resource/csdk/connectivity/src/bt_edr_adapter/android/caedrutils.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 <jni.h>
  22 #include <stdio.h>
  23 #include <android/log.h>
  24 #include "caedrutils.h"
  25 #include "logger.h"
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28 #include "cathreadpool.h"
  29 #include "uarraylist.h"
  30 #include "caadapterutils.h"
  31
  32 #define ERROR_CODE (-1)
  33 #define TAG PCF("OIC_CA_EDR_UTILS")
  34
  35 static const char METHODID_OBJECTNONPARAM[] = "()Landroid/bluetooth/BluetoothAdapter;";
  36 static const char METHODID_STRINGNONPARAM[] = "()Ljava/lang/String;";
  37 static const char CLASSPATH_BT_ADPATER[] = "android/bluetooth/BluetoothAdapter";
  38 static const char CLASSPATH_BT_DEVICE[] = "android/bluetooth/BluetoothDevice";
  39 static const char CLASSPATH_BT_SOCKET[] = "android/bluetooth/BluetoothSocket";
  40
  41 static u_arraylist_t *g_deviceStateList = NULL;
  42 static u_arraylist_t *g_deviceObjectList = NULL;
  43
  44 // get address from bluetooth socket
  45 jstring CAEDRNativeGetAddressFromDeviceSocket(JNIEnv *env, jobject bluetoothSocketObj)
  46 {
  47     VERIFY_NON_NULL_RET(bluetoothSocketObj, TAG, "bluetoothSocketObj", NULL);
  48
  49     jmethodID jni_mid_getRemoteDevice = CAGetJNIMethodID(
  50             env, CLASSPATH_BT_SOCKET, "getRemoteDevice", "()Landroid/bluetooth/BluetoothDevice;");
  51     if (!jni_mid_getRemoteDevice)
  52     {
  53         OIC_LOG(ERROR, TAG, "jni_mid_getRemoteDevice is null");
  54         return NULL;
  55     }
  56
  57     jobject jni_obj_remoteBTDevice = (*env)->CallObjectMethod(env, bluetoothSocketObj,
  58                                                               jni_mid_getRemoteDevice);
  59     if (!jni_obj_remoteBTDevice)
  60     {
  61         OIC_LOG(ERROR, TAG, "jni_obj_remoteBTDevice is null");
  62         return NULL;
  63     }
  64
  65     jmethodID j_mid_getAddress = CAGetJNIMethodID(env, CLASSPATH_BT_DEVICE,
  66                                                   "getAddress",
  67                                                   METHODID_STRINGNONPARAM);
  68     if (!j_mid_getAddress)
  69     {
  70         OIC_LOG(ERROR, TAG, "j_mid_getAddress is null");
  71         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
  72         return NULL;
  73     }
  74
  75     jstring j_str_address = (*env)->CallObjectMethod(env, jni_obj_remoteBTDevice,
  76                                                      j_mid_getAddress);
  77     if (!j_str_address)
  78     {
  79         OIC_LOG(ERROR, TAG, "j_str_address is null");
  80         (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
  81         return NULL;
  82     }
  83
  84     (*env)->DeleteLocalRef(env, jni_obj_remoteBTDevice);
  85
  86     return j_str_address;
  87 }
  88
  89 jstring CAEDRNativeGetLocalDeviceAddress(JNIEnv* env)
  90 {
  91     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
  92     if (!jni_cid_BTAdapter)
  93     {
  94         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
  95         return NULL;
  96     }
  97
  98     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
  99                                                                     "getDefaultAdapter",
 100                                                                     METHODID_OBJECTNONPARAM);
 101     if (!jni_mid_getDefaultAdapter)
 102     {
 103         OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
 104         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 105         return NULL;
 106     }
 107
 108     jmethodID jni_mid_getAddress = (*env)->GetMethodID(env, jni_cid_BTAdapter, "getAddress",
 109                                                        METHODID_STRINGNONPARAM);
 110     if (!jni_mid_getAddress)
 111     {
 112         OIC_LOG(ERROR, TAG, "jni_mid_getAddress is null");
 113         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 114         return NULL;
 115     }
 116
 117     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 118                                                                jni_mid_getDefaultAdapter);
 119     if (!jni_obj_BTAdapter)
 120     {
 121         OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
 122         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 123         return NULL;
 124     }
 125
 126     jstring jni_str_address = (jstring)(*env)->CallObjectMethod(env, jni_obj_BTAdapter,
 127                                                                 jni_mid_getAddress);
 128     if (!jni_str_address)
 129     {
 130         OIC_LOG(ERROR, TAG, "jni_str_address is null");
 131         (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 132         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 133         return NULL;
 134     }
 135
 136     (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 137     (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 138
 139     return jni_str_address;
 140 }
 141
 142 jobjectArray CAEDRNativeGetBondedDevices(JNIEnv *env)
 143 {
 144     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
 145     if (!jni_cid_BTAdapter)
 146     {
 147         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
 148         return NULL;
 149     }
 150
 151     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 152                                                                     "getDefaultAdapter",
 153                                                                     METHODID_OBJECTNONPARAM);
 154     if (!jni_mid_getDefaultAdapter)
 155     {
 156         OIC_LOG(ERROR, TAG, "default adapter is null");
 157         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 158         return NULL;
 159     }
 160
 161     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 162                                                                jni_mid_getDefaultAdapter);
 163     if (!jni_obj_BTAdapter)
 164     {
 165         OIC_LOG(ERROR, TAG, "bluetooth adapter is null");
 166         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 167         return NULL;
 168     }
 169
 170     // Get a list of currently paired devices
 171     jmethodID jni_mid_getBondedDevices = (*env)->GetMethodID(env, jni_cid_BTAdapter,
 172                                                              "getBondedDevices",
 173                                                              "()Ljava/util/Set;");
 174     if (!jni_mid_getBondedDevices)
 175     {
 176         OIC_LOG(ERROR, TAG, "jni_mid_getBondedDevicesr is null");
 177         (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 178         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 179         return NULL;
 180     }
 181
 182     jobject jni_obj_setPairedDevices = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
 183                                                                 jni_mid_getBondedDevices);
 184     if (!jni_obj_setPairedDevices)
 185     {
 186         OIC_LOG(ERROR, TAG, "ni_obj_setPairedDevices is null");
 187         (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 188         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 189         return NULL;
 190     }
 191
 192     // Convert the set to an object array
 193     // object[] array = Set<BluetoothDevice>.toArray();
 194     jmethodID jni_mid_toArray = CAGetJNIMethodID(env, "java/util/Set",
 195                                                  "toArray", "()[Ljava/lang/Object;");
 196     if (!jni_mid_toArray)
 197     {
 198         OIC_LOG(ERROR, TAG, "jni_mid_toArray is null");
 199         goto exit;
 200     }
 201
 202     jobjectArray jni_arrayPairedDevices = (jobjectArray)(
 203             (*env)->CallObjectMethod(env, jni_obj_setPairedDevices, jni_mid_toArray));
 204     if (!jni_arrayPairedDevices)
 205     {
 206         OIC_LOG(ERROR, TAG, "jni_arrayPairedDevices is null");
 207         goto exit;
 208     }
 209
 210     (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 211     (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 212     (*env)->DeleteLocalRef(env, jni_obj_setPairedDevices);
 213
 214     return jni_arrayPairedDevices;
 215
 216 exit:
 217     (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 218     (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 219     (*env)->DeleteLocalRef(env, jni_obj_setPairedDevices);
 220     return NULL;
 221 }
 222
 223 jint CAEDRNativeGetBTStateOnInfo(JNIEnv *env)
 224 {
 225     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
 226     if (!jni_cid_BTAdapter)
 227     {
 228         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
 229         return ERROR_CODE;
 230     }
 231
 232     jfieldID jni_fid_stateon = (*env)->GetStaticFieldID(env, jni_cid_BTAdapter, "STATE_ON", "I");
 233     if (jni_fid_stateon == 0)
 234     {
 235         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 236
 237         OIC_LOG(ERROR, TAG, "get_field_state is 0");
 238         return ERROR_CODE;
 239     }
 240     jint jni_int_val = (*env)->GetStaticIntField(env, jni_cid_BTAdapter, jni_fid_stateon);
 241
 242     OIC_LOG_V(DEBUG, TAG, "bluetooth state integer value : %d", jni_int_val);
 243
 244     (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 245
 246     return jni_int_val;
 247 }
 248
 249 jboolean CAEDRNativeIsEnableBTAdapter(JNIEnv *env)
 250 {
 251     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
 252     if (!jni_cid_BTAdapter)
 253     {
 254         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter: jni_cid_BTAdapter is null");
 255         return JNI_FALSE;
 256     }
 257
 258     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 259                                                                     "getDefaultAdapter",
 260                                                                     METHODID_OBJECTNONPARAM);
 261     if (!jni_mid_getDefaultAdapter)
 262     {
 263         OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
 264         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 265         return JNI_FALSE;
 266     }
 267
 268     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 269                                                                jni_mid_getDefaultAdapter);
 270     if (!jni_obj_BTAdapter)
 271     {
 272         OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
 273         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 274         return JNI_FALSE;
 275     }
 276
 277     // isEnable()
 278     jmethodID jni_mid_isEnable = (*env)->GetMethodID(env, jni_cid_BTAdapter, "isEnabled", "()Z");
 279     if (!jni_mid_isEnable)
 280     {
 281         OIC_LOG(ERROR, TAG, "jni_mid_isEnable is null");
 282         (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 283         (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 284         return JNI_FALSE;
 285     }
 286
 287     jboolean jni_isEnable = (*env)->CallBooleanMethod(env, jni_obj_BTAdapter, jni_mid_isEnable);
 288
 289     (*env)->DeleteLocalRef(env, jni_obj_BTAdapter);
 290     (*env)->DeleteLocalRef(env, jni_cid_BTAdapter);
 291
 292     return jni_isEnable;
 293 }
 294
 295 jstring CAEDRNativeGetAddressFromBTDevice(JNIEnv *env, jobject bluetoothDevice)
 296 {
 297     VERIFY_NON_NULL_RET(bluetoothDevice, TAG, "bluetoothDevice", NULL);
 298
 299     jmethodID jni_mid_getAddress = CAGetJNIMethodID(env,
 300                                                     CLASSPATH_BT_DEVICE,
 301                                                     "getAddress",
 302                                                     METHODID_STRINGNONPARAM);
 303     if (!jni_mid_getAddress)
 304     {
 305         OIC_LOG(ERROR, TAG, "jni_mid_getAddress is null");
 306         return NULL;
 307     }
 308
 309     jstring jni_address = (jstring)(*env)->CallObjectMethod(env, bluetoothDevice,
 310                                                             jni_mid_getAddress);
 311     if (!jni_address)
 312     {
 313         OIC_LOG(ERROR, TAG, "jni_address is null");
 314         return NULL;
 315     }
 316     return jni_address;
 317 }
 318
 319 /**
 320  * BT State List
 321  */
 322 void CAEDRNativeCreateDeviceStateList()
 323 {
 324     OIC_LOG(DEBUG, TAG, "CAEDRNativeCreateDeviceStateList");
 325
 326     // create new object array
 327     if (NULL == g_deviceStateList)
 328     {
 329         OIC_LOG(DEBUG, TAG, "Create device list");
 330
 331         g_deviceStateList = u_arraylist_create();
 332     }
 333 }
 334
 335 void CAEDRUpdateDeviceState(CAConnectedState_t state, const char *address)
 336 {
 337     VERIFY_NON_NULL_VOID(address, TAG, "address");
 338
 339     CAConnectedDeviceInfo_t *deviceInfo =
 340             (CAConnectedDeviceInfo_t *) OICCalloc(1, sizeof(CAConnectedDeviceInfo_t));
 341     if (!deviceInfo)
 342     {
 343         OIC_LOG(ERROR, TAG, "deviceInfo is null");
 344         return;
 345     }
 346     OICStrcpy((char*) deviceInfo->address, sizeof(deviceInfo->address), address);
 347     deviceInfo->state = state;
 348
 349     CAEDRNativeAddDeviceStateToList(deviceInfo);
 350 }
 351
 352 void CAEDRNativeAddDeviceStateToList(CAConnectedDeviceInfo_t *deviceInfo)
 353 {
 354     VERIFY_NON_NULL_VOID(deviceInfo, TAG, "deviceInfo");
 355
 356     if (!g_deviceStateList)
 357     {
 358         OIC_LOG(ERROR, TAG, "gdevice_list is null");
 359         return;
 360     }
 361
 362     if (CAEDRNativeIsDeviceInList((const char*) deviceInfo->address))
 363     {
 364         // delete previous state for update new state
 365         CAEDRNativeRemoveDevice((const char*) deviceInfo->address);
 366     }
 367     u_arraylist_add(g_deviceStateList, deviceInfo); // update new state
 368     OIC_LOG_V(DEBUG, TAG, "add new device state[%d] to list", deviceInfo->state);
 369 }
 370
 371 bool CAEDRNativeIsDeviceInList(const char* remoteAddress)
 372 {
 373     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", false);
 374
 375     jint length = u_arraylist_length(g_deviceStateList);
 376     for (jint index = 0; index < length; index++)
 377     {
 378         CAConnectedDeviceInfo_t* deviceInfo =
 379                 (CAConnectedDeviceInfo_t*) u_arraylist_get(g_deviceStateList, index);
 380         if (!deviceInfo)
 381         {
 382             OIC_LOG(ERROR, TAG, "deviceInfo object is null");
 383             return false;
 384         }
 385
 386         if (!strcmp(remoteAddress, (const char*) deviceInfo->address))
 387         {
 388             OIC_LOG(DEBUG, TAG, "the device is already set");
 389             return true;
 390         }
 391     }
 392
 393     OIC_LOG(DEBUG, TAG, "there are no the device in list.");
 394     return false;
 395 }
 396
 397 void CAEDRNativeRemoveAllDeviceState()
 398 {
 399     OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveAllDevices");
 400
 401     if (!g_deviceStateList)
 402     {
 403         OIC_LOG(ERROR, TAG, "gdeviceStateList is null");
 404         return;
 405     }
 406
 407     jint index;
 408     jint length = u_arraylist_length(g_deviceStateList);
 409     for (index = 0; index < length; index++)
 410     {
 411         CAConnectedDeviceInfo_t* deviceInfo =
 412                 (CAConnectedDeviceInfo_t*) u_arraylist_get(g_deviceStateList, index);
 413         if (!deviceInfo)
 414         {
 415             OIC_LOG(DEBUG, TAG, "jarrayObj is null");
 416             continue;
 417         }
 418         OICFree(deviceInfo);
 419     }
 420
 421     OICFree(g_deviceStateList);
 422     g_deviceStateList = NULL;
 423     return;
 424 }
 425
 426 void CAEDRNativeRemoveDevice(const char *remoteAddress)
 427 {
 428     OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveDeviceforStateList");
 429     VERIFY_NON_NULL_VOID(remoteAddress, TAG, "remoteAddress");
 430
 431     if (!g_deviceStateList)
 432     {
 433         OIC_LOG(ERROR, TAG, "gdeviceStateList is null");
 434         return;
 435     }
 436
 437     jint length = u_arraylist_length(g_deviceStateList);
 438     for (jint index = 0; index < length; index++)
 439     {
 440         CAConnectedDeviceInfo_t* deviceInfo =
 441                 (CAConnectedDeviceInfo_t*) u_arraylist_get(g_deviceStateList, index);
 442         if (!deviceInfo)
 443         {
 444             OIC_LOG(DEBUG, TAG, "deviceInfo object is null");
 445             continue;
 446         }
 447
 448         if (!strcmp((const char*) deviceInfo->address, remoteAddress))
 449         {
 450             OIC_LOG_V(DEBUG, TAG, "remove [%s] info from list", remoteAddress);
 451             OICFree(deviceInfo);
 452
 453             u_arraylist_remove(g_deviceStateList, index);
 454             break;
 455         }
 456     }
 457     return;
 458 }
 459
 460 CAConnectedState_t CAEDRIsConnectedDevice(const char *remoteAddress)
 461 {
 462     OIC_LOG(DEBUG, TAG, "CAEDRIsConnectedDevice");
 463     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", STATE_DISCONNECTED);
 464
 465     if (!g_deviceStateList)
 466     {
 467         OIC_LOG(ERROR, TAG, "gdeviceStateList is null");
 468         return STATE_DISCONNECTED;
 469     }
 470
 471     jint length = u_arraylist_length(g_deviceStateList);
 472     for (jint index = 0; index < length; index++)
 473     {
 474         CAConnectedDeviceInfo_t* deviceInfo =
 475                 (CAConnectedDeviceInfo_t*) u_arraylist_get(g_deviceStateList, index);
 476         if (!deviceInfo)
 477         {
 478             OIC_LOG(DEBUG, TAG, "deviceInfo object is null");
 479             continue;
 480         }
 481
 482         if (!strcmp((const char*) deviceInfo->address, remoteAddress))
 483         {
 484             return deviceInfo->state;
 485         }
 486     }
 487     return STATE_DISCONNECTED;
 488 }
 489
 490 /**
 491  * Device Socket Object List
 492  */
 493 void CAEDRNativeCreateDeviceSocketList()
 494 {
 495     OIC_LOG(DEBUG, TAG, "CAEDRNativeCreateDeviceSocketList");
 496
 497     // create new object array
 498     if (NULL == g_deviceObjectList)
 499     {
 500         OIC_LOG(DEBUG, TAG, "Create Device object list");
 501
 502         g_deviceObjectList = u_arraylist_create();
 503     }
 504 }
 505
 506 void CAEDRNativeAddDeviceSocketToList(JNIEnv *env, jobject deviceSocket)
 507 {
 508     OIC_LOG(DEBUG, TAG, "CANativeAddDeviceobjToList");
 509     VERIFY_NON_NULL_VOID(deviceSocket, TAG, "deviceSocket");
 510
 511     if (!g_deviceObjectList)
 512     {
 513         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 514         return;
 515     }
 516
 517     jstring jni_remoteAddress = CAEDRNativeGetAddressFromDeviceSocket(env, deviceSocket);
 518     if (!jni_remoteAddress)
 519     {
 520         OIC_LOG(ERROR, TAG, "jni_remoteAddress is null");
 521         return;
 522     }
 523
 524     const char* remoteAddress = (*env)->GetStringUTFChars(env, jni_remoteAddress, NULL);
 525
 526     if (CAEDRNativeIsDeviceSocketInList(env, remoteAddress))
 527     {
 528         OIC_LOG(DEBUG, TAG, "the address exists in deviceObjectList. remove it to add new");
 529         CAEDRNativeRemoveDeviceSocketBaseAddr(env, jni_remoteAddress);
 530     }
 531
 532     (*env)->ReleaseStringUTFChars(env, jni_remoteAddress, remoteAddress);
 533     (*env)->DeleteLocalRef(env, jni_remoteAddress);
 534
 535     CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) OICCalloc(1, sizeof(*socketInfo));
 536     if (!socketInfo)
 537     {
 538         OIC_LOG(ERROR, TAG, "Out of memory");
 539         return;
 540     }
 541
 542     jmethodID jni_mid_getInputStream = CAGetJNIMethodID(env, "android/bluetooth/BluetoothSocket",
 543                                                              "getInputStream",
 544                                                              "()Ljava/io/InputStream;");
 545     if (!jni_mid_getInputStream)
 546     {
 547         OIC_LOG(ERROR, TAG, "jni_mid_getInputStream is null");
 548         OICFree(socketInfo);
 549         return;
 550     }
 551
 552     jobject jni_obj_inputStream = (*env)->CallObjectMethod(env, deviceSocket,
 553                                                            jni_mid_getInputStream);
 554     if (!jni_obj_inputStream)
 555     {
 556         OIC_LOG(ERROR, TAG, "jni_obj_inputStream is null");
 557         OICFree(socketInfo);
 558         return;
 559     }
 560
 561     socketInfo->deviceSocket = (*env)->NewGlobalRef(env, deviceSocket);
 562     socketInfo->inputStream = (*env)->NewGlobalRef(env, jni_obj_inputStream);
 563     (*env)->DeleteLocalRef(env, jni_obj_inputStream);
 564
 565     bool result = u_arraylist_add(g_deviceObjectList, (void *) socketInfo);
 566     if (!result)
 567     {
 568         OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
 569         OICFree(socketInfo);
 570         return;
 571     }
 572
 573     OIC_LOG(DEBUG, TAG, "add new device socket object to list");
 574 }
 575
 576 bool CAEDRNativeIsDeviceSocketInList(JNIEnv *env, const char* remoteAddress)
 577 {
 578     OIC_LOG(DEBUG, TAG, "CANativeIsDeviceObjInList");
 579     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", false);
 580
 581     jint length = u_arraylist_length(g_deviceObjectList);
 582     for (jint index = 0; index < length; index++)
 583     {
 584         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 585                                                                               index);
 586         if (!socketInfo)
 587         {
 588             OIC_LOG(DEBUG, TAG, "socketInfo is null");
 589             return false;
 590         }
 591
 592         jobject jarrayObj = socketInfo->deviceSocket;
 593         if (!jarrayObj)
 594         {
 595             OIC_LOG(DEBUG, TAG, "jarrayObj is null");
 596             return false;
 597         }
 598
 599         jstring jni_setAddress = CAEDRNativeGetAddressFromDeviceSocket(env, jarrayObj);
 600         if (!jni_setAddress)
 601         {
 602             OIC_LOG(DEBUG, TAG, "jni_setAddress is null");
 603             return false;
 604         }
 605
 606         const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
 607         if (!setAddress)
 608         {
 609             OIC_LOG(DEBUG, TAG, "setAddress is null");
 610             return false;
 611         }
 612
 613         if (!strcmp(remoteAddress, setAddress))
 614         {
 615             OIC_LOG(DEBUG, TAG, "the device is already set");
 616             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 617             return true;
 618         }
 619         else
 620         {
 621             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 622             continue;
 623         }
 624     }
 625
 626     OIC_LOG(DEBUG, TAG, "there are no the Device obejct in list");
 627     return false;
 628 }
 629
 630 void CAEDRNativeSocketCloseToAll(JNIEnv *env)
 631 {
 632     OIC_LOG(DEBUG, TAG, "CAEDRNativeSocketCloseToAll");
 633
 634     if (!g_deviceObjectList)
 635     {
 636         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 637         return;
 638     }
 639
 640     jmethodID jni_mid_close = CAGetJNIMethodID(env, CLASSPATH_BT_SOCKET,
 641                                                "close", "()V");
 642     if (!jni_mid_close)
 643     {
 644         OIC_LOG(ERROR, TAG, "jni_mid_close is null");
 645         return;
 646     }
 647
 648     jint length = u_arraylist_length(g_deviceObjectList);
 649     for (jint index = 0; index < length; index++)
 650     {
 651         jobject jni_obj_socket = (jobject) u_arraylist_get(g_deviceObjectList, index);
 652         if (!jni_obj_socket)
 653         {
 654             OIC_LOG(ERROR, TAG, "socket obj is null");
 655             return;
 656         }
 657
 658         (*env)->CallVoidMethod(env, jni_obj_socket, jni_mid_close);
 659
 660         if ((*env)->ExceptionCheck(env))
 661         {
 662             OIC_LOG(ERROR, TAG, "close is Failed!!!");
 663             (*env)->ExceptionDescribe(env);
 664             (*env)->ExceptionClear(env);
 665             return;
 666         }
 667     }
 668 }
 669
 670 void CAEDRNativeRemoveAllDeviceSocket(JNIEnv *env)
 671 {
 672     OIC_LOG(DEBUG, TAG, "CANativeRemoveAllDeviceObjsList");
 673
 674     if (!g_deviceObjectList)
 675     {
 676         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 677         return;
 678     }
 679
 680     jint length = u_arraylist_length(g_deviceObjectList);
 681     for (jint index = 0; index < length; index++)
 682     {
 683         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 684                                                                               index);
 685         if (!socketInfo)
 686         {
 687             OIC_LOG(ERROR, TAG, "socketInfo is null");
 688             continue;
 689         }
 690
 691         jobject jdeviceSocket = socketInfo->deviceSocket;
 692         if (jdeviceSocket)
 693         {
 694             (*env)->DeleteGlobalRef(env, jdeviceSocket);
 695         }
 696
 697         jobject jinputStream = socketInfo->inputStream;
 698         if (jinputStream)
 699         {
 700             (*env)->DeleteGlobalRef(env, jinputStream);
 701         }
 702     }
 703
 704     OICFree(g_deviceObjectList);
 705     g_deviceObjectList = NULL;
 706     return;
 707 }
 708
 709 void CAEDRNativeRemoveDeviceSocket(JNIEnv *env, jobject deviceSocket)
 710 {
 711     OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveDeviceSocket");
 712     VERIFY_NON_NULL_VOID(deviceSocket, TAG, "deviceSocket");
 713
 714     jstring jni_address = CAEDRNativeGetAddressFromDeviceSocket(env, deviceSocket);
 715     if (!jni_address)
 716     {
 717         OIC_LOG(ERROR, TAG, "jni_address is null");
 718         return;
 719     }
 720
 721     CAEDRNativeRemoveDeviceSocketBaseAddr(env, jni_address);
 722
 723     return;
 724 }
 725
 726 void CAEDRNativeRemoveDeviceSocketBaseAddr(JNIEnv *env, jstring address)
 727 {
 728     OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveDeviceSocketBaseAddr");
 729     VERIFY_NON_NULL_VOID(address, TAG, "address");
 730
 731     if (!g_deviceObjectList)
 732     {
 733         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 734         return;
 735     }
 736
 737     const char* targetAddress = (*env)->GetStringUTFChars(env, address, NULL);
 738
 739     jint length = u_arraylist_length(g_deviceObjectList);
 740     for (jint index = 0; index < length; index++)
 741     {
 742         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 743                                                                               index);
 744         if (!socketInfo)
 745         {
 746             OIC_LOG(ERROR, TAG, "socketInfo is null");
 747             continue;
 748         }
 749
 750         jobject jarrayObj = socketInfo->deviceSocket;
 751         if (!jarrayObj)
 752         {
 753             OIC_LOG(DEBUG, TAG, "jarrayObj is null");
 754             continue;
 755         }
 756
 757         jstring jni_setAddress = CAEDRNativeGetAddressFromDeviceSocket(env, jarrayObj);
 758         if (!jni_setAddress)
 759         {
 760             OIC_LOG(ERROR, TAG, "jni_setAddress is null");
 761             continue;
 762         }
 763
 764         const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
 765
 766         if (!strcmp(setAddress, targetAddress))
 767         {
 768             OIC_LOG_V(DEBUG, TAG, "remove object : %s", targetAddress);
 769             (*env)->DeleteGlobalRef(env, jarrayObj);
 770             jobject jinputStream = socketInfo->inputStream;
 771             if (jinputStream)
 772             {
 773                 (*env)->DeleteGlobalRef(env, jinputStream);
 774             }
 775             (*env)->ReleaseStringUTFChars(env, address, targetAddress);
 776             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 777             (*env)->DeleteLocalRef(env, jni_setAddress);
 778
 779             u_arraylist_remove(g_deviceObjectList, index);
 780             return;
 781         }
 782         (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 783         (*env)->DeleteLocalRef(env, jni_setAddress);
 784     }
 785
 786     OIC_LOG_V(DEBUG, TAG, "the target object doesn't exist in deviceObjectList (addr: %s)",
 787               targetAddress);
 788     (*env)->ReleaseStringUTFChars(env, address, targetAddress);
 789
 790     return;
 791 }
 792
 793 jobject CAEDRNativeGetDeviceSocket(uint32_t index)
 794 {
 795     if (!g_deviceObjectList)
 796     {
 797         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 798         return NULL;
 799     }
 800
 801     CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 802                                                                           index);
 803     if (!socketInfo)
 804     {
 805         OIC_LOG(ERROR, TAG, "socketInfo is null");
 806         return NULL;
 807     }
 808
 809     jobject jarrayObj = socketInfo->deviceSocket;
 810     if (!jarrayObj)
 811     {
 812         OIC_LOG(ERROR, TAG, "jarrayObj is not available");
 813         return NULL;
 814     }
 815     return jarrayObj;
 816 }
 817
 818 jobject CAEDRNativeGetDeviceSocketBaseAddr(JNIEnv *env, const char* remoteAddress)
 819 {
 820     OIC_LOG(DEBUG, TAG, "CAEDRNativeGetDeviceSocketBaseAddr");
 821     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", NULL);
 822
 823     if (!g_deviceObjectList)
 824     {
 825         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 826         return NULL;
 827     }
 828
 829     jint length = u_arraylist_length(g_deviceObjectList);
 830     for (jint index = 0; index < length; index++)
 831     {
 832         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 833                                                                               index);
 834         if (!socketInfo)
 835         {
 836             OIC_LOG(ERROR, TAG, "socketInfo is null");
 837             continue;
 838         }
 839
 840         jobject jarrayObj = socketInfo->deviceSocket;
 841         if (!jarrayObj)
 842         {
 843             OIC_LOG(ERROR, TAG, "jarrayObj is null");
 844             continue;
 845         }
 846
 847         jstring jni_setAddress = CAEDRNativeGetAddressFromDeviceSocket(env, jarrayObj);
 848         if (!jni_setAddress)
 849         {
 850             OIC_LOG(ERROR, TAG, "jni_setAddress is null");
 851             continue;
 852         }
 853         const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
 854
 855         if (!strcmp(setAddress, remoteAddress))
 856         {
 857             OIC_LOG_V(ERROR, TAG, "remove object : %s", remoteAddress);
 858             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 859             (*env)->DeleteLocalRef(env, jni_setAddress);
 860             return jarrayObj;
 861         }
 862         (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 863         (*env)->DeleteLocalRef(env, jni_setAddress);
 864     }
 865
 866     return NULL;
 867 }
 868
 869 jobject CAEDRNativeGetInputStream(uint32_t index)
 870 {
 871     if (!g_deviceObjectList)
 872     {
 873         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 874         return NULL;
 875     }
 876
 877     CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 878                                                                           index);
 879     if (!socketInfo)
 880     {
 881         OIC_LOG(ERROR, TAG, "socketInfo is null");
 882         return NULL;
 883     }
 884
 885     jobject jarrayObj = socketInfo->inputStream;
 886     if (!jarrayObj)
 887     {
 888         OIC_LOG(ERROR, TAG, "jarrayObj is not available");
 889         return NULL;
 890     }
 891     return jarrayObj;
 892 }
 893
 894 uint32_t CAEDRGetSocketListLength()
 895 {
 896     if (!g_deviceObjectList)
 897     {
 898         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 899         return 0;
 900     }
 901
 902     return u_arraylist_length(g_deviceObjectList);
 903 }
 904
 905 CAConnectedDeviceInfo_t *CAEDRGetDeviceInfoFromAddress(const char *remoteAddress)
 906 {
 907     OIC_LOG(DEBUG, TAG, "CAEDRGetDeviceInfoFromAddress");
 908     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", NULL);
 909
 910     if (!g_deviceStateList)
 911     {
 912         OIC_LOG(ERROR, TAG, "gdeviceStateList is null");
 913         return NULL;
 914     }
 915
 916     jint length = u_arraylist_length(g_deviceStateList);
 917     for (jint index = 0; index < length; index++)
 918     {
 919         CAConnectedDeviceInfo_t* deviceInfo =
 920                 (CAConnectedDeviceInfo_t*) u_arraylist_get(g_deviceStateList, index);
 921         if (!deviceInfo)
 922         {
 923             OIC_LOG(DEBUG, TAG, "deviceInfo object is null");
 924             continue;
 925         }
 926
 927         if (!strcmp((const char*) deviceInfo->address, remoteAddress))
 928         {
 929             return deviceInfo;
 930         }
 931     }
 932     return NULL;
 933 }