resource/csdk/connectivity/src/bt_edr_adapter/android/caedrclient.c

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <jni.h>
  24
  25 #include "caedrinterface.h"
  26 #include "caedrutils.h"
  27 #include "caedrclient.h"
  28 #include "logger.h"
  29 #include "oic_malloc.h"
  30 #include "oic_string.h"
  31 #include "cathreadpool.h" /* for thread pool */
  32 #include "camutex.h"
  33 #include "uarraylist.h"
  34 #include "caadapterutils.h"
  35 #include "caremotehandler.h"
  36
  37 //#define DEBUG_MODE
  38 #define TAG PCF("CA_EDR_CLIENT")
  39
  40 static const char METHODID_CONTEXTNONPARAM[] = "()Landroid/content/Context;";
  41 static const char METHODID_OBJECTNONPARAM[] = "()Landroid/bluetooth/BluetoothAdapter;";
  42 static const char METHODID_OUTPUTNONPARAM[] = "()Ljava/io/OutputStream;";
  43 static const char METHODID_STRINGNONPARAM[] = "()Ljava/lang/String;";
  44 static const char METHODID_BT_DEVICEPARAM[] =
  45         "(Ljava/lang/String;)Landroid/bluetooth/BluetoothDevice;";
  46 static const char CLASSPATH_BT_ADPATER[] = "android/bluetooth/BluetoothAdapter";
  47 static const char CLASSPATH_BT_DEVICE[] = "android/bluetooth/BluetoothDevice";
  48 static const char CLASSPATH_BT_INTERFACE[] = "org/iotivity/ca/CaEdrInterface";
  49 static const char CLASSPATH_BT_SOCKET[] = "android/bluetooth/BluetoothSocket";
  50 static const char CLASSPATH_BT_UUID[] = "java/util/UUID";
  51 static const char CLASSPATH_CONTEXT[] = "android/content/Context";
  52 static const char CLASSPATH_OUTPUT[] = "java/io/OutputStream";
  53
  54 static ca_thread_pool_t g_threadPoolHandle = NULL;
  55
  56 static JavaVM *g_jvm;
  57 static jobject g_context;
  58
  59 /**
  60  * @var g_mutexUnicastServer
  61  * @brief Mutex to synchronize unicast server
  62  */
  63 static ca_mutex g_mutexUnicastServer = NULL;
  64
  65 /**
  66  * @var g_stopUnicast
  67  * @brief Flag to control the Receive Unicast Data Thread
  68  */
  69 static bool g_stopUnicast = false;
  70
  71 /**
  72  * @var g_mutexMulticastServer
  73  * @brief Mutex to synchronize secure multicast server
  74  */
  75 static ca_mutex g_mutexMulticastServer = NULL;
  76
  77 /**
  78  * @var g_stopMulticast
  79  * @brief Flag to control the Receive Multicast Data Thread
  80  */
  81 static bool g_stopMulticast = false;
  82
  83 /**
  84  * @var g_stopAccept
  85  * @brief Flag to control the Accept Thread
  86  */
  87 static bool g_stopAccept = false;
  88
  89 /**
  90  * @var g_mutexStateList
  91  * @brief Mutex to synchronize device state list
  92  */
  93 static ca_mutex g_mutexStateList = NULL;
  94
  95 /**
  96  * @var g_mutexObjectList
  97  * @brief Mutex to synchronize device object list
  98  */
  99 static ca_mutex g_mutexObjectList = NULL;
 100
 101 /**
 102  * @var g_edrErrorHandler
 103  * @brief Error callback to update error in EDR
 104  */
 105 static CAEDRErrorHandleCallback g_edrErrorHandler = NULL;
 106
 107 typedef struct send_data
 108 {
 109     char* address;
 110     char* data;
 111     uint32_t id;
 112 } data_t;
 113
 114 /**
 115  @brief Thread context information for unicast, multicast and secured unicast server
 116  */
 117 typedef struct
 118 {
 119     bool *stopFlag;
 120     CAAdapterServerType_t type;
 121 } CAAdapterReceiveThreadContext_t;
 122
 123 typedef struct
 124 {
 125     bool *stopFlag;
 126 } CAAdapterAcceptThreadContext_t;
 127
 128 /**
 129  * implement for BT-EDR adapter common method
 130  */
 131 CAResult_t CAEDRGetInterfaceInformation(CAEndpoint_t **info)
 132 {
 133     OIC_LOG(DEBUG, TAG, "IN - CAEDRGetInterfaceInformation");
 134
 135     if (!info)
 136     {
 137         OIC_LOG(ERROR, TAG, "endpoint info is null");
 138         return CA_STATUS_INVALID_PARAM;
 139     }
 140
 141     char *macAddress = NULL;
 142     CAResult_t ret = CAEDRGetInterfaceInfo(&macAddress);
 143     if (CA_STATUS_OK != ret)
 144     {
 145         OIC_LOG_V(ERROR, TAG, "Failed to get interface info [%d]", ret);
 146         OICFree(macAddress);
 147         return ret;
 148     }
 149
 150     if (!macAddress)
 151     {
 152         OIC_LOG(ERROR, TAG, "mac address is null");
 153         return CA_STATUS_FAILED;
 154     }
 155     OIC_LOG_V(DEBUG, TAG, "address : %s", macAddress);
 156
 157     // Create local endpoint using util function
 158     CAEndpoint_t *endpoint = CACreateEndpointObject(CA_DEFAULT_FLAGS, CA_ADAPTER_RFCOMM_BTEDR,
 159                                                     macAddress, 0);
 160     if (NULL == endpoint)
 161     {
 162         OIC_LOG(ERROR, TAG, "Failed to create Local Endpoint!");
 163         OICFree(macAddress);
 164         return CA_STATUS_FAILED;
 165     }
 166
 167     // copy unicast server information
 168     int32_t netInfoSize = 1;
 169     CAEndpoint_t *netInfo = (CAEndpoint_t *)OICMalloc(sizeof(CAEndpoint_t) * netInfoSize);
 170     if (NULL == netInfo)
 171     {
 172         OIC_LOG(ERROR, TAG, "Invalid input..");
 173         OICFree(macAddress);
 174         CAFreeEndpoint(endpoint);
 175         return CA_MEMORY_ALLOC_FAILED;
 176     }
 177     *netInfo = *endpoint;
 178     *info = netInfo;
 179
 180     OICFree(macAddress);
 181     CAFreeEndpoint(endpoint);
 182
 183     OIC_LOG(DEBUG, TAG, "OUT - CAEDRGetInterfaceInformation");
 184     return CA_STATUS_OK;
 185 }
 186
 187 void CAEDRClientTerminate()
 188 {
 189     OIC_LOG(DEBUG, TAG, "IN");
 190     CAEDRTerminate();
 191     OIC_LOG(DEBUG, TAG, "OUT");
 192 }
 193
 194 CAResult_t CAEDRManagerReadData()
 195 {
 196     OIC_LOG(DEBUG, TAG, "IN");
 197
 198     OIC_LOG(DEBUG, TAG, "OUT");
 199     return CA_NOT_SUPPORTED;
 200 }
 201
 202 CAResult_t CAEDRClientSendUnicastData(const char *remoteAddress, const uint8_t *data,
 203                                       uint32_t dataLength)
 204 {
 205     VERIFY_NON_NULL(remoteAddress, TAG, "remoteAddress is null");
 206     VERIFY_NON_NULL(data, TAG, "data is null");
 207     OIC_LOG(DEBUG, TAG, "IN");
 208
 209     CAResult_t result = CAEDRSendUnicastMessage(remoteAddress, data, dataLength);
 210     OIC_LOG(DEBUG, TAG, "OUT");
 211     return result;
 212 }
 213
 214 CAResult_t CAEDRClientSendMulticastData(const uint8_t *data, uint32_t dataLength)
 215 {
 216     VERIFY_NON_NULL(data, TAG, "data is null");
 217     OIC_LOG(DEBUG, TAG, "IN");
 218
 219     CAResult_t result = CAEDRSendMulticastMessage(data, dataLength);
 220     OIC_LOG(DEBUG, TAG, "OUT");
 221     return result;
 222 }
 223
 224 // It will be updated when android EDR support is added
 225 void CAEDRClientUnsetCallbacks()
 226 {
 227     OIC_LOG(DEBUG, TAG, "IN");
 228
 229     OIC_LOG(DEBUG, TAG, "OUT");
 230 }
 231
 232 // It will be updated when android EDR support is added
 233 void CAEDRClientDisconnectAll()
 234 {
 235     OIC_LOG(DEBUG, TAG, "IN");
 236
 237     OIC_LOG(DEBUG, TAG, "OUT");
 238 }
 239
 240 CAResult_t CAEDRGetAdapterEnableState(bool *state)
 241 {
 242     OIC_LOG(DEBUG, TAG, "IN");
 243     if (!g_jvm)
 244     {
 245         OIC_LOG(ERROR, TAG, "g_jvm is null");
 246         return CA_STATUS_INVALID_PARAM;
 247     }
 248     bool isAttached = false;
 249     JNIEnv* env;
 250     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 251     if (JNI_OK != res)
 252     {
 253         OIC_LOG(DEBUG, TAG, "CAEDRGetAdapterEnableState - Could not get JNIEnv pointer");
 254         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 255
 256         if (JNI_OK != res)
 257         {
 258             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 259             return CA_STATUS_INVALID_PARAM;
 260         }
 261         isAttached = true;
 262     }
 263     jboolean ret = CAEDRNativeIsEnableBTAdapter(env);
 264     if (ret)
 265     {
 266         *state = true;
 267     }
 268     else
 269     {
 270         *state = false;
 271     }
 272
 273     if (isAttached)
 274     {
 275         (*g_jvm)->DetachCurrentThread(g_jvm);
 276     }
 277
 278     OIC_LOG(DEBUG, TAG, "OUT");
 279     return CA_STATUS_OK;
 280 }
 281
 282 void CAEDRJniInitContext()
 283 {
 284     OIC_LOG(DEBUG, TAG, "CAEDRJniInitContext");
 285
 286     g_context = (jobject) CANativeJNIGetContext();
 287 }
 288
 289 CAResult_t CAEDRCreateJNIInterfaceObject(jobject context)
 290 {
 291     JNIEnv* env;
 292     OIC_LOG(DEBUG, TAG, "[EDRCore] CAEDRCreateJNIInterfaceObject");
 293
 294     if ((*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6) != JNI_OK)
 295     {
 296         OIC_LOG(ERROR, TAG, "[EDRCore] Could not get JNIEnv pointer");
 297         return CA_STATUS_FAILED;
 298     }
 299
 300     //getApplicationContext
 301     jclass contextClass = (*env)->FindClass(env, CLASSPATH_CONTEXT);
 302     if (!contextClass)
 303     {
 304         OIC_LOG(ERROR, TAG, "[EDRCore] Could not get context object class");
 305         return CA_STATUS_FAILED;
 306     }
 307
 308     jmethodID getApplicationContextMethod = (*env)->GetMethodID(env, contextClass,
 309                                                                 "getApplicationContext",
 310                                                                 METHODID_CONTEXTNONPARAM);
 311     if (!getApplicationContextMethod)
 312     {
 313         OIC_LOG(ERROR, TAG, "[EDRCore] Could not get getApplicationContext method");
 314         return CA_STATUS_FAILED;
 315     }
 316
 317     //Create EDRJniInterface instance
 318     jclass EDRJniInterface = (*env)->FindClass(env, CLASSPATH_BT_INTERFACE);
 319     if (!EDRJniInterface)
 320     {
 321         OIC_LOG(ERROR, TAG, "[EDRCore] Could not get CaEdrInterface class");
 322         return CA_STATUS_FAILED;
 323     }
 324
 325     jmethodID EDRInterfaceConstructorMethod = (*env)->GetMethodID(env, EDRJniInterface, "<init>",
 326                                                                   "(Landroid/content/Context;)V");
 327     if (!EDRInterfaceConstructorMethod)
 328     {
 329         OIC_LOG(ERROR, TAG, "[EDRCore] Could not get CaEdrInterface constructor method");
 330         return CA_STATUS_FAILED;
 331     }
 332
 333     (*env)->NewObject(env, EDRJniInterface, EDRInterfaceConstructorMethod, context);
 334     OIC_LOG(DEBUG, TAG, "[EDRCore] NewObject Success");
 335
 336     return CA_STATUS_OK;
 337
 338 }
 339
 340 static void CAEDRDestroyMutex()
 341 {
 342     OIC_LOG(DEBUG, TAG, "IN");
 343
 344     if (g_mutexUnicastServer)
 345     {
 346         ca_mutex_free(g_mutexUnicastServer);
 347         g_mutexUnicastServer = NULL;
 348     }
 349
 350     if (g_mutexMulticastServer)
 351     {
 352         ca_mutex_free(g_mutexMulticastServer);
 353         g_mutexMulticastServer = NULL;
 354     }
 355
 356     if (g_mutexStateList)
 357     {
 358         ca_mutex_free(g_mutexStateList);
 359         g_mutexStateList = NULL;
 360     }
 361
 362     if (g_mutexObjectList)
 363     {
 364         ca_mutex_free(g_mutexObjectList);
 365         g_mutexObjectList = NULL;
 366     }
 367     OIC_LOG(DEBUG, TAG, "OUT");
 368 }
 369
 370 static CAResult_t CAEDRCreateMutex()
 371 {
 372     OIC_LOG(DEBUG, TAG, "IN");
 373
 374     g_mutexUnicastServer = ca_mutex_new();
 375     if (!g_mutexUnicastServer)
 376     {
 377         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 378         return CA_STATUS_FAILED;
 379     }
 380
 381     g_mutexMulticastServer = ca_mutex_new();
 382     if (!g_mutexMulticastServer)
 383     {
 384         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 385
 386         CAEDRDestroyMutex();
 387         return CA_STATUS_FAILED;
 388     }
 389
 390     g_mutexStateList = ca_mutex_new();
 391     if (!g_mutexStateList)
 392     {
 393         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 394
 395         CAEDRDestroyMutex();
 396         return CA_STATUS_FAILED;
 397     }
 398
 399     g_mutexObjectList = ca_mutex_new();
 400     if (!g_mutexObjectList)
 401     {
 402         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 403
 404         CAEDRDestroyMutex();
 405         return CA_STATUS_FAILED;
 406     }
 407
 408     OIC_LOG(DEBUG, TAG, "OUT");
 409     return CA_STATUS_OK;
 410 }
 411
 412 void CAEDRInitialize(ca_thread_pool_t handle)
 413 {
 414     OIC_LOG(DEBUG, TAG, "CAEDRInitialize");
 415
 416     g_threadPoolHandle = handle;
 417
 418     CAEDRCoreJniInit();
 419
 420     CAEDRJniInitContext();
 421
 422     // init mutex
 423     CAEDRCreateMutex();
 424
 425     bool isAttached = false;
 426     JNIEnv* env;
 427     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 428     if (JNI_OK != res)
 429     {
 430         OIC_LOG(DEBUG, TAG, "CAEDRInitialize - Could not get JNIEnv pointer");
 431         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 432
 433         if (JNI_OK != res)
 434         {
 435             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 436             return;
 437         }
 438         isAttached = true;
 439     }
 440     jstring jni_address = CAEDRNativeGetLocalDeviceAddress(env);
 441     if (jni_address)
 442     {
 443         const char* localAddress = (*env)->GetStringUTFChars(env, jni_address, NULL);
 444         OIC_LOG_V(DEBUG, TAG, "My BT Address is %s", localAddress);
 445         (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
 446     }
 447
 448     ca_mutex_lock(g_mutexStateList);
 449     CAEDRNativeCreateDeviceStateList();
 450     ca_mutex_unlock(g_mutexStateList);
 451
 452     ca_mutex_lock(g_mutexObjectList);
 453     CAEDRNativeCreateDeviceSocketList();
 454     ca_mutex_unlock(g_mutexObjectList);
 455
 456     if (isAttached)
 457     {
 458         (*g_jvm)->DetachCurrentThread(g_jvm);
 459     }
 460
 461     if (g_context)
 462     {
 463         CAEDRCreateJNIInterfaceObject(g_context); /* create java CaEdrInterface instance*/
 464     }
 465
 466     OIC_LOG(DEBUG, TAG, "OUT");
 467 }
 468
 469 void CAEDRTerminate()
 470 {
 471     OIC_LOG(DEBUG, TAG, "CAEDRTerminate");
 472
 473     bool isAttached = false;
 474     JNIEnv* env;
 475     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 476     if (JNI_OK != res)
 477     {
 478         OIC_LOG(DEBUG, TAG, "CAEDRTerminate - Could not get JNIEnv pointer");
 479         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 480
 481         if (JNI_OK != res)
 482         {
 483             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 484             return;
 485         }
 486         isAttached = true;
 487     }
 488
 489     g_stopAccept = true;
 490     g_stopMulticast = true;
 491     g_stopUnicast = true;
 492
 493     if (isAttached)
 494     {
 495         (*g_jvm)->DetachCurrentThread(g_jvm);
 496     }
 497
 498     if (g_context)
 499     {
 500         (*env)->DeleteGlobalRef(env, g_context);
 501     }
 502
 503     CAEDRNativeSocketCloseToAll(env);
 504
 505     // delete mutex
 506     CAEDRDestroyMutex();
 507
 508     CAEDRNativeRemoveAllDeviceState();
 509     CAEDRNativeRemoveAllDeviceSocket(env);
 510 }
 511
 512 void CAEDRCoreJniInit()
 513 {
 514     OIC_LOG(DEBUG, TAG, "CAEdrClientJniInit");
 515     g_jvm = (JavaVM*) CANativeJNIGetJavaVM();
 516 }
 517
 518 CAResult_t CAEDRSendUnicastMessage(const char* address, const uint8_t* data, uint32_t dataLen)
 519 {
 520     VERIFY_NON_NULL(address, TAG, "address is null");
 521     VERIFY_NON_NULL(data, TAG, "data is null");
 522
 523     CAResult_t result = CAEDRSendUnicastMessageImpl(address, data, dataLen);
 524     return result;
 525 }
 526
 527 CAResult_t CAEDRSendMulticastMessage(const uint8_t* data, uint32_t dataLen)
 528 {
 529     VERIFY_NON_NULL(data, TAG, "data is null");
 530     OIC_LOG_V(DEBUG, TAG, "CAEDRSendMulticastMessage(%s)", data);
 531
 532     bool isAttached = false;
 533     JNIEnv* env;
 534     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 535     if (JNI_OK != res)
 536     {
 537         OIC_LOG(DEBUG, TAG, "CAEDRSendMulticastMessage - Could not get JNIEnv pointer");
 538         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 539
 540         if (JNI_OK != res)
 541         {
 542             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 543             return CA_STATUS_INVALID_PARAM;
 544         }
 545         isAttached = true;
 546     }
 547
 548     CAResult_t result = CAEDRSendMulticastMessageImpl(env, data, dataLen);
 549     if(CA_STATUS_OK != result)
 550     {
 551         OIC_LOG(ERROR, TAG, "CAEDRSendMulticastMessage - could not send multicast message");
 552         return result;
 553     }
 554
 555     OIC_LOG(DEBUG, TAG, "sent data");
 556
 557     if (isAttached)
 558     {
 559         OIC_LOG(DEBUG, TAG, "DetachCurrentThread");
 560         (*g_jvm)->DetachCurrentThread(g_jvm);
 561     }
 562
 563     OIC_LOG(DEBUG, TAG, "OUT - CAEDRSendMulticastMessage");
 564     return CA_STATUS_OK;
 565 }
 566
 567 CAResult_t CAEDRGetInterfaceInfo(char **address)
 568 {
 569     CAEDRGetLocalAddress(address);
 570     return CA_STATUS_OK;
 571 }
 572
 573 void CAEDRGetLocalAddress(char **address)
 574 {
 575     bool isAttached = false;
 576     JNIEnv* env;
 577     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 578     if (JNI_OK != res)
 579     {
 580         OIC_LOG(DEBUG, TAG, "CAEDRGetLocalAddress - Could not get JNIEnv pointer");
 581         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 582         if (JNI_OK != res)
 583         {
 584             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 585             return;
 586         }
 587         isAttached = true;
 588     }
 589
 590     jstring jni_address = CAEDRNativeGetLocalDeviceAddress(env);
 591     if (jni_address)
 592     {
 593         const char* localAddress = (*env)->GetStringUTFChars(env, jni_address, NULL);
 594         *address = OICStrdup(localAddress);
 595         if (*address == NULL)
 596         {
 597             if (isAttached)
 598             {
 599                 (*g_jvm)->DetachCurrentThread(g_jvm);
 600             }
 601             (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
 602             (*env)->DeleteLocalRef(env, jni_address);
 603             return;
 604         }
 605
 606         (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
 607         (*env)->DeleteLocalRef(env, jni_address);
 608     }
 609
 610     OIC_LOG_V(DEBUG, TAG, "Local Address : %s", *address);
 611     if (isAttached)
 612     {
 613         (*g_jvm)->DetachCurrentThread(g_jvm);
 614     }
 615 }
 616
 617 CAResult_t CAEDRSendUnicastMessageImpl(const char* address, const uint8_t* data, uint32_t dataLen)
 618 {
 619     VERIFY_NON_NULL(address, TAG, "address is null");
 620     VERIFY_NON_NULL(data, TAG, "data is null");
 621     OIC_LOG_V(DEBUG, TAG, "CAEDRSendUnicastMessageImpl, address: %s, data: %s", address, data);
 622
 623     bool isAttached = false;
 624     JNIEnv* env;
 625     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 626     if (JNI_OK != res)
 627     {
 628         OIC_LOG(DEBUG, TAG, "CAEDRSendUnicastMessageImpl - Could not get JNIEnv pointer");
 629         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 630         if (JNI_OK != res)
 631         {
 632             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 633             return CA_STATUS_INVALID_PARAM;
 634         }
 635         isAttached = true;
 636     }
 637
 638     OIC_LOG(DEBUG, TAG, "[EDR][Native] set byteArray for data");
 639
 640     // get bonded device list
 641     jobjectArray jni_arrayPairedDevices = CAEDRNativeGetBondedDevices(env);
 642     if (!jni_arrayPairedDevices)
 643     {
 644         OIC_LOG(ERROR, TAG, "[EDR][Native] jni_arrayPairedDevices is empty");
 645         if (isAttached)
 646         {
 647             (*g_jvm)->DetachCurrentThread(g_jvm);
 648         }
 649         return CA_STATUS_INVALID_PARAM;
 650     }
 651     // Get information from array of devices
 652     jclass jni_cid_BTDevice = (*env)->FindClass(env, CLASSPATH_BT_DEVICE);
 653     jmethodID j_mid_getName = (*env)->GetMethodID(env, jni_cid_BTDevice, "getName",
 654                                                   METHODID_STRINGNONPARAM);
 655     jmethodID j_mid_getAddress = (*env)->GetMethodID(env, jni_cid_BTDevice, "getAddress",
 656                                                      METHODID_STRINGNONPARAM);
 657
 658     jsize length = (*env)->GetArrayLength(env, jni_arrayPairedDevices);
 659     jsize i;
 660     for (i = 0; i < length; i++)
 661     {
 662         OIC_LOG(DEBUG, TAG, "[EDR][Native] start to check device");
 663         // get name, address from BT device
 664         jobject j_obj_device = (*env)->GetObjectArrayElement(env, jni_arrayPairedDevices, i);
 665         jstring j_str_name = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getName);
 666
 667         if (j_str_name)
 668         {
 669             const char * name = (*env)->GetStringUTFChars(env, j_str_name, NULL);
 670             OIC_LOG_V(DEBUG, TAG, "[EDR][Native] getBondedDevices: ~~device name is %s", name);
 671             (*env)->ReleaseStringUTFChars(env, j_str_name, name);
 672             (*env)->DeleteLocalRef(env, j_str_name);
 673         }
 674
 675         jstring j_str_address = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getAddress);
 676         const char * remoteAddress = (*env)->GetStringUTFChars(env, j_str_address, NULL);
 677         if (!remoteAddress)
 678         {
 679             OIC_LOG(ERROR, TAG, "[EDR][Native] remoteAddress is null");
 680             if (isAttached)
 681             {
 682                 (*g_jvm)->DetachCurrentThread(g_jvm);
 683             }
 684
 685             (*env)->DeleteLocalRef(env, j_str_address);
 686             (*env)->DeleteLocalRef(env, j_obj_device);
 687             (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 688             (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 689             return CA_STATUS_INVALID_PARAM;
 690         }
 691         OIC_LOG_V(DEBUG, TAG,
 692                   "[EDR][Native] getBondedDevices: ~~device address is %s", remoteAddress);
 693
 694         // find address
 695         if (!strcmp(remoteAddress, address))
 696         {
 697             CAResult_t res = CAEDRNativeSendData(env, remoteAddress, data, dataLen);
 698             if (CA_STATUS_OK != res)
 699             {
 700                 (*env)->ReleaseStringUTFChars(env, j_str_address, remoteAddress);
 701                 (*env)->DeleteLocalRef(env, j_str_address);
 702                 (*env)->DeleteLocalRef(env, j_obj_device);
 703                 (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 704                 (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 705                 return res;
 706             }
 707         }
 708         (*env)->ReleaseStringUTFChars(env, j_str_address, remoteAddress);
 709         (*env)->DeleteLocalRef(env, j_str_address);
 710         (*env)->DeleteLocalRef(env, j_obj_device);
 711     }
 712
 713     (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 714     (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 715
 716     if (isAttached)
 717     {
 718         (*g_jvm)->DetachCurrentThread(g_jvm);
 719     }
 720
 721     return CA_STATUS_OK;
 722 }
 723
 724 CAResult_t CAEDRSendMulticastMessageImpl(JNIEnv *env, const uint8_t* data, uint32_t dataLen)
 725 {
 726     VERIFY_NON_NULL(data, TAG, "data is null");
 727     OIC_LOG_V(DEBUG, TAG, "CASendMulticastMessageImpl, send to, data: %s, %d", data, dataLen);
 728
 729     // get bonded device list
 730     jobjectArray jni_arrayPairedDevices = CAEDRNativeGetBondedDevices(env);
 731     if (!jni_arrayPairedDevices)
 732     {
 733         OIC_LOG(ERROR, TAG, "[EDR][Native] jni_arrayPairedDevices is empty");
 734         return CA_STATUS_INVALID_PARAM;
 735     }
 736     // Get information from array of devices
 737     jclass jni_cid_BTDevice = (*env)->FindClass(env, CLASSPATH_BT_DEVICE);
 738     jmethodID j_mid_getName = (*env)->GetMethodID(env, jni_cid_BTDevice, "getName",
 739                                                   METHODID_STRINGNONPARAM);
 740     jmethodID j_mid_getAddress = (*env)->GetMethodID(env, jni_cid_BTDevice, "getAddress",
 741                                                      METHODID_STRINGNONPARAM);
 742
 743     jsize length = (*env)->GetArrayLength(env, jni_arrayPairedDevices);
 744     jsize i;
 745     for (i = 0; i < length; i++)
 746     {
 747         // get name, address from BT device
 748         jobject j_obj_device = (*env)->GetObjectArrayElement(env, jni_arrayPairedDevices, i);
 749         jstring j_str_name = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getName);
 750
 751         if (j_str_name)
 752         {
 753             const char * name = (*env)->GetStringUTFChars(env, j_str_name, NULL);
 754             OIC_LOG_V(DEBUG, TAG, "[EDR][Native] getBondedDevices: ~~device name is %s", name);
 755             (*env)->ReleaseStringUTFChars(env, j_str_name, name);
 756             (*env)->DeleteLocalRef(env, j_str_name);
 757         }
 758
 759         jstring j_str_address = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getAddress);
 760         const char * remoteAddress = (*env)->GetStringUTFChars(env, j_str_address, NULL);
 761         OIC_LOG_V(DEBUG, TAG,
 762                   "[EDR][Native] getBondedDevices: ~~device address is %s", remoteAddress);
 763
 764         // find address
 765         CAResult_t res = CAEDRNativeSendData(env, remoteAddress, data, dataLen);
 766         (*env)->ReleaseStringUTFChars(env, j_str_address, remoteAddress);
 767         (*env)->DeleteLocalRef(env, j_str_address);
 768         if (CA_STATUS_OK != res)
 769         {
 770             OIC_LOG_V(ERROR, TAG, "CASendMulticastMessageImpl, failed to send message to : %s",
 771                       remoteAddress);
 772             g_edrErrorHandler(remoteAddress, data, dataLen, res);
 773             continue;
 774         }
 775     }
 776
 777     (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 778     (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 779
 780     return CA_STATUS_OK;
 781 }
 782
 783 /**
 784  * EDR Method
 785  */
 786 CAResult_t CAEDRNativeSendData(JNIEnv *env, const char *address, const uint8_t *data,
 787                                uint32_t dataLength)
 788 {
 789     VERIFY_NON_NULL(address, TAG, "address is null");
 790     VERIFY_NON_NULL(data, TAG, "data is null");
 791     OIC_LOG_V(DEBUG, TAG, "[EDR][Native] btSendData logic start : %s, %d", data, dataLength);
 792
 793     if (!CAEDRNativeIsEnableBTAdapter(env))
 794     {
 795         OIC_LOG(ERROR, TAG, "BT adpater is not enable");
 796         return CA_STATUS_INVALID_PARAM;
 797     }
 798
 799     if (STATE_DISCONNECTED == CAEDRIsConnectedDevice(address))
 800     {
 801         // connect before send data
 802         OIC_LOG(DEBUG, TAG, "[EDR][Native] connect before send data");
 803
 804         CAResult_t res = CAEDRNativeConnect(env, address);
 805         if (CA_STATUS_OK != res)
 806         {
 807             return res;
 808         }
 809     }
 810
 811     if (STATE_CONNECTED == CAEDRIsConnectedDevice(address))
 812     {
 813         if (!((*env)->ExceptionCheck(env)))
 814         {
 815             jclass jni_cid_BTsocket = (*env)->FindClass(env, CLASSPATH_BT_SOCKET);
 816             if (!jni_cid_BTsocket)
 817             {
 818                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_cid_BTsocket is null");
 819                 return CA_STATUS_FAILED;
 820             }
 821
 822             jmethodID jni_mid_getOutputStream = (*env)->GetMethodID(env, jni_cid_BTsocket,
 823                                                                     "getOutputStream",
 824                                                                     METHODID_OUTPUTNONPARAM);
 825             if (!jni_mid_getOutputStream)
 826             {
 827                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_mid_getOutputStream is null");
 828                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 829                 return CA_STATUS_FAILED;
 830             }
 831
 832             OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: Get MethodID for i/o stream");
 833
 834             jobject jni_obj_socket = CAEDRNativeGetDeviceSocketBaseAddr(env, address);
 835             if (!jni_obj_socket)
 836             {
 837                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_socket is not available");
 838                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 839                 return CA_STATUS_FAILED;
 840             }
 841
 842             jobject jni_obj_outputStream = (*env)->CallObjectMethod(env, jni_obj_socket,
 843                                                                     jni_mid_getOutputStream);
 844             if (!jni_obj_outputStream)
 845             {
 846                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_obj_outputStream is null");
 847                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 848                 return CA_STATUS_FAILED;
 849             }
 850
 851             OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: ready outputStream..");
 852
 853             jclass jni_cid_OutputStream = (*env)->FindClass(env, CLASSPATH_OUTPUT);
 854             if (!jni_cid_OutputStream)
 855             {
 856                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_cid_OutputStream is null");
 857                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 858                 (*env)->DeleteLocalRef(env, jni_obj_outputStream);
 859                 return CA_STATUS_FAILED;
 860             }
 861
 862             jmethodID jni_mid_write = (*env)->GetMethodID(env, jni_cid_OutputStream, "write",
 863                                                           "([BII)V");
 864             if (!jni_mid_write)
 865             {
 866                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_mid_write is null");
 867                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 868                 (*env)->DeleteLocalRef(env, jni_obj_outputStream);
 869                 (*env)->DeleteLocalRef(env, jni_cid_OutputStream);
 870                 return CA_STATUS_FAILED;
 871             }
 872
 873             jbyteArray jbuf = (*env)->NewByteArray(env, dataLength);
 874             (*env)->SetByteArrayRegion(env, jbuf, 0, dataLength, (jbyte*) data);
 875
 876             (*env)->CallVoidMethod(env, jni_obj_outputStream, jni_mid_write, jbuf, (jint) 0,
 877                                    (jint) dataLength);
 878
 879             (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 880             (*env)->DeleteLocalRef(env, jni_obj_outputStream);
 881             (*env)->DeleteLocalRef(env, jni_cid_OutputStream);
 882             (*env)->DeleteLocalRef(env, jbuf);
 883
 884             if ((*env)->ExceptionCheck(env))
 885             {
 886                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: Write Error!!!");
 887                 (*env)->ExceptionDescribe(env);
 888                 (*env)->ExceptionClear(env);
 889                 return CA_STATUS_FAILED;
 890             }
 891
 892             OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: Write Success");
 893         }
 894         else
 895         {
 896             (*env)->ExceptionDescribe(env);
 897             (*env)->ExceptionClear(env);
 898             OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: error!!");
 899             return CA_STATUS_FAILED;
 900         }
 901     }
 902     else
 903     {
 904         OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: BT connection is not completed!!");
 905     }
 906
 907     return CA_STATUS_OK;
 908 }
 909
 910 CAResult_t CAEDRNativeConnect(JNIEnv *env, const char *address)
 911 {
 912     VERIFY_NON_NULL(address, TAG, "address is null");
 913     OIC_LOG(DEBUG, TAG, "[EDR][Native] btConnect..");
 914
 915     if (!CAEDRNativeIsEnableBTAdapter(env))
 916     {
 917         OIC_LOG(ERROR, TAG, "BT adpater is not enable");
 918         return CA_STATUS_INVALID_PARAM;
 919     }
 920
 921     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
 922     if (!jni_cid_BTAdapter)
 923     {
 924         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_BTAdapter is null");
 925         return CA_STATUS_FAILED;
 926     }
 927
 928     // get BTadpater
 929     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 930                                                                     "getDefaultAdapter",
 931                                                                     METHODID_OBJECTNONPARAM);
 932     if (!jni_mid_getDefaultAdapter)
 933     {
 934         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_getDefaultAdapter is null");
 935         return CA_STATUS_FAILED;
 936     }
 937
 938     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 939                                                                jni_mid_getDefaultAdapter);
 940     if (!jni_obj_BTAdapter)
 941     {
 942         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_BTAdapter is null");
 943         return CA_STATUS_FAILED;
 944     }
 945
 946     // get remote bluetooth device
 947     jmethodID jni_mid_getRemoteDevice = (*env)->GetMethodID(env, jni_cid_BTAdapter,
 948                                                             "getRemoteDevice",
 949                                                             METHODID_BT_DEVICEPARAM);
 950     if (!jni_mid_getRemoteDevice)
 951     {
 952         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_getRemoteDevice is null");
 953         return CA_STATUS_FAILED;
 954     }
 955
 956     jstring jni_address = (*env)->NewStringUTF(env, address);
 957     jobject jni_obj_remoteBTDevice = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
 958                                                               jni_mid_getRemoteDevice, jni_address);
 959     if (!jni_obj_remoteBTDevice)
 960     {
 961         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_remoteBTDevice is null");
 962         return CA_STATUS_FAILED;
 963     }
 964
 965     // get create Rfcomm Socket method ID
 966     jclass jni_cid_BluetoothDevice = (*env)->FindClass(env, CLASSPATH_BT_DEVICE);
 967     if (!jni_cid_BluetoothDevice)
 968     {
 969         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_BluetoothDevice is null");
 970         return CA_STATUS_FAILED;
 971     }
 972
 973     jmethodID jni_mid_createSocket = (*env)->GetMethodID(
 974             env, jni_cid_BluetoothDevice, "createInsecureRfcommSocketToServiceRecord",
 975             "(Ljava/util/UUID;)Landroid/bluetooth/BluetoothSocket;");
 976     if (!jni_mid_createSocket)
 977     {
 978         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_createSocket is null");
 979         return CA_STATUS_FAILED;
 980     }
 981
 982     // setting UUID
 983     jclass jni_cid_uuid = (*env)->FindClass(env, CLASSPATH_BT_UUID);
 984     if (!jni_cid_uuid)
 985     {
 986         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_uuid is null");
 987         return CA_STATUS_FAILED;
 988     }
 989
 990     jmethodID jni_mid_fromString = (*env)->GetStaticMethodID(
 991             env, jni_cid_uuid, "fromString", "(Ljava/lang/String;)Ljava/util/UUID;");
 992     if (!jni_mid_fromString)
 993     {
 994         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_fromString is null");
 995         return CA_STATUS_FAILED;
 996     }
 997
 998     jstring jni_uuid = (*env)->NewStringUTF(env, OIC_EDR_SERVICE_ID);
 999     if (!jni_uuid)
1000     {
1001         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_uuid is null");
1002         return CA_STATUS_FAILED;
1003     }
1004     jobject jni_obj_uuid = (*env)->CallStaticObjectMethod(env, jni_cid_uuid, jni_mid_fromString,
1005                                                           jni_uuid);
1006     if (!jni_obj_uuid)
1007     {
1008         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_uuid is null");
1009         return CA_STATUS_FAILED;
1010     }
1011     // create socket
1012     jobject jni_obj_BTSocket = (*env)->CallObjectMethod(env, jni_obj_remoteBTDevice,
1013                                                         jni_mid_createSocket, jni_obj_uuid);
1014     if (!jni_obj_BTSocket)
1015     {
1016         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_BTSocket is null");
1017         return CA_STATUS_FAILED;
1018     }
1019
1020     // connect
1021     jclass jni_cid_BTSocket = (*env)->FindClass(env, CLASSPATH_BT_SOCKET);
1022     if (!jni_cid_BTSocket)
1023     {
1024         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_BTSocket is null");
1025         return CA_STATUS_FAILED;
1026     }
1027
1028     jmethodID jni_mid_connect = (*env)->GetMethodID(env, jni_cid_BTSocket, "connect", "()V");
1029     if (!jni_mid_connect)
1030     {
1031         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_connect is null");
1032         return CA_STATUS_FAILED;
1033     }
1034
1035     OIC_LOG(DEBUG, TAG, "[EDR][Native] btConnect: initiating connection...");
1036     (*env)->CallVoidMethod(env, jni_obj_BTSocket, jni_mid_connect);
1037
1038     if ((*env)->ExceptionCheck(env))
1039     {
1040         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: Connect is Failed!!!");
1041         (*env)->ExceptionDescribe(env);
1042         (*env)->ExceptionClear(env);
1043         return CA_STATUS_FAILED;
1044     }
1045
1046     // set socket to list
1047     jobject jni_socket = (*env)->NewGlobalRef(env, jni_obj_BTSocket);
1048     if (!jni_socket)
1049     {
1050         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_socket is null");
1051         return CA_STATUS_FAILED;
1052     }
1053     ca_mutex_lock(g_mutexObjectList);
1054     CAEDRNativeAddDeviceSocketToList(env, jni_socket);
1055     ca_mutex_unlock(g_mutexObjectList);
1056
1057     // update state
1058     ca_mutex_lock(g_mutexStateList);
1059     CAEDRUpdateDeviceState(STATE_CONNECTED, address);
1060     ca_mutex_unlock(g_mutexStateList);
1061
1062     OIC_LOG(DEBUG, TAG, "[EDR][Native] btConnect: connected");
1063
1064     return CA_STATUS_OK;
1065 }
1066
1067 void CAEDRNativeSocketClose(JNIEnv *env, const char *address)
1068 {
1069     VERIFY_NON_NULL_VOID(address, TAG, "address is null");
1070
1071     jclass jni_cid_BTSocket = (*env)->FindClass(env, "android/bluetooth/BluetoothSocket");
1072     if (!jni_cid_BTSocket)
1073     {
1074         OIC_LOG(ERROR, TAG, "[EDR][Native] close: jni_cid_BTSocket is null");
1075         return;
1076     }
1077
1078     jmethodID jni_mid_close = (*env)->GetMethodID(env, jni_cid_BTSocket, "close", "()V");
1079     if (!jni_mid_close)
1080     {
1081         OIC_LOG(ERROR, TAG, "[EDR][Native] close: jni_mid_close is null");
1082         return;
1083     }
1084
1085     jobject jni_obj_socket = CAEDRNativeGetDeviceSocketBaseAddr(env, address);
1086     if (!jni_obj_socket)
1087     {
1088         OIC_LOG(ERROR, TAG, "[EDR][Native] close: jni_obj_socket is not available");
1089         return;
1090     }
1091
1092     (*env)->CallVoidMethod(env, jni_obj_socket, jni_mid_close);
1093
1094     if ((*env)->ExceptionCheck(env))
1095     {
1096         OIC_LOG(ERROR, TAG, "[EDR][Native] close: close is Failed!!!");
1097         (*env)->ExceptionDescribe(env);
1098         (*env)->ExceptionClear(env);
1099         return;
1100     }
1101
1102     // remove socket to list
1103     CAEDRNativeRemoveDeviceSocket(env, jni_obj_socket);
1104
1105     // update state
1106     ca_mutex_lock(g_mutexStateList);
1107     CAEDRUpdateDeviceState(STATE_DISCONNECTED, address);
1108     ca_mutex_unlock(g_mutexStateList);
1109
1110     OIC_LOG(DEBUG, TAG, "[EDR][Native] close: disconnected");
1111 }
1112
1113 void CAEDRInitializeClient(ca_thread_pool_t handle)
1114 {
1115     OIC_LOG(DEBUG, TAG, "IN");
1116     CAEDRInitialize(handle);
1117     OIC_LOG(DEBUG, TAG, "OUT");
1118 }
1119
1120 void CAEDRSetErrorHandler(CAEDRErrorHandleCallback errorHandleCallback)
1121 {
1122     g_edrErrorHandler = errorHandleCallback;
1123 }