1 /* ****************************************************************
3 * Copyright 2014 Samsung Electronics All Rights Reserved.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 ******************************************************************/
25 #include "caedrinterface.h"
26 #include "caedrutils.h"
27 #include "caedrserver.h"
29 #include "oic_malloc.h"
30 #include "cathreadpool.h" /* for thread pool */
32 #include "uarraylist.h"
33 #include "caadapterutils.h"
34 #include "org_iotivity_ca_CaEdrInterface.h"
35 #include "oic_string.h"
37 #define TAG PCF("OIC_CA_EDR_SERVER")
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";
44 static ca_thread_pool_t g_threadPoolHandle = NULL;
49 * Maximum CoAP over TCP header length
50 * to know the total data length.
52 #define EDR_MAX_HEADER_LEN 6
55 * Mutex to synchronize receive server.
57 static ca_mutex g_mutexReceiveServer = NULL;
60 * Flag to control the Receive Unicast Data Thread.
62 static bool g_stopUnicast = false;
65 * Mutex to synchronize accept server.
67 static ca_mutex g_mutexAcceptServer = NULL;
70 * Flag to control the Accept Thread.
72 static bool g_stopAccept = false;
75 * Mutex to synchronize server socket.
77 static ca_mutex g_mutexServerSocket = NULL;
80 * Flag to control the server socket.
82 static jobject g_serverSocket = NULL;
85 * Mutex to synchronize device state list.
87 static ca_mutex g_mutexStateList = NULL;
90 * Mutex to synchronize device object list.
92 static ca_mutex g_mutexObjectList = NULL;
95 * Thread context information for unicast, multicast and secured unicast server.
100 CAAdapterServerType_t type;
101 } CAAdapterReceiveThreadContext_t;
106 } CAAdapterAcceptThreadContext_t;
109 * Maintains the callback to be notified when data received from remote
112 static CAEDRDataReceivedCallback g_edrPacketReceivedCallback = NULL;
114 static void CAReceiveHandler(void *data)
116 OIC_LOG(DEBUG, TAG, "IN - CAReceiveHandler..");
118 VERIFY_NON_NULL_VOID(data, TAG, "Invalid thread context");
120 bool isAttached = false;
122 jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
125 OIC_LOG(DEBUG, TAG, "CAReceiveHandler - Could not get JNIEnv pointer");
126 res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
130 OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
136 CAAdapterReceiveThreadContext_t *ctx = (CAAdapterReceiveThreadContext_t *) data;
138 while (true != *(ctx->stopFlag))
140 if (!CAEDRNativeIsEnableBTAdapter(env))
142 OIC_LOG(INFO, TAG, "BT adapter is not enabled");
146 // if new socket object is added in socket list after below logic is ran.
147 // new socket will be started to read after next while loop
148 uint32_t length = CAEDRGetSocketListLength();
151 for (uint32_t idx = 0; idx < length; idx++)
153 CAEDRNativeReadData(env, idx);
160 (*g_jvm)->DetachCurrentThread(g_jvm);
165 OIC_LOG(DEBUG, TAG, "OUT - CAReceiveHandler");
168 static void CAAcceptHandler(void *data)
170 OIC_LOG(DEBUG, TAG, "AcceptThread start");
172 VERIFY_NON_NULL_VOID(data, TAG, "data is null");
174 bool isAttached = false;
176 jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
179 OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
180 res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
184 OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
190 jobject jni_obj_BTServerSocket = CAEDRNativeListen(env);
191 if (!jni_obj_BTServerSocket)
193 OIC_LOG(ERROR, TAG, "jni_obj_BTServerSocket is null");
197 (*g_jvm)->DetachCurrentThread(g_jvm);
203 ca_mutex_lock(g_mutexServerSocket);
204 g_serverSocket = (*env)->NewGlobalRef(env, jni_obj_BTServerSocket);
205 ca_mutex_unlock(g_mutexServerSocket);
207 CAAdapterAcceptThreadContext_t *ctx = (CAAdapterAcceptThreadContext_t *) data;
209 // it should be initialized for restart accept thread
210 ca_mutex_lock(g_mutexAcceptServer);
211 g_stopAccept = false;
212 ca_mutex_unlock(g_mutexAcceptServer);
214 while (true != *(ctx->stopFlag))
216 // when BT state is changed with Off. its thread will be stopped
217 if (!CAEDRNativeIsEnableBTAdapter(env))
219 OIC_LOG(INFO, TAG, "BT adapter is not enabled");
220 ca_mutex_lock(g_mutexAcceptServer);
222 ca_mutex_unlock(g_mutexAcceptServer);
223 ca_mutex_lock(g_mutexServerSocket);
224 g_serverSocket = NULL;
225 ca_mutex_unlock(g_mutexServerSocket);
229 CAEDRNativeAccept(env, g_serverSocket);
235 (*g_jvm)->DetachCurrentThread(g_jvm);
240 OIC_LOG(DEBUG, TAG, "AcceptThread finish");
246 * implement for adapter common method.
248 CAResult_t CAEDRServerStart()
250 if (!g_threadPoolHandle)
252 return CA_STATUS_NOT_INITIALIZED;
255 CAResult_t res = CAEDRServerStartAcceptThread();
256 if (CA_STATUS_OK == res)
258 res = CAEDRStartReceiveThread(false);
259 if (CA_STATUS_OK != res)
261 OIC_LOG(ERROR, TAG, "failed to start receive thread");
263 return CA_STATUS_FAILED;
270 CAResult_t CAEDRServerStop()
272 CAEDRStopReceiveThread();
274 ca_mutex_lock(g_mutexAcceptServer);
276 ca_mutex_unlock(g_mutexAcceptServer);
280 OIC_LOG(DEBUG, TAG, "g_jvm is null");
281 return CA_STATUS_FAILED;
284 bool isAttached = false;
286 jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
289 OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
290 res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
294 OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
295 return CA_STATUS_FAILED;
300 CAEDRNatvieCloseServerTask(env);
304 (*g_jvm)->DetachCurrentThread(g_jvm);
310 void CAEDRSetPacketReceivedCallback(CAEDRDataReceivedCallback packetReceivedCallback)
312 g_edrPacketReceivedCallback = packetReceivedCallback;
315 static void CAEDRServerDestroyMutex()
317 if (g_mutexReceiveServer)
319 ca_mutex_free(g_mutexReceiveServer);
320 g_mutexReceiveServer = NULL;
323 if (g_mutexAcceptServer)
325 ca_mutex_free(g_mutexAcceptServer);
326 g_mutexAcceptServer = NULL;
329 if (g_mutexServerSocket)
331 ca_mutex_free(g_mutexServerSocket);
332 g_mutexServerSocket = NULL;
335 if (g_mutexStateList)
337 ca_mutex_free(g_mutexStateList);
338 g_mutexStateList = NULL;
341 if (g_mutexObjectList)
343 ca_mutex_free(g_mutexObjectList);
344 g_mutexObjectList = NULL;
348 static CAResult_t CAEDRServerCreateMutex()
350 g_mutexReceiveServer = ca_mutex_new();
351 if (!g_mutexReceiveServer)
353 OIC_LOG(ERROR, TAG, "Failed to created mutex!");
354 return CA_STATUS_FAILED;
357 g_mutexAcceptServer = ca_mutex_new();
358 if (!g_mutexAcceptServer)
360 OIC_LOG(ERROR, TAG, "Failed to created mutex!");
362 CAEDRServerDestroyMutex();
363 return CA_STATUS_FAILED;
366 g_mutexServerSocket = ca_mutex_new();
367 if (!g_mutexServerSocket)
369 OIC_LOG(ERROR, TAG, "Failed to created mutex!");
371 CAEDRServerDestroyMutex();
372 return CA_STATUS_FAILED;
375 g_mutexStateList = ca_mutex_new();
376 if (!g_mutexStateList)
378 OIC_LOG(ERROR, TAG, "Failed to created mutex!");
380 CAEDRServerDestroyMutex();
381 return CA_STATUS_FAILED;
384 g_mutexObjectList = ca_mutex_new();
385 if (!g_mutexObjectList)
387 OIC_LOG(ERROR, TAG, "Failed to created mutex!");
389 CAEDRServerDestroyMutex();
390 return CA_STATUS_FAILED;
396 void CAEDRServerJniInit()
398 OIC_LOG(DEBUG, TAG, "CAEDRServerJniInit");
399 g_jvm = CANativeJNIGetJavaVM();
402 CAResult_t CAEDRServerInitialize(ca_thread_pool_t handle)
404 OIC_LOG(DEBUG, TAG, "CAEDRServerInitialize");
405 VERIFY_NON_NULL(handle, TAG, "handle is NULL");
407 g_threadPoolHandle = handle;
408 CAEDRServerJniInit();
410 return CAEDRServerCreateMutex();
413 CAResult_t CAEDRServerStartAcceptThread()
415 bool isAttached = false;
417 jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
420 OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
421 res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
425 OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
426 return CA_STATUS_FAILED;
431 jstring jni_address = CAEDRNativeGetLocalDeviceAddress(env);
434 const char* localAddress = (*env)->GetStringUTFChars(env, jni_address, NULL);
435 OIC_LOG_V(DEBUG, TAG, "My BT Address is %s", localAddress);
436 (*env)->ReleaseStringUTFChars(env, jni_address, localAddress);
439 ca_mutex_lock(g_mutexStateList);
440 CAEDRNativeCreateDeviceStateList();
441 ca_mutex_unlock(g_mutexStateList);
443 ca_mutex_lock(g_mutexObjectList);
444 CAEDRNativeCreateDeviceSocketList();
445 ca_mutex_unlock(g_mutexObjectList);
449 (*g_jvm)->DetachCurrentThread(g_jvm);
452 CAAdapterReceiveThreadContext_t *ctx = (CAAdapterReceiveThreadContext_t *) OICMalloc(
453 sizeof(CAAdapterReceiveThreadContext_t));
456 OIC_LOG(ERROR, TAG, "Out of memory!");
457 return CA_MEMORY_ALLOC_FAILED;
460 ctx->stopFlag = &g_stopAccept;
461 if (CA_STATUS_OK != ca_thread_pool_add_task(g_threadPoolHandle, CAAcceptHandler, (void *) ctx))
463 OIC_LOG(ERROR, TAG, "Failed to create read thread!");
464 OICFree((void *) ctx);
465 return CA_STATUS_FAILED;
471 void CAEDRServerTerminate()
473 OIC_LOG(DEBUG, TAG, "CAEDRServerTerminate");
479 bool isAttached = false;
481 jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
484 OIC_LOG(DEBUG, TAG, "Could not get JNIEnv pointer");
485 res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
489 OIC_LOG(ERROR, TAG, "AttachCurrentThread failed");
495 CAEDRNativeSocketCloseToAll(env);
499 (*g_jvm)->DetachCurrentThread(g_jvm);
502 CAEDRNativeRemoveAllDeviceState();
503 CAEDRNativeRemoveAllDeviceSocket(env);
506 CAEDRServerDestroyMutex();
509 CAResult_t CAEDRStartReceiveThread(bool isSecured)
511 OIC_LOG(DEBUG, TAG, "CAEDRStartReceiveThread");
513 ca_mutex_lock(g_mutexReceiveServer);
516 * The task to listen for data from unicast is added to the thread pool.
517 * This is a blocking call is made where we try to receive some data..
518 * We will keep waiting until some data is received.
519 * This task will be terminated when thread pool is freed on stopping the adapters.
520 * Thread context will be freed by thread on exit.
522 CAAdapterReceiveThreadContext_t *ctx = (CAAdapterReceiveThreadContext_t *) OICMalloc(
523 sizeof(CAAdapterReceiveThreadContext_t));
526 OIC_LOG(ERROR, TAG, "Out of memory!");
527 ca_mutex_unlock(g_mutexReceiveServer);
528 return CA_MEMORY_ALLOC_FAILED;
531 g_stopUnicast = false;
532 ctx->stopFlag = &g_stopUnicast;
533 ctx->type = isSecured ? CA_SECURED_UNICAST_SERVER : CA_UNICAST_SERVER;
534 if (CA_STATUS_OK != ca_thread_pool_add_task(g_threadPoolHandle, CAReceiveHandler, (void *) ctx))
536 OIC_LOG(ERROR, TAG, "Failed to create read thread!");
537 ca_mutex_unlock(g_mutexReceiveServer);
538 OICFree((void *) ctx);
539 return CA_STATUS_FAILED;
541 ca_mutex_unlock(g_mutexReceiveServer);
543 OIC_LOG(DEBUG, TAG, "OUT");
547 CAResult_t CAEDRStopReceiveThread()
549 OIC_LOG(DEBUG, TAG, "CAEDRStopReceiveThread");
551 ca_mutex_lock(g_mutexReceiveServer);
552 g_stopUnicast = true;
553 ca_mutex_unlock(g_mutexReceiveServer);
558 CAResult_t CAEDRNativeReadData(JNIEnv *env, uint32_t id)
560 if ((*env)->ExceptionCheck(env))
562 (*env)->ExceptionDescribe(env);
563 (*env)->ExceptionClear(env);
564 OIC_LOG(ERROR, TAG, "env error!!");
565 return CA_STATUS_FAILED;
568 jobject jni_obj_inputStream = CAEDRNativeGetInputStream(id);
569 if (!jni_obj_inputStream)
571 OIC_LOG(ERROR, TAG, "jni_obj_inputStream is null");
572 return CA_STATUS_FAILED;
575 jmethodID jni_mid_available = CAGetJNIMethodID(env, "java/io/InputStream", "available", "()I");
576 if (!jni_mid_available)
578 OIC_LOG(ERROR, TAG, "jni_mid_available is null");
579 return CA_STATUS_FAILED;
582 jint available = (*env)->CallIntMethod(env, jni_obj_inputStream, jni_mid_available);
586 jobject jni_obj_socket = CAEDRNativeGetDeviceSocket(id);
589 OIC_LOG(ERROR, TAG, "jni_obj_socket is null");
590 return CA_STATUS_FAILED;
592 jstring jni_str_address = CAEDRNativeGetAddressFromDeviceSocket(env, jni_obj_socket);
593 if (!jni_str_address)
595 OIC_LOG(ERROR, TAG, "jni_str_address is null");
596 return CA_STATUS_FAILED;
599 const char* address = (*env)->GetStringUTFChars(env, jni_str_address, NULL);
602 OIC_LOG(ERROR, TAG, "address is null");
603 (*env)->DeleteLocalRef(env, jni_str_address);
604 return CA_STATUS_FAILED;
607 OIC_LOG_V(DEBUG, TAG, "get InputStream..%d, %s", id, address);
608 jmethodID jni_mid_read = CAGetJNIMethodID(env, "java/io/InputStream", "read", "([BII)I");
611 OIC_LOG(ERROR, TAG, "jni_mid_read is null");
612 (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
613 (*env)->DeleteLocalRef(env, jni_str_address);
614 return CA_STATUS_FAILED;
617 CAConnectedDeviceInfo_t *deviceInfo =
618 (CAConnectedDeviceInfo_t *) CAEDRGetDeviceInfoFromAddress(address);
620 (*env)->ReleaseStringUTFChars(env, jni_str_address, address);
621 (*env)->DeleteLocalRef(env, jni_str_address);
624 OIC_LOG(ERROR, TAG, "failed to get device info from list");
625 return CA_STATUS_FAILED;
628 jint bufSize = (deviceInfo->totalDataLen == 0) ?
629 EDR_MAX_HEADER_LEN : deviceInfo->totalDataLen;
630 if (!deviceInfo->recvData)
632 deviceInfo->recvData = OICCalloc(1, bufSize);
633 if (!deviceInfo->recvData)
635 OIC_LOG(ERROR, TAG, "out of memory");
636 return CA_STATUS_FAILED;
640 jint remainSize = (jint) bufSize - deviceInfo->recvDataLen;
643 OIC_LOG(ERROR, TAG, "remainSize value is invalid.");
644 return CA_STATUS_FAILED;
646 jbyteArray jbuf = (*env)->NewByteArray(env, remainSize);
649 OIC_LOG(ERROR, TAG, "jbuf is null");
650 return CA_STATUS_FAILED;
653 jint recvLen = (*env)->CallIntMethod(env, jni_obj_inputStream, jni_mid_read,
654 jbuf, (jint) 0, remainSize);
657 OIC_LOG(ERROR, TAG, "recvLen is -1");
658 (*env)->DeleteLocalRef(env, jbuf);
659 return CA_STATUS_FAILED;
662 jbyte* buf = (*env)->GetByteArrayElements(env, jbuf, NULL);
665 OIC_LOG(ERROR, TAG, "buf is null");
666 (*env)->DeleteLocalRef(env, jbuf);
667 return CA_STATUS_FAILED;
669 memcpy(deviceInfo->recvData + deviceInfo->recvDataLen, (const char*) buf, recvLen);
670 deviceInfo->recvDataLen += recvLen;
672 (*env)->ReleaseByteArrayElements(env, jbuf, buf, 0);
673 (*env)->DeleteLocalRef(env, jbuf);
675 OIC_LOG(DEBUG, TAG, "read something from InputStream");
677 if (!deviceInfo->totalDataLen)
679 coap_transport_type transport = coap_get_tcp_header_type_from_initbyte(
680 ((unsigned char *) deviceInfo->recvData)[0] >> 4);
681 size_t headerLen = coap_get_tcp_header_length_for_transport(transport);
682 if (deviceInfo->recvData && deviceInfo->recvDataLen >= headerLen)
684 deviceInfo->totalDataLen = coap_get_total_message_length(deviceInfo->recvData,
685 deviceInfo->recvDataLen);
686 OIC_LOG_V(DEBUG, TAG, "total data length [%d] bytes", deviceInfo->totalDataLen);
688 uint8_t *newBuf = OICRealloc(deviceInfo->recvData, deviceInfo->totalDataLen);
691 OIC_LOG(ERROR, TAG, "out of memory");
692 return CA_STATUS_FAILED;
694 deviceInfo->recvData = newBuf;
698 if (deviceInfo->totalDataLen == deviceInfo->recvDataLen)
700 if ((*env)->ExceptionCheck(env))
702 OIC_LOG(ERROR, TAG, "read Error!!!");
703 (*env)->ExceptionDescribe(env);
704 (*env)->ExceptionClear(env);
706 // update state to disconnect
707 // the socket will be close next read thread routine
708 ca_mutex_lock(g_mutexStateList);
709 CAEDRUpdateDeviceState(STATE_DISCONNECTED, address);
710 ca_mutex_unlock(g_mutexStateList);
712 return CA_STATUS_FAILED;
715 if (g_edrPacketReceivedCallback)
717 OIC_LOG_V(DEBUG, TAG,"data will be sent to callback routine: \
718 %s, %d", deviceInfo->recvData, deviceInfo->recvDataLen);
720 uint32_t sentLength = 0;
721 g_edrPacketReceivedCallback(address, (void*) deviceInfo->recvData,
722 deviceInfo->recvDataLen, &sentLength);
724 OICFree(deviceInfo->recvData);
725 deviceInfo->recvData = NULL;
726 deviceInfo->recvDataLen = 0;
727 deviceInfo->totalDataLen = 0;
735 void CANativeStartListenTask(JNIEnv *env)
737 jobject jni_obj_BTServerSocket = CAEDRNativeListen(env);
738 if (!jni_obj_BTServerSocket)
740 OIC_LOG(ERROR, TAG, "jni_obj_BTServerSocket is null");
744 ca_mutex_lock(g_mutexServerSocket);
745 g_serverSocket = (*env)->NewGlobalRef(env, jni_obj_BTServerSocket);
746 ca_mutex_unlock(g_mutexServerSocket);
749 jobject CAEDRNativeListen(JNIEnv *env)
751 OIC_LOG(DEBUG, TAG, "CAEDRNativeListen - IN");
753 if (!CAEDRNativeIsEnableBTAdapter(env))
755 OIC_LOG(INFO, TAG, "BT adapter is not enabled");
759 jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADPATER);
760 if (!jni_cid_BTAdapter)
762 OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
767 jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
769 METHODID_OBJECTNONPARAM);
770 if (!jni_mid_getDefaultAdapter)
772 OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
776 jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
777 jni_mid_getDefaultAdapter);
778 if (!jni_obj_BTAdapter)
780 OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
784 // get listen method ID
785 jmethodID jni_mid_listen = (*env)->GetMethodID(
786 env, jni_cid_BTAdapter, "listenUsingInsecureRfcommWithServiceRecord",
787 "(Ljava/lang/String;Ljava/util/UUID;)Landroid/bluetooth/BluetoothServerSocket;");
790 OIC_LOG(ERROR, TAG, "jni_mid_listen is null");
793 // listenUsingInsecureRfcommWithServiceRecord / listenUsingRfcommWithServiceRecord
795 jclass jni_cid_uuid = (*env)->FindClass(env, CLASSPATH_BT_UUID);
798 OIC_LOG(ERROR, TAG, "jni_mid_listen is null");
802 jmethodID jni_mid_fromString = (*env)->GetStaticMethodID(
803 env, jni_cid_uuid, "fromString", "(Ljava/lang/String;)Ljava/util/UUID;");
804 if (!jni_mid_fromString)
806 OIC_LOG(ERROR, TAG, "jni_mid_fromString is null");
810 jstring jni_uuid = (*env)->NewStringUTF(env, OIC_EDR_SERVICE_ID);
813 OIC_LOG(ERROR, TAG, "jni_uuid is null");
816 jobject jni_obj_uuid = (*env)->CallStaticObjectMethod(env, jni_cid_uuid, jni_mid_fromString,
820 OIC_LOG(ERROR, TAG, "jni_obj_uuid is null");
825 jstring jni_name = (*env)->NewStringUTF(env, "BluetoothTestSecure");
828 OIC_LOG(ERROR, TAG, "jni_name is null");
831 jobject jni_obj_BTServerSocket = (*env)->CallObjectMethod(env, jni_obj_BTAdapter, jni_mid_listen,
832 jni_name, jni_obj_uuid);
833 if (!jni_obj_BTServerSocket)
835 OIC_LOG(ERROR, TAG, "jni_obj_BTServerSocket is null");
839 OIC_LOG(DEBUG, TAG, "CAEDRNativeListen - OUT");
841 return jni_obj_BTServerSocket;
844 void CAEDRNativeAccept(JNIEnv *env, jobject serverSocketObject)
846 OIC_LOG(DEBUG, TAG, "CAEDRNativeAccept - IN");
848 if (NULL != serverSocketObject)
850 jmethodID jni_mid_accept = CAGetJNIMethodID(env, CLASSPATH_BT_SERVER_SOCKET,
852 "()Landroid/bluetooth/BluetoothSocket;");
855 OIC_LOG(ERROR, TAG, "jni_mid_accept is null");
859 OIC_LOG(DEBUG, TAG, "waiting for the new connection request...");
861 jobject jni_obj_BTSocket = (*env)->CallObjectMethod(env, serverSocketObject,
863 if (!jni_obj_BTSocket)
865 OIC_LOG(ERROR, TAG, "jni_obj_BTSocket is null");
867 if ((*env)->ExceptionCheck(env))
869 OIC_LOG(ERROR, TAG, "socket might closed or timeout!!!");
870 (*env)->ExceptionDescribe(env);
871 (*env)->ExceptionClear(env);
876 // get remote address
877 jstring j_str_address = CAEDRNativeGetAddressFromDeviceSocket(env, jni_obj_BTSocket);
880 OIC_LOG(ERROR, TAG, "j_str_address is null");
884 const char* address = (*env)->GetStringUTFChars(env, j_str_address, NULL);
885 OIC_LOG_V(DEBUG, TAG, "received the connection request from [%s]", address);
887 // set socket to list
888 jobject jni_socket = (*env)->NewGlobalRef(env, jni_obj_BTSocket);
891 OIC_LOG(ERROR, TAG, "jni_socket is null");
892 (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
895 ca_mutex_lock(g_mutexObjectList);
896 CAEDRNativeAddDeviceSocketToList(env, jni_socket);
897 (*env)->DeleteGlobalRef(env, jni_socket);
898 (*env)->DeleteLocalRef(env, jni_obj_BTSocket);
899 ca_mutex_unlock(g_mutexObjectList);
902 ca_mutex_lock(g_mutexStateList);
903 CAEDRUpdateDeviceState(STATE_CONNECTED, address);
904 ca_mutex_unlock(g_mutexStateList);
906 (*env)->ReleaseStringUTFChars(env, j_str_address, address);
907 (*env)->DeleteLocalRef(env, j_str_address);
909 OIC_LOG_V(DEBUG, TAG, "connected with [%s]", address);
913 OIC_LOG(DEBUG, TAG, "serverSocket is close previously");
916 OIC_LOG(DEBUG, TAG, "CAEDRNativeAccept - OUT");
920 * InputStream & BluetoothServerSocket will be close for Terminating.
922 void CAEDRNatvieCloseServerTask(JNIEnv* env)
926 OIC_LOG(DEBUG, TAG, "Accept Resource will be close");
928 jmethodID jni_mid_close = CAGetJNIMethodID(env, CLASSPATH_BT_SERVER_SOCKET,
932 OIC_LOG(ERROR, TAG, "jni_mid_close is null");
936 (*env)->CallVoidMethod(env, g_serverSocket, jni_mid_close);
937 (*env)->DeleteGlobalRef(env, g_serverSocket);
938 g_serverSocket = NULL;
940 OIC_LOG(DEBUG, TAG, "close accept obj");