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     for (jsize i = 0; i < length; i++)
 660     {
 661         OIC_LOG(DEBUG, TAG, "[EDR][Native] start to check device");
 662         // get name, address from BT device
 663         jobject j_obj_device = (*env)->GetObjectArrayElement(env, jni_arrayPairedDevices, i);
 664         jstring j_str_name = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getName);
 665
 666         if (j_str_name)
 667         {
 668             const char * name = (*env)->GetStringUTFChars(env, j_str_name, NULL);
 669             OIC_LOG_V(DEBUG, TAG, "[EDR][Native] getBondedDevices: ~~device name is %s", name);
 670             (*env)->ReleaseStringUTFChars(env, j_str_name, name);
 671             (*env)->DeleteLocalRef(env, j_str_name);
 672         }
 673
 674         jstring j_str_address = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getAddress);
 675         const char * remoteAddress = (*env)->GetStringUTFChars(env, j_str_address, NULL);
 676         (*env)->DeleteLocalRef(env, j_obj_device);
 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, jni_arrayPairedDevices);
 687             (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 688             return CA_STATUS_INVALID_PARAM;
 689         }
 690         OIC_LOG_V(DEBUG, TAG,
 691                   "[EDR][Native] getBondedDevices: ~~device address is %s", remoteAddress);
 692
 693         // find address
 694         if (!strcmp(remoteAddress, address))
 695         {
 696             CAResult_t res = CAEDRNativeSendData(env, remoteAddress, data, dataLen);
 697             (*env)->ReleaseStringUTFChars(env, j_str_address, remoteAddress);
 698             (*env)->DeleteLocalRef(env, j_str_address);
 699             if (CA_STATUS_OK != res)
 700             {
 701                 (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 702                 (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 703                 return res;
 704             }
 705             break;
 706         }
 707         (*env)->ReleaseStringUTFChars(env, j_str_address, remoteAddress);
 708         (*env)->DeleteLocalRef(env, j_str_address);
 709     }
 710
 711     (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 712     (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 713
 714     if (isAttached)
 715     {
 716         (*g_jvm)->DetachCurrentThread(g_jvm);
 717     }
 718
 719     return CA_STATUS_OK;
 720 }
 721
 722 CAResult_t CAEDRSendMulticastMessageImpl(JNIEnv *env, const uint8_t* data, uint32_t dataLen)
 723 {
 724     VERIFY_NON_NULL(data, TAG, "data is null");
 725     OIC_LOG_V(DEBUG, TAG, "CASendMulticastMessageImpl, send to, data: %s, %d", data, dataLen);
 726
 727     // get bonded device list
 728     jobjectArray jni_arrayPairedDevices = CAEDRNativeGetBondedDevices(env);
 729     if (!jni_arrayPairedDevices)
 730     {
 731         OIC_LOG(ERROR, TAG, "[EDR][Native] jni_arrayPairedDevices is empty");
 732         return CA_STATUS_INVALID_PARAM;
 733     }
 734     // Get information from array of devices
 735     jclass jni_cid_BTDevice = (*env)->FindClass(env, CLASSPATH_BT_DEVICE);
 736     jmethodID j_mid_getName = (*env)->GetMethodID(env, jni_cid_BTDevice, "getName",
 737                                                   METHODID_STRINGNONPARAM);
 738     jmethodID j_mid_getAddress = (*env)->GetMethodID(env, jni_cid_BTDevice, "getAddress",
 739                                                      METHODID_STRINGNONPARAM);
 740
 741     jsize length = (*env)->GetArrayLength(env, jni_arrayPairedDevices);
 742     for (jsize i = 0; i < length; i++)
 743     {
 744         // get name, address from BT device
 745         jobject j_obj_device = (*env)->GetObjectArrayElement(env, jni_arrayPairedDevices, i);
 746         jstring j_str_name = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getName);
 747
 748         if (j_str_name)
 749         {
 750             const char * name = (*env)->GetStringUTFChars(env, j_str_name, NULL);
 751             OIC_LOG_V(DEBUG, TAG, "[EDR][Native] getBondedDevices: ~~device name is %s", name);
 752             (*env)->ReleaseStringUTFChars(env, j_str_name, name);
 753             (*env)->DeleteLocalRef(env, j_str_name);
 754         }
 755
 756         jstring j_str_address = (*env)->CallObjectMethod(env, j_obj_device, j_mid_getAddress);
 757         const char * remoteAddress = (*env)->GetStringUTFChars(env, j_str_address, NULL);
 758         (*env)->DeleteLocalRef(env, j_obj_device);
 759         OIC_LOG_V(DEBUG, TAG,
 760                   "[EDR][Native] getBondedDevices: ~~device address is %s", remoteAddress);
 761
 762         // find address
 763         CAResult_t res = CAEDRNativeSendData(env, remoteAddress, data, dataLen);
 764         (*env)->ReleaseStringUTFChars(env, j_str_address, remoteAddress);
 765         (*env)->DeleteLocalRef(env, j_str_address);
 766         if (CA_STATUS_OK != res)
 767         {
 768             OIC_LOG_V(ERROR, TAG, "CASendMulticastMessageImpl, failed to send message to : %s",
 769                       remoteAddress);
 770             g_edrErrorHandler(remoteAddress, data, dataLen, res);
 771             continue;
 772         }
 773     }
 774
 775     (*env)->DeleteLocalRef(env, jni_arrayPairedDevices);
 776     (*env)->DeleteLocalRef(env, jni_cid_BTDevice);
 777
 778     return CA_STATUS_OK;
 779 }
 780
 781 /**
 782  * EDR Method
 783  */
 784 CAResult_t CAEDRNativeSendData(JNIEnv *env, const char *address, const uint8_t *data,
 785                                uint32_t dataLength)
 786 {
 787     VERIFY_NON_NULL(address, TAG, "address is null");
 788     VERIFY_NON_NULL(data, TAG, "data is null");
 789     OIC_LOG_V(DEBUG, TAG, "[EDR][Native] btSendData logic start : %s, %d", data, dataLength);
 790
 791     if (!CAEDRNativeIsEnableBTAdapter(env))
 792     {
 793         OIC_LOG(ERROR, TAG, "BT adpater is not enable");
 794         return CA_STATUS_INVALID_PARAM;
 795     }
 796
 797     if (STATE_DISCONNECTED == CAEDRIsConnectedDevice(address))
 798     {
 799         // connect before send data
 800         OIC_LOG(DEBUG, TAG, "[EDR][Native] connect before send data");
 801
 802         CAResult_t res = CAEDRNativeConnect(env, address);
 803         if (CA_STATUS_OK != res)
 804         {
 805             return res;
 806         }
 807     }
 808
 809     if (STATE_CONNECTED == CAEDRIsConnectedDevice(address))
 810     {
 811         if (!((*env)->ExceptionCheck(env)))
 812         {
 813             jclass jni_cid_BTsocket = (*env)->FindClass(env, CLASSPATH_BT_SOCKET);
 814             if (!jni_cid_BTsocket)
 815             {
 816                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_cid_BTsocket is null");
 817                 return CA_STATUS_FAILED;
 818             }
 819
 820             jmethodID jni_mid_getOutputStream = (*env)->GetMethodID(env, jni_cid_BTsocket,
 821                                                                     "getOutputStream",
 822                                                                     METHODID_OUTPUTNONPARAM);
 823             if (!jni_mid_getOutputStream)
 824             {
 825                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_mid_getOutputStream is null");
 826                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 827                 return CA_STATUS_FAILED;
 828             }
 829
 830             OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: Get MethodID for i/o stream");
 831
 832             jobject jni_obj_socket = CAEDRNativeGetDeviceSocketBaseAddr(env, address);
 833             if (!jni_obj_socket)
 834             {
 835                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_socket is not available");
 836                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 837                 return CA_STATUS_FAILED;
 838             }
 839
 840             jobject jni_obj_outputStream = (*env)->CallObjectMethod(env, jni_obj_socket,
 841                                                                     jni_mid_getOutputStream);
 842             if (!jni_obj_outputStream)
 843             {
 844                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_obj_outputStream is null");
 845                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 846                 return CA_STATUS_FAILED;
 847             }
 848
 849             OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: ready outputStream..");
 850
 851             jclass jni_cid_OutputStream = (*env)->FindClass(env, CLASSPATH_OUTPUT);
 852             if (!jni_cid_OutputStream)
 853             {
 854                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_cid_OutputStream is null");
 855                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 856                 (*env)->DeleteLocalRef(env, jni_obj_outputStream);
 857                 return CA_STATUS_FAILED;
 858             }
 859
 860             jmethodID jni_mid_write = (*env)->GetMethodID(env, jni_cid_OutputStream, "write",
 861                                                           "([BII)V");
 862             if (!jni_mid_write)
 863             {
 864                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: jni_mid_write is null");
 865                 (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 866                 (*env)->DeleteLocalRef(env, jni_obj_outputStream);
 867                 (*env)->DeleteLocalRef(env, jni_cid_OutputStream);
 868                 return CA_STATUS_FAILED;
 869             }
 870
 871             jbyteArray jbuf = (*env)->NewByteArray(env, dataLength);
 872             (*env)->SetByteArrayRegion(env, jbuf, 0, dataLength, (jbyte*) data);
 873
 874             (*env)->CallVoidMethod(env, jni_obj_outputStream, jni_mid_write, jbuf, (jint) 0,
 875                                    (jint) dataLength);
 876
 877             (*env)->DeleteLocalRef(env, jni_cid_BTsocket);
 878             (*env)->DeleteLocalRef(env, jni_obj_outputStream);
 879             (*env)->DeleteLocalRef(env, jni_cid_OutputStream);
 880             (*env)->DeleteLocalRef(env, jbuf);
 881
 882             if ((*env)->ExceptionCheck(env))
 883             {
 884                 OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: Write Error!!!");
 885                 (*env)->ExceptionDescribe(env);
 886                 (*env)->ExceptionClear(env);
 887                 return CA_STATUS_FAILED;
 888             }
 889
 890             OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: Write Success");
 891         }
 892         else
 893         {
 894             (*env)->ExceptionDescribe(env);
 895             (*env)->ExceptionClear(env);
 896             OIC_LOG(ERROR, TAG, "[EDR][Native] btSendData: error!!");
 897             return CA_STATUS_FAILED;
 898         }
 899     }
 900     else
 901     {
 902         OIC_LOG(DEBUG, TAG, "[EDR][Native] btSendData: BT connection is not completed!!");
 903     }
 904
 905     return CA_STATUS_OK;
 906 }
 907
 908 CAResult_t CAEDRNativeConnect(JNIEnv *env, const char *address)
 909 {
 910     VERIFY_NON_NULL(address, TAG, "address is null");
 911     OIC_LOG(DEBUG, TAG, "[EDR][Native] btConnect..");
 912
 913     if (!CAEDRNativeIsEnableBTAdapter(env))
 914     {
 915         OIC_LOG(ERROR, TAG, "BT adpater is not enable");
 916         return CA_STATUS_INVALID_PARAM;
 917     }
 918
 919     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
 920     if (!jni_cid_BTAdapter)
 921     {
 922         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_BTAdapter is null");
 923         return CA_STATUS_FAILED;
 924     }
 925
 926     // get BTadpater
 927     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 928                                                                     "getDefaultAdapter",
 929                                                                     METHODID_OBJECTNONPARAM);
 930     if (!jni_mid_getDefaultAdapter)
 931     {
 932         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_getDefaultAdapter is null");
 933         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 934         return CA_STATUS_FAILED;
 935     }
 936
 937     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 938                                                                jni_mid_getDefaultAdapter);
 939     if (!jni_obj_BTAdapter)
 940     {
 941         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_BTAdapter is null");
 942         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 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     (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 951     if (!jni_mid_getRemoteDevice)
 952     {
 953         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_getRemoteDevice is null");
 954         (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 955         return CA_STATUS_FAILED;
 956     }
 957
 958     jstring jni_address = (*env)->NewStringUTF(env, address);
 959     jobject jni_obj_remoteBTDevice = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
 960                                                               jni_mid_getRemoteDevice, jni_address);
 961     (*env)->DeleteLocalRef(env, jni_address);
 962     (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 963     if (!jni_obj_remoteBTDevice)
 964     {
 965         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_remoteBTDevice is null");
 966         return CA_STATUS_FAILED;
 967     }
 968
 969     // get create Rfcomm Socket method ID
 970     jclass jni_cid_BluetoothDevice = (*env)->FindClass(env, CLASSPATH_BT_DEVICE);
 971     if (!jni_cid_BluetoothDevice)
 972     {
 973         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_BluetoothDevice is null");
 974         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
 975         return CA_STATUS_FAILED;
 976     }
 977
 978     jmethodID jni_mid_createSocket = (*env)->GetMethodID(
 979             env, jni_cid_BluetoothDevice, "createInsecureRfcommSocketToServiceRecord",
 980             "(Ljava/util/UUID;)Landroid/bluetooth/BluetoothSocket;");
 981     (*env)->DeleteLocalRef(env, jni_cid_BluetoothDevice);
 982     if (!jni_mid_createSocket)
 983     {
 984         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_createSocket is null");
 985         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
 986         return CA_STATUS_FAILED;
 987     }
 988
 989     // setting UUID
 990     jclass jni_cid_uuid = (*env)->FindClass(env, CLASSPATH_BT_UUID);
 991     if (!jni_cid_uuid)
 992     {
 993         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_uuid is null");
 994         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
 995         return CA_STATUS_FAILED;
 996     }
 997
 998     jmethodID jni_mid_fromString = (*env)->GetStaticMethodID(
 999             env, jni_cid_uuid, "fromString", "(Ljava/lang/String;)Ljava/util/UUID;");
1000     if (!jni_mid_fromString)
1001     {
1002         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_fromString is null");
1003         (*env)->DeleteLocalRef(env, jni_cid_uuid);
1004         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
1005         return CA_STATUS_FAILED;
1006     }
1007
1008     jstring jni_uuid = (*env)->NewStringUTF(env, OIC_EDR_SERVICE_ID);
1009     if (!jni_uuid)
1010     {
1011         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_uuid is null");
1012         (*env)->DeleteLocalRef(env, jni_cid_uuid);
1013         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
1014         return CA_STATUS_FAILED;
1015     }
1016     jobject jni_obj_uuid = (*env)->CallStaticObjectMethod(env, jni_cid_uuid, jni_mid_fromString,
1017                                                           jni_uuid);
1018     (*env)->DeleteLocalRef(env, jni_cid_uuid);
1019     (*env)->DeleteLocalRef(env, jni_uuid);
1020     if (!jni_obj_uuid)
1021     {
1022         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_uuid is null");
1023         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
1024         return CA_STATUS_FAILED;
1025     }
1026     // create socket
1027     jobject jni_obj_BTSocket = (*env)->CallObjectMethod(env, jni_obj_remoteBTDevice,
1028                                                         jni_mid_createSocket, jni_obj_uuid);
1029     (*env)->DeleteLocalRef(env, jni_obj_uuid);
1030     (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
1031     if (!jni_obj_BTSocket)
1032     {
1033         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_obj_BTSocket is null");
1034         return CA_STATUS_FAILED;
1035     }
1036
1037     // connect
1038     jclass jni_cid_BTSocket = (*env)->FindClass(env, CLASSPATH_BT_SOCKET);
1039     if (!jni_cid_BTSocket)
1040     {
1041         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_cid_BTSocket is null");
1042         (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
1043         return CA_STATUS_FAILED;
1044     }
1045
1046     jmethodID jni_mid_connect = (*env)->GetMethodID(env, jni_cid_BTSocket, "connect", "()V");
1047     (*env)->DeleteLocalRef(env, jni_cid_BTSocket);
1048     if (!jni_mid_connect)
1049     {
1050         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_mid_connect is null");
1051         (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
1052         return CA_STATUS_FAILED;
1053     }
1054
1055     OIC_LOG(DEBUG, TAG, "[EDR][Native] btConnect: initiating connection...");
1056     (*env)->CallVoidMethod(env, jni_obj_BTSocket, jni_mid_connect);
1057
1058     if ((*env)->ExceptionCheck(env))
1059     {
1060         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: Connect is Failed!!!");
1061         (*env)->ExceptionDescribe(env);
1062         (*env)->ExceptionClear(env);
1063         return CA_STATUS_FAILED;
1064     }
1065
1066     // set socket to list
1067     jobject jni_socket = (*env)->NewGlobalRef(env, jni_obj_BTSocket);
1068     if (!jni_socket)
1069     {
1070         OIC_LOG(ERROR, TAG, "[EDR][Native] btConnect: jni_socket is null");
1071         (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
1072         return CA_STATUS_FAILED;
1073     }
1074     ca_mutex_lock(g_mutexObjectList);
1075     CAEDRNativeAddDeviceSocketToList(env, jni_socket);
1076     (*env)->DeleteGlobalRef(env, jni_socket);
1077     (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
1078     ca_mutex_unlock(g_mutexObjectList);
1079
1080     // update state
1081     ca_mutex_lock(g_mutexStateList);
1082     CAEDRUpdateDeviceState(STATE_CONNECTED, address);
1083     ca_mutex_unlock(g_mutexStateList);
1084
1085     OIC_LOG(DEBUG, TAG, "[EDR][Native] btConnect: connected");
1086
1087     return CA_STATUS_OK;
1088 }
1089
1090 void CAEDRNativeSocketClose(JNIEnv *env, const char *address)
1091 {
1092     VERIFY_NON_NULL_VOID(address, TAG, "address is null");
1093
1094     jclass jni_cid_BTSocket = (*env)->FindClass(env, "android/bluetooth/BluetoothSocket");
1095     if (!jni_cid_BTSocket)
1096     {
1097         OIC_LOG(ERROR, TAG, "[EDR][Native] close: jni_cid_BTSocket is null");
1098         return;
1099     }
1100
1101     jmethodID jni_mid_close = (*env)->GetMethodID(env, jni_cid_BTSocket, "close", "()V");
1102     if (!jni_mid_close)
1103     {
1104         OIC_LOG(ERROR, TAG, "[EDR][Native] close: jni_mid_close is null");
1105         return;
1106     }
1107
1108     jobject jni_obj_socket = CAEDRNativeGetDeviceSocketBaseAddr(env, address);
1109     if (!jni_obj_socket)
1110     {
1111         OIC_LOG(ERROR, TAG, "[EDR][Native] close: jni_obj_socket is not available");
1112         return;
1113     }
1114
1115     (*env)->CallVoidMethod(env, jni_obj_socket, jni_mid_close);
1116
1117     if ((*env)->ExceptionCheck(env))
1118     {
1119         OIC_LOG(ERROR, TAG, "[EDR][Native] close: close is Failed!!!");
1120         (*env)->ExceptionDescribe(env);
1121         (*env)->ExceptionClear(env);
1122         return;
1123     }
1124
1125     // remove socket to list
1126     CAEDRNativeRemoveDeviceSocket(env, jni_obj_socket);
1127
1128     // update state
1129     ca_mutex_lock(g_mutexStateList);
1130     CAEDRUpdateDeviceState(STATE_DISCONNECTED, address);
1131     ca_mutex_unlock(g_mutexStateList);
1132
1133     OIC_LOG(DEBUG, TAG, "[EDR][Native] close: disconnected");
1134 }
1135
1136 void CAEDRInitializeClient(ca_thread_pool_t handle)
1137 {
1138     OIC_LOG(DEBUG, TAG, "IN");
1139     CAEDRInitialize(handle);
1140     OIC_LOG(DEBUG, TAG, "OUT");
1141 }
1142
1143 void CAEDRSetErrorHandler(CAEDRErrorHandleCallback errorHandleCallback)
1144 {
1145     g_edrErrorHandler = errorHandleCallback;
1146 }