resource/csdk/connectivity/src/bt_edr_adapter/android/caedrserver.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 "caedrserver.h"
  28 #include "logger.h"
  29 #include "oic_malloc.h"
  30 #include "cathreadpool.h" /* for thread pool */
  31 #include "camutex.h"
  32 #include "uarraylist.h"
  33 #include "caadapterutils.h"
  34 #include "org_iotivity_ca_CaEdrInterface.h"
  35 #include "oic_string.h"
  36
  37 #define TAG PCF("OIC_CA_EDR_SERVER")
  38
  39 static const char METHODID_OBJECTNONPARAM[] = "()Landroid/bluetooth/BluetoothAdapter;";
  40 static const char CLASSPATH_BT_ADPATER[] = "android/bluetooth/BluetoothAdapter";
  41 static const char CLASSPATH_BT_UUID[] = "java/util/UUID";
  42 static const char CLASSPATH_BT_SERVER_SOCKET[] = "android/bluetooth/BluetoothServerSocket";
  43
  44 static ca_thread_pool_t g_threadPoolHandle = NULL;
  45
  46 static JavaVM *g_jvm;
  47
  48 /**
  49  * when Both Mode(server and client) in App is set,
  50  * startDiscoveryServer and startListenningServer is calling.
  51  * and then both accept thread and receive thread is running redundantly.
  52  */
  53 static bool g_isStartServer = false;
  54
  55 /**
  56  * Maximum CoAP over TCP header length
  57  * to know the total data length.
  58  */
  59 #define EDR_MAX_HEADER_LEN  6
  60
  61 /**
  62  * Mutex to synchronize receive server.
  63  */
  64 static ca_mutex g_mutexReceiveServer = NULL;
  65
  66 /**
  67  * Flag to control the Receive Unicast Data Thread.
  68  */
  69 static bool g_stopUnicast = false;
  70
  71 /**
  72  * Mutex to synchronize accept server.
  73  */
  74 static ca_mutex g_mutexAcceptServer = NULL;
  75
  76 /**
  77  * Flag to control the Accept Thread.
  78  */
  79 static bool g_stopAccept = false;
  80
  81 /**
  82  * Mutex to synchronize server socket.
  83  */
  84 static ca_mutex g_mutexServerSocket = NULL;
  85
  86 /**
  87  * Flag to control the server socket.
  88  */
  89 static jobject g_serverSocket = NULL;
  90
  91 /**
  92  * Mutex to synchronize device state list.
  93  */
  94 static ca_mutex g_mutexStateList = NULL;
  95
  96 /**
  97  * Mutex to synchronize device object list.
  98  */
  99 static ca_mutex g_mutexObjectList = NULL;
 100
 101 /**
 102  * Mutex to synchronize start server state.
 103  */
 104 static ca_mutex g_mutexStartServerState = NULL;
 105
 106 /**
 107  * Thread context information for unicast, multicast and secured unicast server.
 108  */
 109 typedef struct
 110 {
 111     bool *stopFlag;
 112     CAAdapterServerType_t type;
 113 } CAAdapterReceiveThreadContext_t;
 114
 115 typedef struct
 116 {
 117     bool *stopFlag;
 118 } CAAdapterAcceptThreadContext_t;
 119
 120 /**
 121  * Maintains the callback to be notified when data received from remote
 122  * Bluetooth device.
 123  */
 124 static CAEDRDataReceivedCallback g_edrPacketReceivedCallback = NULL;
 125
 126 static void CAReceiveHandler(void *data)
 127 {
 128     OIC_LOG(DEBUG, TAG, "IN - CAReceiveHandler..");
 129     // Input validation
 130     VERIFY_NON_NULL_VOID(data, TAG, "Invalid thread context");
 131
 132     bool isAttached = false;
 133     JNIEnv* env = NULL;
 134     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 135     if (JNI_OK != res)
 136     {
 137         OIC_LOG(DEBUG, TAG, "CAReceiveHandler - Could not get JNIEnv pointer");
 138         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 139
 140         if (JNI_OK != res)
 141         {
 142             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 143             return;
 144         }
 145         isAttached = true;
 146     }
 147
 148     CAAdapterReceiveThreadContext_t *ctx = (CAAdapterReceiveThreadContext_t *) data;
 149
 150     while (true != *(ctx->stopFlag))
 151     {
 152         if (!CAEDRNativeIsEnableBTAdapter(env))
 153         {
 154             OIC_LOG(INFO, TAG, "BT adapter is not enabled");
 155             break;
 156         }
 157
 158         // if new socket object is added in socket list after below logic is ran.
 159         // new socket will be started to read after next while loop
 160         uint32_t length = CAEDRGetSocketListLength();
 161         if (0 != length)
 162         {
 163             for (uint32_t idx = 0; idx < length; idx++)
 164             {
 165                 CAEDRNativeReadData(env, idx);
 166             }
 167         }
 168     }
 169
 170     if (isAttached)
 171     {
 172         (*g_jvm)->DetachCurrentThread(g_jvm);
 173     }
 174
 175     OICFree(ctx);
 176
 177     OIC_LOG(DEBUG, TAG, "OUT - CAReceiveHandler");
 178 }
 179
 180 static void CAAcceptHandler(void *data)
 181 {
 182     OIC_LOG(DEBUG, TAG, "AcceptThread start");
 183
 184     VERIFY_NON_NULL_VOID(data, TAG, "data is null");
 185
 186     bool isAttached = false;
 187     JNIEnv* env = NULL;
 188     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 189     if (JNI_OK != res)
 190     {
 191         OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
 192         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 193
 194         if (JNI_OK != res)
 195         {
 196             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 197             return;
 198         }
 199         isAttached = true;
 200     }
 201
 202     jobject jni_obj_BTServerSocket = CAEDRNativeListen(env);
 203     if (!jni_obj_BTServerSocket)
 204     {
 205         OIC_LOG(ERROR, TAG, "jni_obj_BTServerSocket is null");
 206
 207         if (isAttached)
 208         {
 209             (*g_jvm)->DetachCurrentThread(g_jvm);
 210         }
 211
 212         return;
 213     }
 214
 215     ca_mutex_lock(g_mutexServerSocket);
 216     g_serverSocket = (*env)->NewGlobalRef(env, jni_obj_BTServerSocket);
 217     ca_mutex_unlock(g_mutexServerSocket);
 218
 219     CAAdapterAcceptThreadContext_t *ctx = (CAAdapterAcceptThreadContext_t *) data;
 220
 221     // it should be initialized for restart accept thread
 222     ca_mutex_lock(g_mutexAcceptServer);
 223     g_stopAccept = false;
 224     ca_mutex_unlock(g_mutexAcceptServer);
 225
 226     while (true != *(ctx->stopFlag))
 227     {
 228         // when BT state is changed with Off. its thread will be stopped
 229         if (!CAEDRNativeIsEnableBTAdapter(env))
 230         {
 231             OIC_LOG(INFO, TAG, "BT adapter is not enabled");
 232             ca_mutex_lock(g_mutexAcceptServer);
 233             g_stopAccept = true;
 234             ca_mutex_unlock(g_mutexAcceptServer);
 235             ca_mutex_lock(g_mutexServerSocket);
 236             g_serverSocket = NULL;
 237             ca_mutex_unlock(g_mutexServerSocket);
 238         }
 239         else
 240         {
 241             CAEDRNativeAccept(env, g_serverSocket);
 242         }
 243     }
 244
 245     if (isAttached)
 246     {
 247         (*g_jvm)->DetachCurrentThread(g_jvm);
 248     }
 249
 250     OICFree(ctx);
 251
 252     OIC_LOG(DEBUG, TAG, "AcceptThread finish");
 253
 254     return;
 255 }
 256
 257 /**
 258  * implement for adapter common method.
 259  */
 260 CAResult_t CAEDRServerStart()
 261 {
 262     if (!g_threadPoolHandle)
 263     {
 264         return CA_STATUS_NOT_INITIALIZED;
 265     }
 266
 267     ca_mutex_lock(g_mutexStartServerState);
 268     if (g_isStartServer)
 269     {
 270         OIC_LOG(DEBUG, TAG, "server already started");
 271         ca_mutex_unlock(g_mutexStartServerState);
 272         return CA_STATUS_OK;
 273     }
 274     ca_mutex_unlock(g_mutexStartServerState);
 275
 276     CAResult_t res = CAEDRServerStartAcceptThread();
 277     if (CA_STATUS_OK == res)
 278     {
 279         res = CAEDRStartReceiveThread(false);
 280         if (CA_STATUS_OK != res)
 281         {
 282             OIC_LOG(ERROR, TAG, "failed to start receive thread");
 283             CAEDRServerStop();
 284             return CA_STATUS_FAILED;
 285         }
 286         ca_mutex_lock(g_mutexStartServerState);
 287         g_isStartServer = true;
 288         ca_mutex_unlock(g_mutexStartServerState);
 289     }
 290
 291     return res;
 292 }
 293
 294 CAResult_t CAEDRServerStop()
 295 {
 296     CAEDRStopReceiveThread();
 297
 298     ca_mutex_lock(g_mutexAcceptServer);
 299     g_stopAccept = true;
 300     ca_mutex_unlock(g_mutexAcceptServer);
 301
 302     if (!g_jvm)
 303     {
 304         OIC_LOG(DEBUG, TAG, "g_jvm is null");
 305         return CA_STATUS_FAILED;
 306     }
 307
 308     bool isAttached = false;
 309     JNIEnv* env = NULL;
 310     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 311     if (JNI_OK != res)
 312     {
 313         OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
 314         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 315
 316         if (JNI_OK != res)
 317         {
 318             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 319             return CA_STATUS_FAILED;
 320         }
 321         isAttached = true;
 322     }
 323
 324     CAEDRNatvieCloseServerTask(env);
 325     ca_mutex_lock(g_mutexStartServerState);
 326     g_isStartServer = false;
 327     ca_mutex_unlock(g_mutexStartServerState);
 328
 329     if (isAttached)
 330     {
 331         (*g_jvm)->DetachCurrentThread(g_jvm);
 332     }
 333
 334     return CA_STATUS_OK;
 335 }
 336
 337 void CAEDRSetPacketReceivedCallback(CAEDRDataReceivedCallback packetReceivedCallback)
 338 {
 339     g_edrPacketReceivedCallback = packetReceivedCallback;
 340 }
 341
 342 static void CAEDRServerDestroyMutex()
 343 {
 344     if (g_mutexReceiveServer)
 345     {
 346         ca_mutex_free(g_mutexReceiveServer);
 347         g_mutexReceiveServer = NULL;
 348     }
 349
 350     if (g_mutexAcceptServer)
 351     {
 352         ca_mutex_free(g_mutexAcceptServer);
 353         g_mutexAcceptServer = NULL;
 354     }
 355
 356     if (g_mutexServerSocket)
 357     {
 358         ca_mutex_free(g_mutexServerSocket);
 359         g_mutexServerSocket = NULL;
 360     }
 361
 362     if (g_mutexStateList)
 363     {
 364         ca_mutex_free(g_mutexStateList);
 365         g_mutexStateList = NULL;
 366     }
 367
 368     if (g_mutexObjectList)
 369     {
 370         ca_mutex_free(g_mutexObjectList);
 371         g_mutexObjectList = NULL;
 372     }
 373
 374     if (g_mutexStartServerState)
 375     {
 376         ca_mutex_free(g_mutexStartServerState);
 377         g_mutexStartServerState = NULL;
 378     }
 379 }
 380
 381 static CAResult_t CAEDRServerCreateMutex()
 382 {
 383     g_mutexReceiveServer = ca_mutex_new();
 384     if (!g_mutexReceiveServer)
 385     {
 386         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 387         return CA_STATUS_FAILED;
 388     }
 389
 390     g_mutexAcceptServer = ca_mutex_new();
 391     if (!g_mutexAcceptServer)
 392     {
 393         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 394
 395         CAEDRServerDestroyMutex();
 396         return CA_STATUS_FAILED;
 397     }
 398
 399     g_mutexServerSocket = ca_mutex_new();
 400     if (!g_mutexServerSocket)
 401     {
 402         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 403
 404         CAEDRServerDestroyMutex();
 405         return CA_STATUS_FAILED;
 406     }
 407
 408     g_mutexStateList = ca_mutex_new();
 409     if (!g_mutexStateList)
 410     {
 411         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 412
 413         CAEDRServerDestroyMutex();
 414         return CA_STATUS_FAILED;
 415     }
 416
 417     g_mutexObjectList = ca_mutex_new();
 418     if (!g_mutexObjectList)
 419     {
 420         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 421
 422         CAEDRServerDestroyMutex();
 423         return CA_STATUS_FAILED;
 424     }
 425
 426     g_mutexStartServerState = ca_mutex_new();
 427     if (!g_mutexStartServerState)
 428     {
 429         OIC_LOG(ERROR, TAG, "Failed to created mutex!");
 430
 431         CAEDRServerDestroyMutex();
 432         return CA_STATUS_FAILED;
 433     }
 434
 435     return CA_STATUS_OK;
 436 }
 437
 438 void CAEDRServerJniInit()
 439 {
 440     OIC_LOG(DEBUG, TAG, "CAEDRServerJniInit");
 441     g_jvm = CANativeJNIGetJavaVM();
 442 }
 443
 444 CAResult_t CAEDRServerInitialize(ca_thread_pool_t handle)
 445 {
 446     OIC_LOG(DEBUG, TAG, "CAEDRServerInitialize");
 447     VERIFY_NON_NULL(handle, TAG, "handle is NULL");
 448
 449     g_threadPoolHandle = handle;
 450     CAEDRServerJniInit();
 451
 452     return CAEDRServerCreateMutex();
 453 }
 454
 455 CAResult_t CAEDRServerStartAcceptThread()
 456 {
 457     bool isAttached = false;
 458     JNIEnv* env = NULL;
 459     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 460     if (JNI_OK != res)
 461     {
 462         OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
 463         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 464
 465         if (JNI_OK != res)
 466         {
 467             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 468             return CA_STATUS_FAILED;
 469         }
 470         isAttached = true;
 471     }
 472
 473     jstring jni_address = CAEDRNativeGetLocalDeviceAddress(env);
 474     if (jni_address)
 475     {
 476         const char* localAddress = (*env)->GetStringUTFChars(env, jni_address, NULL);
 477         OIC_LOG_V(DEBUG, TAG, "My BT Address is %s", localAddress);
 478         (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
 479     }
 480
 481     ca_mutex_lock(g_mutexStateList);
 482     CAEDRNativeCreateDeviceStateList();
 483     ca_mutex_unlock(g_mutexStateList);
 484
 485     ca_mutex_lock(g_mutexObjectList);
 486     CAEDRNativeCreateDeviceSocketList();
 487     ca_mutex_unlock(g_mutexObjectList);
 488
 489     if (isAttached)
 490     {
 491         (*g_jvm)->DetachCurrentThread(g_jvm);
 492     }
 493
 494     CAAdapterReceiveThreadContext_t *ctx = (CAAdapterReceiveThreadContext_t *) OICMalloc(
 495             sizeof(CAAdapterReceiveThreadContext_t));
 496     if (!ctx)
 497     {
 498         OIC_LOG(ERROR, TAG, "Out of memory!");
 499         return CA_MEMORY_ALLOC_FAILED;
 500     }
 501
 502     ctx->stopFlag = &g_stopAccept;
 503     if (CA_STATUS_OK != ca_thread_pool_add_task(g_threadPoolHandle, CAAcceptHandler, (void *) ctx))
 504     {
 505         OIC_LOG(ERROR, TAG, "Failed to create read thread!");
 506         OICFree((void *) ctx);
 507         return CA_STATUS_FAILED;
 508     }
 509
 510     return CA_STATUS_OK;
 511 }
 512
 513 void CAEDRServerTerminate()
 514 {
 515     OIC_LOG(DEBUG, TAG, "CAEDRServerTerminate");
 516
 517     if (!g_jvm)
 518     {
 519         return;
 520     }
 521     bool isAttached = false;
 522     JNIEnv* env = NULL;
 523     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 524     if (JNI_OK != res)
 525     {
 526         OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
 527         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 528
 529         if (JNI_OK != res)
 530         {
 531             OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
 532             return;
 533         }
 534         isAttached = true;
 535     }
 536
 537     CAEDRNativeSocketCloseToAll(env);
 538
 539     if (isAttached)
 540     {
 541         (*g_jvm)->DetachCurrentThread(g_jvm);
 542     }
 543
 544     CAEDRNativeRemoveAllDeviceState();
 545     CAEDRNativeRemoveAllDeviceSocket(env);
 546
 547     // delete mutex
 548     CAEDRServerDestroyMutex();
 549 }
 550
 551 CAResult_t CAEDRStartReceiveThread(bool isSecured)
 552 {
 553     OIC_LOG(DEBUG, TAG, "CAEDRStartReceiveThread");
 554
 555     ca_mutex_lock(g_mutexReceiveServer);
 556
 557     /**
 558      * The task to listen for data from unicast is added to the thread pool.
 559      * This is a blocking call is made where we try to receive some data..
 560      * We will keep waiting until some data is received.
 561      * This task will be terminated when thread pool is freed on stopping the adapters.
 562      * Thread context will be freed by thread on exit.
 563      */
 564     CAAdapterReceiveThreadContext_t *ctx = (CAAdapterReceiveThreadContext_t *) OICMalloc(
 565             sizeof(CAAdapterReceiveThreadContext_t));
 566     if (!ctx)
 567     {
 568         OIC_LOG(ERROR, TAG, "Out of memory!");
 569         ca_mutex_unlock(g_mutexReceiveServer);
 570         return CA_MEMORY_ALLOC_FAILED;
 571     }
 572
 573     g_stopUnicast = false;
 574     ctx->stopFlag = &g_stopUnicast;
 575     ctx->type = isSecured ? CA_SECURED_UNICAST_SERVER : CA_UNICAST_SERVER;
 576     if (CA_STATUS_OK != ca_thread_pool_add_task(g_threadPoolHandle, CAReceiveHandler, (void *) ctx))
 577     {
 578         OIC_LOG(ERROR, TAG, "Failed to create read thread!");
 579         ca_mutex_unlock(g_mutexReceiveServer);
 580         OICFree((void *) ctx);
 581         return CA_STATUS_FAILED;
 582     }
 583     ca_mutex_unlock(g_mutexReceiveServer);
 584
 585     OIC_LOG(DEBUG, TAG, "OUT");
 586     return CA_STATUS_OK;
 587 }
 588
 589 CAResult_t CAEDRStopReceiveThread()
 590 {
 591     OIC_LOG(DEBUG, TAG, "CAEDRStopReceiveThread");
 592
 593     ca_mutex_lock(g_mutexReceiveServer);
 594     g_stopUnicast = true;
 595     ca_mutex_unlock(g_mutexReceiveServer);
 596
 597     return CA_STATUS_OK;
 598 }
 599
 600 CAResult_t CAEDRNativeReadData(JNIEnv *env, uint32_t idx)
 601 {
 602     if ((*env)->ExceptionCheck(env))
 603     {
 604         (*env)->ExceptionDescribe(env);
 605         (*env)->ExceptionClear(env);
 606         OIC_LOG(ERROR, TAG, "env error!!");
 607         return CA_STATUS_FAILED;
 608     }
 609
 610     jobject jni_obj_inputStream = CAEDRNativeGetInputStream(idx);
 611     if (!jni_obj_inputStream)
 612     {
 613         OIC_LOG(ERROR, TAG, "jni_obj_inputStream is null");
 614         return CA_STATUS_FAILED;
 615     }
 616
 617     jmethodID jni_mid_available = CAGetJNIMethodID(env, "java/io/InputStream", "available", "()I");
 618     if (!jni_mid_available)
 619     {
 620         OIC_LOG(ERROR, TAG, "jni_mid_available is null");
 621         return CA_STATUS_FAILED;
 622     }
 623
 624     jint available = (*env)->CallIntMethod(env, jni_obj_inputStream, jni_mid_available);
 625
 626     if (0 < available)
 627     {
 628         jobject jni_obj_socket = CAEDRNativeGetDeviceSocket(idx);
 629         if (!jni_obj_socket)
 630         {
 631             OIC_LOG(ERROR, TAG, "jni_obj_socket is null");
 632             return CA_STATUS_FAILED;
 633         }
 634
 635         jstring jni_str_address = CAEDRNativeGetAddressFromDeviceSocket(env, jni_obj_socket);
 636         if (!jni_str_address)
 637         {
 638             OIC_LOG(ERROR, TAG, "jni_str_address is null");
 639             return CA_STATUS_FAILED;
 640         }
 641
 642         const char* address = (*env)->GetStringUTFChars(env, jni_str_address, NULL);
 643         if (!address)
 644         {
 645             OIC_LOG(ERROR, TAG, "address is null");
 646             (*env)->DeleteLocalRef(env, jni_str_address);
 647             return CA_STATUS_FAILED;
 648         }
 649
 650         CAConnectedDeviceInfo_t *deviceInfo =
 651                 (CAConnectedDeviceInfo_t *) CAEDRGetDeviceInfoFromAddress(address);
 652         if (!deviceInfo)
 653         {
 654             OIC_LOG(ERROR, TAG, "failed to get device info from list");
 655             (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 656             (*env)->DeleteLocalRef(env, jni_str_address);
 657             return CA_STATUS_FAILED;
 658         }
 659
 660         jint bufSize = (deviceInfo->totalDataLen == 0) ? EDR_MAX_HEADER_LEN
 661                                                        : deviceInfo->totalDataLen;
 662         if (!deviceInfo->recvData)
 663         {
 664             deviceInfo->recvData = OICCalloc(1, bufSize);
 665             if (!deviceInfo->recvData)
 666             {
 667                 OIC_LOG(ERROR, TAG, "out of memory");
 668                 (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 669                 (*env)->DeleteLocalRef(env, jni_str_address);
 670                 return CA_STATUS_FAILED;
 671             }
 672         }
 673
 674         jint remainSize = (jint) bufSize - deviceInfo->recvDataLen;
 675         if (0 >= remainSize)
 676         {
 677             OIC_LOG(ERROR, TAG, "remainSize value is invalid.");
 678             (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 679             (*env)->DeleteLocalRef(env, jni_str_address);
 680             return CA_STATUS_FAILED;
 681         }
 682
 683         jbyteArray jbuf = (*env)->NewByteArray(env, remainSize);
 684         if (!jbuf)
 685         {
 686             OIC_LOG(ERROR, TAG, "jbuf is null");
 687             (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 688             (*env)->DeleteLocalRef(env, jni_str_address);
 689             return CA_STATUS_FAILED;
 690         }
 691
 692         jmethodID jni_mid_read = CAGetJNIMethodID(env, "java/io/InputStream", "read", "([BII)I");
 693         if (!jni_mid_read)
 694         {
 695             OIC_LOG(ERROR, TAG, "jni_mid_read is null");
 696             (*env)->DeleteLocalRef(env, jbuf);
 697             (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 698             (*env)->DeleteLocalRef(env, jni_str_address);
 699             return CA_STATUS_FAILED;
 700         }
 701
 702         OIC_LOG_V(DEBUG, TAG, "read InputStream (idx:%d, addr:%s)", idx, address);
 703         jint recvLen = (*env)->CallIntMethod(env, jni_obj_inputStream, jni_mid_read,
 704                                              jbuf, (jint) 0, remainSize);
 705         if (-1 == recvLen)
 706         {
 707             OIC_LOG(ERROR, TAG, "recvLen is -1");
 708             (*env)->DeleteLocalRef(env, jbuf);
 709             (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 710             (*env)->DeleteLocalRef(env, jni_str_address);
 711             return CA_STATUS_FAILED;
 712         }
 713         OIC_LOG_V(DEBUG, TAG, "read success (length: %d bytes)", recvLen);
 714
 715         jbyte* buf = (*env)->GetByteArrayElements(env, jbuf, NULL);
 716         if (!buf)
 717         {
 718             OIC_LOG(ERROR, TAG, "buf is null");
 719             (*env)->DeleteLocalRef(env, jbuf);
 720             (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 721             (*env)->DeleteLocalRef(env, jni_str_address);
 722             return CA_STATUS_FAILED;
 723         }
 724         memcpy(deviceInfo->recvData + deviceInfo->recvDataLen, (const char*) buf, recvLen);
 725         deviceInfo->recvDataLen += recvLen;
 726
 727         (*env)->ReleaseByteArrayElements(env, jbuf, buf, 0);
 728         (*env)->DeleteLocalRef(env, jbuf);
 729
 730         if (!deviceInfo->totalDataLen)
 731         {
 732             coap_transport_t transport = coap_get_tcp_header_type_from_initbyte(
 733                     ((unsigned char *) deviceInfo->recvData)[0] >> 4);
 734             size_t headerLen = coap_get_tcp_header_length_for_transport(transport);
 735             if (deviceInfo->recvData && deviceInfo->recvDataLen >= headerLen)
 736             {
 737                 deviceInfo->totalDataLen = coap_get_total_message_length(deviceInfo->recvData,
 738                                                                          deviceInfo->recvDataLen);
 739                 OIC_LOG_V(DEBUG, TAG, "total data length [%d] bytes", deviceInfo->totalDataLen);
 740
 741                 uint8_t *newBuf = OICRealloc(deviceInfo->recvData, deviceInfo->totalDataLen);
 742                 if (!newBuf)
 743                 {
 744                     OIC_LOG(ERROR, TAG, "out of memory");
 745                     (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 746                     (*env)->DeleteLocalRef(env, jni_str_address);
 747                     return CA_STATUS_FAILED;
 748                 }
 749                 deviceInfo->recvData = newBuf;
 750             }
 751         }
 752
 753         if (deviceInfo->totalDataLen == deviceInfo->recvDataLen)
 754         {
 755             if ((*env)->ExceptionCheck(env))
 756             {
 757                 OIC_LOG(ERROR, TAG, "read Error!!!");
 758                 (*env)->ExceptionDescribe(env);
 759                 (*env)->ExceptionClear(env);
 760
 761                 // update state to disconnect
 762                 // the socket will be close next read thread routine
 763                 ca_mutex_lock(g_mutexStateList);
 764                 CAEDRUpdateDeviceState(STATE_DISCONNECTED, address);
 765                 ca_mutex_unlock(g_mutexStateList);
 766
 767                 (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 768                 (*env)->DeleteLocalRef(env, jni_str_address);
 769                 return CA_STATUS_FAILED;
 770             }
 771
 772             if (g_edrPacketReceivedCallback)
 773             {
 774                 OIC_LOG_V(DEBUG, TAG, "data will be sent to callback routine: %s, %d",
 775                           deviceInfo->recvData, deviceInfo->recvDataLen);
 776
 777                 uint32_t sentLength = 0;
 778                 g_edrPacketReceivedCallback(address, (void*) deviceInfo->recvData,
 779                                             deviceInfo->recvDataLen, &sentLength);
 780
 781                 OICFree(deviceInfo->recvData);
 782                 deviceInfo->recvData = NULL;
 783                 deviceInfo->recvDataLen = 0;
 784                 deviceInfo->totalDataLen = 0;
 785             }
 786         }
 787
 788         (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
 789         (*env)->DeleteLocalRef(env, jni_str_address);
 790     }
 791
 792     return CA_STATUS_OK;
 793 }
 794
 795 void CANativeStartListenTask(JNIEnv *env)
 796 {
 797     jobject jni_obj_BTServerSocket = CAEDRNativeListen(env);
 798     if (!jni_obj_BTServerSocket)
 799     {
 800         OIC_LOG(ERROR, TAG, "jni_obj_BTServerSocket is null");
 801         return;
 802     }
 803
 804     ca_mutex_lock(g_mutexServerSocket);
 805     g_serverSocket = (*env)->NewGlobalRef(env, jni_obj_BTServerSocket);
 806     ca_mutex_unlock(g_mutexServerSocket);
 807 }
 808
 809 jobject CAEDRNativeListen(JNIEnv *env)
 810 {
 811     OIC_LOG(DEBUG, TAG, "CAEDRNativeListen - IN");
 812
 813     if (!CAEDRNativeIsEnableBTAdapter(env))
 814     {
 815         OIC_LOG(INFO, TAG, "BT adapter is not enabled");
 816         return NULL;
 817     }
 818
 819     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
 820     if (!jni_cid_BTAdapter)
 821     {
 822         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
 823         return NULL;
 824     }
 825
 826     // get BTadpater
 827     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 828                                                                     "getDefaultAdapter",
 829                                                                     METHODID_OBJECTNONPARAM);
 830     if (!jni_mid_getDefaultAdapter)
 831     {
 832         OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
 833         return NULL;
 834     }
 835
 836     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 837                                                                jni_mid_getDefaultAdapter);
 838     if (!jni_obj_BTAdapter)
 839     {
 840         OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
 841         return NULL;
 842     }
 843
 844     // get listen method ID
 845     jmethodID jni_mid_listen = (*env)->GetMethodID(
 846             env, jni_cid_BTAdapter, "listenUsingInsecureRfcommWithServiceRecord",
 847             "(Ljava/lang/String;Ljava/util/UUID;)Landroid/bluetooth/BluetoothServerSocket;");
 848     if (!jni_mid_listen)
 849     {
 850         OIC_LOG(ERROR, TAG, "jni_mid_listen is null");
 851         return NULL;
 852     }
 853     // listenUsingInsecureRfcommWithServiceRecord  / listenUsingRfcommWithServiceRecord
 854     // setting UUID
 855     jclass jni_cid_uuid = (*env)->FindClass(env, CLASSPATH_BT_UUID);
 856     if (!jni_cid_uuid)
 857     {
 858         OIC_LOG(ERROR, TAG, "jni_mid_listen is null");
 859         return NULL;
 860     }
 861
 862     jmethodID jni_mid_fromString = (*env)->GetStaticMethodID(
 863             env, jni_cid_uuid, "fromString", "(Ljava/lang/String;)Ljava/util/UUID;");
 864     if (!jni_mid_fromString)
 865     {
 866         OIC_LOG(ERROR, TAG, "jni_mid_fromString is null");
 867         return NULL;
 868     }
 869
 870     jstring jni_uuid = (*env)->NewStringUTF(env, OIC_EDR_SERVICE_ID);
 871     if (!jni_uuid)
 872     {
 873         OIC_LOG(ERROR, TAG, "jni_uuid is null");
 874         return NULL;
 875     }
 876     jobject jni_obj_uuid = (*env)->CallStaticObjectMethod(env, jni_cid_uuid, jni_mid_fromString,
 877                                                           jni_uuid);
 878     if (!jni_obj_uuid)
 879     {
 880         OIC_LOG(ERROR, TAG, "jni_obj_uuid is null");
 881         return NULL;
 882     }
 883
 884     // create socket
 885     jstring jni_name = (*env)->NewStringUTF(env, "BluetoothTestSecure");
 886     if (!jni_name)
 887     {
 888         OIC_LOG(ERROR, TAG, "jni_name is null");
 889         return NULL;
 890     }
 891     jobject jni_obj_BTServerSocket = (*env)->CallObjectMethod(env, jni_obj_BTAdapter, jni_mid_listen,
 892                                                              jni_name, jni_obj_uuid);
 893     if (!jni_obj_BTServerSocket)
 894     {
 895         OIC_LOG(ERROR, TAG, "jni_obj_BTServerSocket is null");
 896         return NULL;
 897     }
 898
 899     OIC_LOG(DEBUG, TAG, "CAEDRNativeListen - OUT");
 900
 901     return jni_obj_BTServerSocket;
 902 }
 903
 904 void CAEDRNativeAccept(JNIEnv *env, jobject serverSocketObject)
 905 {
 906     OIC_LOG(DEBUG, TAG, "CAEDRNativeAccept - IN");
 907
 908     if (NULL != serverSocketObject)
 909     {
 910         jmethodID jni_mid_accept = CAGetJNIMethodID(env, CLASSPATH_BT_SERVER_SOCKET,
 911                                                     "accept",
 912                                                     "()Landroid/bluetooth/BluetoothSocket;");
 913         if (!jni_mid_accept)
 914         {
 915             OIC_LOG(ERROR, TAG, "jni_mid_accept is null");
 916             return;
 917         }
 918
 919         OIC_LOG(DEBUG, TAG, "waiting for the new connection request...");
 920
 921         jobject jni_obj_BTSocket = (*env)->CallObjectMethod(env, serverSocketObject,
 922                                                             jni_mid_accept);
 923         if (!jni_obj_BTSocket)
 924         {
 925             OIC_LOG(ERROR, TAG, "jni_obj_BTSocket is null");
 926
 927             if ((*env)->ExceptionCheck(env))
 928             {
 929                 OIC_LOG(ERROR, TAG, "socket might closed or timeout!!!");
 930                 (*env)->ExceptionDescribe(env);
 931                 (*env)->ExceptionClear(env);
 932                 return;
 933             }
 934         }
 935
 936         // get remote address
 937         jstring j_str_address = CAEDRNativeGetAddressFromDeviceSocket(env, jni_obj_BTSocket);
 938         if (!j_str_address)
 939         {
 940             OIC_LOG(ERROR, TAG, "j_str_address is null");
 941             return;
 942         }
 943
 944         const char* address = (*env)->GetStringUTFChars(env, j_str_address, NULL);
 945
 946         OIC_LOG_V(INFO, TAG, "accept a new connection from [%s]", address);
 947
 948         // update state
 949         ca_mutex_lock(g_mutexStateList);
 950         CAEDRUpdateDeviceState(STATE_CONNECTED, address);
 951         ca_mutex_unlock(g_mutexStateList);
 952
 953         (*env)->ReleaseStringUTFChars(env, j_str_address, address);
 954         (*env)->DeleteLocalRef(env, j_str_address);
 955
 956         // set socket to list
 957         jobject jni_socket = (*env)->NewGlobalRef(env, jni_obj_BTSocket);
 958         if (!jni_socket)
 959         {
 960             OIC_LOG(ERROR, TAG, "jni_socket is null");
 961             (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
 962             return;
 963         }
 964
 965         ca_mutex_lock(g_mutexObjectList);
 966         CAEDRNativeAddDeviceSocketToList(env, jni_socket);
 967         ca_mutex_unlock(g_mutexObjectList);
 968
 969         (*env)->DeleteGlobalRef(env, jni_socket);
 970         (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
 971     }
 972     else
 973     {
 974         OIC_LOG(DEBUG, TAG, "serverSocket is close previously");
 975     }
 976
 977     OIC_LOG(DEBUG, TAG, "CAEDRNativeAccept - OUT");
 978 }
 979
 980 /**
 981  * InputStream & BluetoothServerSocket will be close for Terminating.
 982  */
 983 void CAEDRNatvieCloseServerTask(JNIEnv* env)
 984 {
 985     if (g_serverSocket)
 986     {
 987         OIC_LOG(DEBUG, TAG, "Accept Resource will be close");
 988
 989         jmethodID jni_mid_close = CAGetJNIMethodID(env, CLASSPATH_BT_SERVER_SOCKET,
 990                                                    "close", "()V");
 991         if (!jni_mid_close)
 992         {
 993             OIC_LOG(ERROR, TAG, "jni_mid_close is null");
 994             return;
 995         }
 996
 997         (*env)->CallVoidMethod(env, g_serverSocket, jni_mid_close);
 998         (*env)->DeleteGlobalRef(env, g_serverSocket);
 999         g_serverSocket = NULL;
1000
1001         OIC_LOG(DEBUG, TAG, "close accept obj");
1002     }
1003 }