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         return;
 549     }
 550
 551     jobject jni_obj_inputStream = (*env)->CallObjectMethod(env, deviceSocket,
 552                                                            jni_mid_getInputStream);
 553     if (!jni_obj_inputStream)
 554     {
 555         OIC_LOG(ERROR, TAG, "jni_obj_inputStream is null");
 556         return;
 557     }
 558
 559     socketInfo->deviceSocket = (*env)->NewGlobalRef(env, deviceSocket);
 560     socketInfo->inputStream = (*env)->NewGlobalRef(env, jni_obj_inputStream);
 561     (*env)->DeleteLocalRef(env, jni_obj_inputStream);
 562
 563     bool result = u_arraylist_add(g_deviceObjectList, (void *) socketInfo);
 564     if (!result)
 565     {
 566         OIC_LOG(ERROR, TAG, "u_arraylist_add failed.");
 567         OICFree(socketInfo);
 568         return;
 569     }
 570
 571     OIC_LOG(DEBUG, TAG, "add new device socket object to list");
 572 }
 573
 574 bool CAEDRNativeIsDeviceSocketInList(JNIEnv *env, const char* remoteAddress)
 575 {
 576     OIC_LOG(DEBUG, TAG, "CANativeIsDeviceObjInList");
 577     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", false);
 578
 579     jint length = u_arraylist_length(g_deviceObjectList);
 580     for (jint index = 0; index < length; index++)
 581     {
 582         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 583                                                                               index);
 584         if (!socketInfo)
 585         {
 586             OIC_LOG(DEBUG, TAG, "socketInfo is null");
 587             return false;
 588         }
 589
 590         jobject jarrayObj = socketInfo->deviceSocket;
 591         if (!jarrayObj)
 592         {
 593             OIC_LOG(DEBUG, TAG, "jarrayObj is null");
 594             return false;
 595         }
 596
 597         jstring jni_setAddress = CAEDRNativeGetAddressFromDeviceSocket(env, jarrayObj);
 598         if (!jni_setAddress)
 599         {
 600             OIC_LOG(DEBUG, TAG, "jni_setAddress is null");
 601             return false;
 602         }
 603
 604         const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
 605         if (!setAddress)
 606         {
 607             OIC_LOG(DEBUG, TAG, "setAddress is null");
 608             return false;
 609         }
 610
 611         if (!strcmp(remoteAddress, setAddress))
 612         {
 613             OIC_LOG(DEBUG, TAG, "the device is already set");
 614             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 615             return true;
 616         }
 617         else
 618         {
 619             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 620             continue;
 621         }
 622     }
 623
 624     OIC_LOG(DEBUG, TAG, "there are no the Device obejct in list");
 625     return false;
 626 }
 627
 628 void CAEDRNativeSocketCloseToAll(JNIEnv *env)
 629 {
 630     OIC_LOG(DEBUG, TAG, "CAEDRNativeSocketCloseToAll");
 631
 632     if (!g_deviceObjectList)
 633     {
 634         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 635         return;
 636     }
 637
 638     jmethodID jni_mid_close = CAGetJNIMethodID(env, CLASSPATH_BT_SOCKET,
 639                                                "close", "()V");
 640     if (!jni_mid_close)
 641     {
 642         OIC_LOG(ERROR, TAG, "jni_mid_close is null");
 643         return;
 644     }
 645
 646     jint length = u_arraylist_length(g_deviceObjectList);
 647     for (jint index = 0; index < length; index++)
 648     {
 649         jobject jni_obj_socket = (jobject) u_arraylist_get(g_deviceObjectList, index);
 650         if (!jni_obj_socket)
 651         {
 652             OIC_LOG(ERROR, TAG, "socket obj is null");
 653             return;
 654         }
 655
 656         (*env)->CallVoidMethod(env, jni_obj_socket, jni_mid_close);
 657
 658         if ((*env)->ExceptionCheck(env))
 659         {
 660             OIC_LOG(ERROR, TAG, "close is Failed!!!");
 661             (*env)->ExceptionDescribe(env);
 662             (*env)->ExceptionClear(env);
 663             return;
 664         }
 665     }
 666 }
 667
 668 void CAEDRNativeRemoveAllDeviceSocket(JNIEnv *env)
 669 {
 670     OIC_LOG(DEBUG, TAG, "CANativeRemoveAllDeviceObjsList");
 671
 672     if (!g_deviceObjectList)
 673     {
 674         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 675         return;
 676     }
 677
 678     jint length = u_arraylist_length(g_deviceObjectList);
 679     for (jint index = 0; index < length; index++)
 680     {
 681         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 682                                                                               index);
 683         if (!socketInfo)
 684         {
 685             OIC_LOG(ERROR, TAG, "socketInfo is null");
 686             continue;
 687         }
 688
 689         jobject jdeviceSocket = socketInfo->deviceSocket;
 690         if (jdeviceSocket)
 691         {
 692             (*env)->DeleteGlobalRef(env, jdeviceSocket);
 693         }
 694
 695         jobject jinputStream = socketInfo->inputStream;
 696         if (jinputStream)
 697         {
 698             (*env)->DeleteGlobalRef(env, jinputStream);
 699         }
 700     }
 701
 702     OICFree(g_deviceObjectList);
 703     g_deviceObjectList = NULL;
 704     return;
 705 }
 706
 707 void CAEDRNativeRemoveDeviceSocket(JNIEnv *env, jobject deviceSocket)
 708 {
 709     OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveDeviceSocket");
 710     VERIFY_NON_NULL_VOID(deviceSocket, TAG, "deviceSocket");
 711
 712     jstring jni_address = CAEDRNativeGetAddressFromDeviceSocket(env, deviceSocket);
 713     if (!jni_address)
 714     {
 715         OIC_LOG(ERROR, TAG, "jni_address is null");
 716         return;
 717     }
 718
 719     CAEDRNativeRemoveDeviceSocketBaseAddr(env, jni_address);
 720
 721     return;
 722 }
 723
 724 void CAEDRNativeRemoveDeviceSocketBaseAddr(JNIEnv *env, jstring address)
 725 {
 726     OIC_LOG(DEBUG, TAG, "CAEDRNativeRemoveDeviceSocketBaseAddr");
 727     VERIFY_NON_NULL_VOID(address, TAG, "address");
 728
 729     if (!g_deviceObjectList)
 730     {
 731         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 732         return;
 733     }
 734
 735     const char* targetAddress = (*env)->GetStringUTFChars(env, address, NULL);
 736
 737     jint length = u_arraylist_length(g_deviceObjectList);
 738     for (jint index = 0; index < length; index++)
 739     {
 740         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 741                                                                               index);
 742         if (!socketInfo)
 743         {
 744             OIC_LOG(ERROR, TAG, "socketInfo is null");
 745             continue;
 746         }
 747
 748         jobject jarrayObj = socketInfo->deviceSocket;
 749         if (!jarrayObj)
 750         {
 751             OIC_LOG(DEBUG, TAG, "jarrayObj is null");
 752             continue;
 753         }
 754
 755         jstring jni_setAddress = CAEDRNativeGetAddressFromDeviceSocket(env, jarrayObj);
 756         if (!jni_setAddress)
 757         {
 758             OIC_LOG(ERROR, TAG, "jni_setAddress is null");
 759             continue;
 760         }
 761
 762         const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
 763
 764         if (!strcmp(setAddress, targetAddress))
 765         {
 766             OIC_LOG_V(DEBUG, TAG, "remove object : %s", targetAddress);
 767             (*env)->DeleteGlobalRef(env, jarrayObj);
 768             jobject jinputStream = socketInfo->inputStream;
 769             if (jinputStream)
 770             {
 771                 (*env)->DeleteGlobalRef(env, jinputStream);
 772             }
 773             (*env)->ReleaseStringUTFChars(env, address, targetAddress);
 774             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 775             (*env)->DeleteLocalRef(env, jni_setAddress);
 776
 777             u_arraylist_remove(g_deviceObjectList, index);
 778             return;
 779         }
 780         (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 781         (*env)->DeleteLocalRef(env, jni_setAddress);
 782     }
 783
 784     OIC_LOG_V(DEBUG, TAG, "the target object doesn't exist in deviceObjectList (addr: %s)",
 785               targetAddress);
 786     (*env)->ReleaseStringUTFChars(env, address, targetAddress);
 787
 788     return;
 789 }
 790
 791 jobject CAEDRNativeGetDeviceSocket(uint32_t index)
 792 {
 793     if (!g_deviceObjectList)
 794     {
 795         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 796         return NULL;
 797     }
 798
 799     CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 800                                                                           index);
 801     if (!socketInfo)
 802     {
 803         OIC_LOG(ERROR, TAG, "socketInfo is null");
 804         return NULL;
 805     }
 806
 807     jobject jarrayObj = socketInfo->deviceSocket;
 808     if (!jarrayObj)
 809     {
 810         OIC_LOG(ERROR, TAG, "jarrayObj is not available");
 811         return NULL;
 812     }
 813     return jarrayObj;
 814 }
 815
 816 jobject CAEDRNativeGetDeviceSocketBaseAddr(JNIEnv *env, const char* remoteAddress)
 817 {
 818     OIC_LOG(DEBUG, TAG, "CAEDRNativeGetDeviceSocketBaseAddr");
 819     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", NULL);
 820
 821     if (!g_deviceObjectList)
 822     {
 823         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 824         return NULL;
 825     }
 826
 827     jint length = u_arraylist_length(g_deviceObjectList);
 828     for (jint index = 0; index < length; index++)
 829     {
 830         CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 831                                                                               index);
 832         if (!socketInfo)
 833         {
 834             OIC_LOG(ERROR, TAG, "socketInfo is null");
 835             continue;
 836         }
 837
 838         jobject jarrayObj = socketInfo->deviceSocket;
 839         if (!jarrayObj)
 840         {
 841             OIC_LOG(ERROR, TAG, "jarrayObj is null");
 842             continue;
 843         }
 844
 845         jstring jni_setAddress = CAEDRNativeGetAddressFromDeviceSocket(env, jarrayObj);
 846         if (!jni_setAddress)
 847         {
 848             OIC_LOG(ERROR, TAG, "jni_setAddress is null");
 849             continue;
 850         }
 851         const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
 852
 853         if (!strcmp(setAddress, remoteAddress))
 854         {
 855             OIC_LOG_V(ERROR, TAG, "remove object : %s", remoteAddress);
 856             (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 857             (*env)->DeleteLocalRef(env, jni_setAddress);
 858             return jarrayObj;
 859         }
 860         (*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
 861         (*env)->DeleteLocalRef(env, jni_setAddress);
 862     }
 863
 864     return NULL;
 865 }
 866
 867 jobject CAEDRNativeGetInputStream(uint32_t index)
 868 {
 869     if (!g_deviceObjectList)
 870     {
 871         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 872         return NULL;
 873     }
 874
 875     CAEDRSocketInfo_t *socketInfo = (CAEDRSocketInfo_t *) u_arraylist_get(g_deviceObjectList,
 876                                                                           index);
 877     if (!socketInfo)
 878     {
 879         OIC_LOG(ERROR, TAG, "socketInfo is null");
 880         return NULL;
 881     }
 882
 883     jobject jarrayObj = socketInfo->inputStream;
 884     if (!jarrayObj)
 885     {
 886         OIC_LOG(ERROR, TAG, "jarrayObj is not available");
 887         return NULL;
 888     }
 889     return jarrayObj;
 890 }
 891
 892 uint32_t CAEDRGetSocketListLength()
 893 {
 894     if (!g_deviceObjectList)
 895     {
 896         OIC_LOG(ERROR, TAG, "gdeviceObjectList is null");
 897         return 0;
 898     }
 899
 900     return u_arraylist_length(g_deviceObjectList);
 901 }
 902
 903 CAConnectedDeviceInfo_t *CAEDRGetDeviceInfoFromAddress(const char *remoteAddress)
 904 {
 905     OIC_LOG(DEBUG, TAG, "CAEDRGetDeviceInfoFromAddress");
 906     VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress", NULL);
 907
 908     if (!g_deviceStateList)
 909     {
 910         OIC_LOG(ERROR, TAG, "gdeviceStateList is null");
 911         return NULL;
 912     }
 913
 914     jint length = u_arraylist_length(g_deviceStateList);
 915     for (jint index = 0; index < length; index++)
 916     {
 917         CAConnectedDeviceInfo_t* deviceInfo =
 918                 (CAConnectedDeviceInfo_t*) u_arraylist_get(g_deviceStateList, index);
 919         if (!deviceInfo)
 920         {
 921             OIC_LOG(DEBUG, TAG, "deviceInfo object is null");
 922             continue;
 923         }
 924
 925         if (!strcmp((const char*) deviceInfo->address, remoteAddress))
 926         {
 927             return deviceInfo;
 928         }
 929     }
 930     return NULL;
 931 }