#include "caleutils.h"
#include "caleinterface.h"
#include "caadapterutils.h"
+#include "calestate.h"
#include "logger.h"
#include "oic_malloc.h"
#include "cathreadpool.h"
-#include "camutex.h"
+#include "octhread.h"
#include "uarraylist.h"
#include "org_iotivity_ca_CaLeServerInterface.h"
-#define TAG PCF("CA_LE_SERVER")
+#define TAG PCF("OIC_CA_LE_SERVER")
+
+#define WAIT_TIME_WRITE_CHARACTERISTIC 10000000
+#define INVALID_STATE -1
static JavaVM *g_jvm = NULL;
static jobject g_context = NULL;
static jobject g_bluetoothGattServer = NULL;
static jobject g_bluetoothGattServerCallback = NULL;
static jobject g_leAdvertiseCallback = NULL;
+static jobject g_bluetoothManager = NULL;
static CAPacketReceiveCallback g_packetReceiveCallback = NULL;
static CABLEErrorHandleCallback g_serverErrorCallback;
static u_arraylist_t *g_connectedDeviceList = NULL;
-static ca_thread_pool_t g_threadPoolHandle = NULL;
+static u_arraylist_t *g_deviceStateList = NULL;
static bool g_isStartServer = false;
static bool g_isInitializedServer = false;
-static CABLEServerDataReceivedCallback g_CABLEServerDataReceivedCallback = NULL;
-static ca_mutex g_bleReqRespCbMutex = NULL;
-static ca_mutex g_bleClientBDAddressMutex = NULL;
-static ca_mutex g_connectedDeviceListMutex = NULL;
+static jbyteArray g_sendBuffer = NULL;
+static jobject g_obj_bluetoothDevice = NULL;
+
+static CABLEDataReceivedCallback g_CABLEServerDataReceivedCallback = NULL;
+static oc_mutex g_bleReqRespCbMutex = NULL;
+static oc_mutex g_bleClientBDAddressMutex = NULL;
+static oc_mutex g_connectedDeviceListMutex = NULL;
+
+static oc_mutex g_threadSendMutex = NULL;
+static oc_mutex g_threadSendNotifyMutex = NULL;
+static oc_cond g_threadSendNotifyCond = NULL;
+static bool g_isSignalSetFlag = false;
+
+static oc_mutex g_deviceStateListMutex = NULL;
+
+static jint g_state_connected = INVALID_STATE;
+static jint g_state_disconnected = INVALID_STATE;
+
+static const char CLASSPATH_BT_ADVERTISE_CB[] = "android/bluetooth/le/AdvertiseCallback";
+static const char CLASSPATH_BT_GATTSERVER[] = "android/bluetooth/BluetoothGattServer";
+
+static bool g_setHighQoS = true;
void CALEServerJNISetContext()
{
}
bool isAttached = false;
- JNIEnv* env;
+ JNIEnv* env = NULL;
jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
if (JNI_OK != res)
{
return CA_STATUS_FAILED;
}
-jobject CALEServerSetResponseData(JNIEnv *env, jbyteArray responseData)
+/**
+ * get the current connection state of the gatt profile to the remote device.
+ * @param[in] env JNI interface pointer.
+ * @param[in] device bluetooth device object
+ * @return state of the profile connection.
+ */
+static jint CALEServerGetConnectionState(JNIEnv *env, jobject device)
{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerSetResponseData");
- VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
- VERIFY_NON_NULL_RET(responseData, TAG, "responseData is null", NULL);
+ OIC_LOG(DEBUG, TAG, "CALEServerGetConnectionState");
- if (!g_bluetoothGattServer)
+ VERIFY_NON_NULL_RET(env, TAG, "env", -1);
+ VERIFY_NON_NULL_RET(device, TAG, "device", -1);
+
+ jmethodID jni_mid_getConnectionState = CAGetJNIMethodID(env, "android/bluetooth"
+ "/BluetoothManager",
+ "getConnectionState",
+ "(Landroid/bluetooth/BluetoothDevice"
+ ";I)I");
+ if (!jni_mid_getConnectionState)
{
- OIC_LOG(ERROR, TAG, "Check BluetoothGattServer status");
- return NULL;
+ OIC_LOG(ERROR, TAG, "jni_mid_getConnectionState is null");
+ return -1;
}
- if (!CALEIsEnableBTAdapter(env))
+ if (!g_bluetoothManager)
{
- OIC_LOG(ERROR, TAG, "BT adapter is not enabled");
- return NULL;
+ OIC_LOG(ERROR, TAG, "g_bluetoothManager is null");
+ return -1;
}
- OIC_LOG(DEBUG, TAG, "CALEServerSetResponseData");
-
- jclass jni_cid_bluetoothGattServer = (*env)->FindClass(env,
- "android/bluetooth/BluetoothGattServer");
- if (!jni_cid_bluetoothGattServer)
+ jint jni_state = (jint)(*env)->CallIntMethod(env, g_bluetoothManager,
+ jni_mid_getConnectionState,
+ device, GATT_PROFILE);
+ if (CACheckJNIException(env))
{
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattServer is null");
- return NULL;
+ OIC_LOG(ERROR, TAG, "getConnectionState has failed");
+ return -1;
}
- jclass jni_cid_bluetoothGattService = (*env)->FindClass(env, "android/bluetooth/"
- "BluetoothGattService");
- if (!jni_cid_bluetoothGattService)
+ OIC_LOG_V(INFO, TAG, "connection state is %d", jni_state);
+ return jni_state;
+}
+
+jobject CALEServerSetResponseData(JNIEnv *env, jbyteArray responseData)
+{
+ OIC_LOG(DEBUG, TAG, "IN - CALEServerSetResponseData");
+ VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
+ VERIFY_NON_NULL_RET(responseData, TAG, "responseData is null", NULL);
+
+ if (!g_bluetoothGattServer)
{
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattService is null");
+ OIC_LOG(ERROR, TAG, "Check BluetoothGattServer status");
return NULL;
}
- jclass jni_cid_bluetoothGattCharacteristic = (*env)->FindClass(env, "android/bluetooth/"
- "BluetoothGattCharacteristic");
- if (!jni_cid_bluetoothGattService)
+ if (!CALEIsEnableBTAdapter(env))
{
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattCharacteristic is null");
+ OIC_LOG(ERROR, TAG, "BT adapter is not enabled");
return NULL;
}
- jmethodID jni_mid_getService = (*env)->GetMethodID(env, jni_cid_bluetoothGattServer,
- "getService",
- "(Ljava/util/UUID;)Landroid/bluetooth/"
- "BluetoothGattService;");
- if (!jni_cid_bluetoothGattService)
+ OIC_LOG(DEBUG, TAG, "CALEServerSetResponseData");
+ jmethodID jni_mid_getService = CAGetJNIMethodID(env, CLASSPATH_BT_GATTSERVER,
+ "getService",
+ "(Ljava/util/UUID;)Landroid/bluetooth/"
+ "BluetoothGattService;");
+ if (!jni_mid_getService)
{
OIC_LOG(ERROR, TAG, "jni_mid_getService is null");
return NULL;
if (!jni_obj_bluetoothGattService)
{
OIC_LOG(ERROR, TAG, "jni_obj_bluetoothGattService is null");
+ CACheckJNIException(env);
return NULL;
}
- jmethodID jni_mid_getCharacteristic = (*env)->GetMethodID(env, jni_cid_bluetoothGattService,
- "getCharacteristic",
- "(Ljava/util/UUID;)"
- "Landroid/bluetooth/"
- "BluetoothGattCharacteristic;");
+ jmethodID jni_mid_getCharacteristic = CAGetJNIMethodID(env, "android/bluetooth/"
+ "BluetoothGattService",
+ "getCharacteristic",
+ "(Ljava/util/UUID;)"
+ "Landroid/bluetooth/"
+ "BluetoothGattCharacteristic;");
if (!jni_mid_getCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_mid_getCharacteristic is null");
if (!jni_obj_bluetoothGattCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_obj_bluetoothGattCharacteristic is null");
+ CACheckJNIException(env);
return NULL;
}
- jmethodID jni_mid_setValue = (*env)->GetMethodID(env, jni_cid_bluetoothGattCharacteristic,
- "setValue", "([B)Z");
+ jmethodID jni_mid_setValue = CAGetJNIMethodID(env, "android/bluetooth/"
+ "BluetoothGattCharacteristic",
+ "setValue", "([B)Z");
if (!jni_mid_setValue)
{
OIC_LOG(ERROR, TAG, "jni_mid_setValue is null");
if (JNI_FALSE == jni_boolean_setValue)
{
OIC_LOG(ERROR, TAG, "Fail to set response data");
+ CACheckJNIException(env);
}
OIC_LOG(DEBUG, TAG, "OUT - CALEServerSetResponseData");
CAResult_t CALEServerSendResponseData(JNIEnv *env, jobject device, jobject responseData)
{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerSendResponseData");
+ OIC_LOG(DEBUG, TAG, "CALEServerSendResponseData");
VERIFY_NON_NULL(responseData, TAG, "responseData is null");
VERIFY_NON_NULL(device, TAG, "device is null");
VERIFY_NON_NULL(env, TAG, "env is null");
return CA_ADAPTER_NOT_ENABLED;
}
- jclass jni_cid_bluetoothGattServer = (*env)->FindClass(env,
- "android/bluetooth/BluetoothGattServer");
- if (!jni_cid_bluetoothGattServer)
+ if (!g_bluetoothGattServer)
+ {
+ OIC_LOG(ERROR, TAG, "g_bluetoothGattServer is not available");
+ return CA_STATUS_FAILED;
+ }
+
+ if (g_state_connected != CALEServerGetConnectionState(env, device))
{
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattServer is null");
+ OIC_LOG(ERROR, TAG, "it is not connected state");
return CA_STATUS_FAILED;
}
- jmethodID jni_mid_notifyCharacteristicChanged = (*env)->GetMethodID(
- env, jni_cid_bluetoothGattServer, "notifyCharacteristicChanged",
- "(Landroid/bluetooth/BluetoothDevice;"
- "Landroid/bluetooth/BluetoothGattCharacteristic;Z)Z");
+ jmethodID jni_mid_notifyCharacteristicChanged = CAGetJNIMethodID(env,
+ CLASSPATH_BT_GATTSERVER,
+ "notifyCharacteristicChanged",
+ "(Landroid/bluetooth/BluetoothDevice;"
+ "Landroid/bluetooth/"
+ "BluetoothGattCharacteristic;Z)Z");
if (!jni_mid_notifyCharacteristicChanged)
{
OIC_LOG(ERROR, TAG, "jni_mid_notifyCharacteristicChanged is null");
return CA_STATUS_FAILED;
}
+ OIC_LOG(DEBUG, TAG, "CALL API - notifyCharacteristicChanged");
+
jboolean jni_boolean_notifyCharacteristicChanged = (*env)->CallBooleanMethod(
env, g_bluetoothGattServer, jni_mid_notifyCharacteristicChanged, device, responseData,
JNI_FALSE);
if (JNI_FALSE == jni_boolean_notifyCharacteristicChanged)
{
OIC_LOG(ERROR, TAG, "Fail to notify characteristic");
+ CACheckJNIException(env);
return CA_SEND_FAILED;
}
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerSendResponseData");
+ OIC_LOG_V(DEBUG, TAG, "callback flag is %d", g_isSignalSetFlag);
+ oc_mutex_lock(g_threadSendNotifyMutex);
+ if (!g_isSignalSetFlag)
+ {
+ OIC_LOG(DEBUG, TAG, "wait for callback to notify notifyCharacteristic is success");
+ if (0 != oc_cond_wait_for(g_threadSendNotifyCond, g_threadSendNotifyMutex,
+ WAIT_TIME_WRITE_CHARACTERISTIC))
+ {
+ OIC_LOG(ERROR, TAG, "there is no response. notifyCharacteristic has failed");
+ oc_mutex_unlock(g_threadSendNotifyMutex);
+ return CA_STATUS_FAILED;
+ }
+ }
+ // reset flag set by writeCharacteristic Callback
+ g_isSignalSetFlag = false;
+ oc_mutex_unlock(g_threadSendNotifyMutex);
+ OIC_LOG(INFO, TAG, "notifyCharacteristic success");
return CA_STATUS_OK;
}
return CA_ADAPTER_NOT_ENABLED;
}
- jclass jni_cid_bluetoothGattServer = (*env)->FindClass(env,
- "android/bluetooth/BluetoothGattServer");
- if (!jni_cid_bluetoothGattServer)
+ if (!g_bluetoothGattServer)
{
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattServer is null");
+ OIC_LOG(ERROR, TAG, "g_bluetoothGattServer is not available");
return CA_STATUS_FAILED;
}
- jmethodID jni_mid_sendResponse = (*env)->GetMethodID(env, jni_cid_bluetoothGattServer,
- "sendResponse",
- "(Landroid/bluetooth/BluetoothDevice;"
- "III[B)Z");
+ jmethodID jni_mid_sendResponse = CAGetJNIMethodID(env, CLASSPATH_BT_GATTSERVER,
+ "sendResponse",
+ "(Landroid/bluetooth/BluetoothDevice;"
+ "III[B)Z");
if (!jni_mid_sendResponse)
{
OIC_LOG(ERROR, TAG, "jni_mid_sendResponse is null");
if (JNI_FALSE == jni_boolean_sendResponse)
{
OIC_LOG(ERROR, TAG, "Fail to send response for gatt characteristic write request");
+ CACheckJNIException(env);
return CA_SEND_FAILED;
}
return CA_STATUS_OK;
}
-CAResult_t CALEServerStartAdvertise(JNIEnv *env, jobject advertiseCallback)
+CAResult_t CALEServerStartAdvertise()
+{
+ if ((caglobals.bleFlags & CA_LE_ADV_DISABLE) || CA_DEFAULT_BT_FLAGS == caglobals.bleFlags)
+ {
+ OIC_LOG_V(INFO, TAG, "the advertisement of the bleFlags is disable[%d]",
+ caglobals.bleFlags);
+ return CA_STATUS_OK;
+ }
+
+ if (!g_jvm)
+ {
+ OIC_LOG(ERROR, TAG, "g_jvm is null");
+ return CA_STATUS_FAILED;
+ }
+
+ bool isAttached = false;
+ JNIEnv* env = NULL;
+ jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
+ if (JNI_OK != res)
+ {
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
+ res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
+
+ if (JNI_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "AttachCurrentThread has failed");
+ return CA_STATUS_FAILED;
+ }
+ isAttached = true;
+ }
+
+ // start advertise
+ CAResult_t ret = CALEServerStartAdvertiseImpl(env, g_leAdvertiseCallback);
+ if (CA_STATUS_OK != ret)
+ {
+ OIC_LOG(ERROR, TAG, "CALEServerStartAdvertiseImpl has failed");
+ }
+
+ if (isAttached)
+ {
+ (*g_jvm)->DetachCurrentThread(g_jvm);
+ }
+ return ret;
+}
+
+CAResult_t CALEServerStartAdvertiseImpl(JNIEnv *env, jobject advertiseCallback)
{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerStartAdvertise");
+ OIC_LOG(DEBUG, TAG, "IN - CALEServerStartAdvertiseImpl");
VERIFY_NON_NULL(env, TAG, "env is null");
VERIFY_NON_NULL(advertiseCallback, TAG, "advertiseCallback is null");
if (!jni_cid_AdvertiseSettings)
{
OIC_LOG(ERROR, TAG, "jni_cid_AdvertiseSettings is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_AdvertiseSettings = (*env)->GetMethodID(env, jni_cid_AdvertiseSettings,
if (!jni_mid_AdvertiseSettings)
{
OIC_LOG(ERROR, TAG, "jni_mid_AdvertiseSettings is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_AdvertiseSettings = (*env)->NewObject(env, jni_cid_AdvertiseSettings,
if (!jni_AdvertiseSettings)
{
OIC_LOG(ERROR, TAG, "jni_AdvertiseSettings is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_setAdvertiseMode = (*env)->GetMethodID(env, jni_cid_AdvertiseSettings,
if (!jni_mid_setAdvertiseMode)
{
OIC_LOG(ERROR, TAG, "jni_mid_setAdvertiseMode is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
// 0: Low power, 1: Balanced
if (!jni_obj_setAdvertiseMode)
{
OIC_LOG(ERROR, TAG, "jni_obj_setAdvertiseMode is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_setConnectable = (*env)->GetMethodID(env, jni_cid_AdvertiseSettings,
if (!jni_mid_setConnectable)
{
OIC_LOG(ERROR, TAG, "jni_mid_setConnectable is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_setConnectable = (*env)->CallObjectMethod(env, jni_AdvertiseSettings,
if (!jni_obj_setConnectable)
{
OIC_LOG(ERROR, TAG, "jni_obj_setConnectable is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_setTimeout = (*env)->GetMethodID(env, jni_cid_AdvertiseSettings, "setTimeout",
if (!jni_mid_setTimeout)
{
OIC_LOG(ERROR, TAG, "jni_mid_setTimeout is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
//A value of 0 will disable the time limit
if (!jni_obj_setTimeout)
{
OIC_LOG(ERROR, TAG, "jni_obj_setTimeout is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jclass jni_cid_AdvertiseDataBuilder = (*env)->FindClass(env,
if (!jni_cid_AdvertiseDataBuilder)
{
OIC_LOG(ERROR, TAG, "jni_cid_AdvertiseDataBuilder is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_AdvertiseDataBuilder = (*env)->GetMethodID(env, jni_cid_AdvertiseDataBuilder,
if (!jni_mid_AdvertiseDataBuilder)
{
OIC_LOG(ERROR, TAG, "jni_mid_AdvertiseDataBuilder is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_AdvertiseDataBuilder = (*env)->NewObject(env, jni_cid_AdvertiseDataBuilder,
if (!jni_AdvertiseDataBuilder)
{
OIC_LOG(ERROR, TAG, "jni_AdvertiseDataBuilder is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
+ }
+
+ jobject jni_AdvertiseDataBuilderForScanRsp = (*env)->NewObject(env,
+ jni_cid_AdvertiseDataBuilder,
+ jni_mid_AdvertiseDataBuilder);
+ if (!jni_AdvertiseDataBuilderForScanRsp)
+ {
+ OIC_LOG(ERROR, TAG, "jni_AdvertiseDataBuilderForScanRsp is null");
+ goto error_exit;
}
jobject jni_obj_serviceUUID = CALEGetUuidFromString(env, OIC_GATT_SERVICE_UUID);
if (!jni_mid_addServiceUuid)
{
OIC_LOG(ERROR, TAG, "jni_mid_addServiceUuid is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_addServiceUuid = (*env)->CallObjectMethod(env, jni_AdvertiseDataBuilder,
if (!jni_obj_addServiceUuid)
{
OIC_LOG(ERROR, TAG, "jni_obj_addServiceUuid is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
+ }
+
+ // Device name has to be included in advertise packet after Android API 23
+ OIC_LOG(DEBUG, TAG, "device name will be added into advertise packet");
+ jmethodID jni_mid_setIncludeDeviceName = (*env)->GetMethodID(env, jni_cid_AdvertiseDataBuilder,
+ "setIncludeDeviceName",
+ "(Z)Landroid/"
+ "bluetooth/le/"
+ "AdvertiseData$Builder;");
+ if (!jni_mid_setIncludeDeviceName)
+ {
+ OIC_LOG(ERROR, TAG, "jni_mid_setIncludeDeviceName is null");
+ goto error_exit;
+ }
+
+ jobject jni_obj_setIncludeDeviceName = (*env)->CallObjectMethod(env,
+ jni_AdvertiseDataBuilderForScanRsp,
+ jni_mid_setIncludeDeviceName,
+ JNI_TRUE);
+ if (!jni_obj_setIncludeDeviceName)
+ {
+ OIC_LOG(ERROR, TAG, "jni_obj_setIncludeDeviceName is null");
+ goto error_exit;
}
jclass jni_cid_BTAdapter = (*env)->FindClass(env, "android/bluetooth/BluetoothAdapter");
if (!jni_mid_getDefaultAdapter)
{
OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
if (!jni_obj_BTAdapter)
{
OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_getBluetoothLeAdvertiser = (*env)->GetMethodID(env, jni_cid_BTAdapter,
if (!jni_mid_getBluetoothLeAdvertiser)
{
OIC_LOG(ERROR, TAG, "jni_mid_getBluetoothLeAdvertiser is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_getBluetoothLeAdvertiser = (*env)->CallObjectMethod(
if (!jni_obj_getBluetoothLeAdvertiser)
{
OIC_LOG(ERROR, TAG, "jni_obj_getBluetoothLeAdvertiser is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_build_LeAdvertiseSettings = (*env)->GetMethodID(env,
if (!jni_mid_build_LeAdvertiseSettings)
{
OIC_LOG(ERROR, TAG, "jni_mid_build_LeAdvertiseSettings is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_build_LeAdvertiseSettings = (*env)->CallObjectMethod(
if (!jni_obj_build_LeAdvertiseSettings)
{
OIC_LOG(ERROR, TAG, "jni_obj_build_LeAdvertiseSettings is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_build_LeAdvertiseData = (*env)->GetMethodID(env, jni_cid_AdvertiseDataBuilder,
if (!jni_mid_build_LeAdvertiseData)
{
OIC_LOG(ERROR, TAG, "jni_mid_build_LeAdvertiseData is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_build_LeAdvertiseData = (*env)->CallObjectMethod(env, jni_AdvertiseDataBuilder,
if (!jni_obj_build_LeAdvertiseData)
{
OIC_LOG(ERROR, TAG, "jni_obj_build_LeAdvertiseData is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
- jclass jni_cid_leAdvertiser = (*env)->FindClass(env,
- "android/bluetooth/le/BluetoothLeAdvertiser");
- if (!jni_cid_leAdvertiser)
+ jobject jni_obj_build_LeAdvertiseDataForScanRsp = (*env)->CallObjectMethod(env,
+ jni_AdvertiseDataBuilderForScanRsp,
+ jni_mid_build_LeAdvertiseData);
+ if (!jni_obj_build_LeAdvertiseDataForScanRsp)
{
- OIC_LOG(ERROR, TAG, "jni_cid_leAdvertiser is null");
- return CA_STATUS_FAILED;
+ OIC_LOG(ERROR, TAG, "jni_obj_build_LeAdvertiseDataForScanRsp is null");
+ goto error_exit;
}
- jmethodID jni_mid_startAdvertising = (*env)->GetMethodID(env, jni_cid_leAdvertiser,
- "startAdvertising",
- "(Landroid/bluetooth/le/"
- "AdvertiseSettings;Landroid/bluetooth/"
- "le/AdvertiseData;Landroid/bluetooth/"
- "le/AdvertiseCallback;)V");
+ jmethodID jni_mid_startAdvertising = CAGetJNIMethodID(env, "android/bluetooth/le/"
+ "BluetoothLeAdvertiser",
+ "startAdvertising",
+ "(Landroid/bluetooth/le/"
+ "AdvertiseSettings;Landroid/bluetooth/"
+ "le/AdvertiseData;Landroid/bluetooth/"
+ "le/AdvertiseData;Landroid/bluetooth/"
+ "le/AdvertiseCallback;)V");
if (!jni_mid_startAdvertising)
{
- OIC_LOG(ERROR, TAG, "jni_mid_startAdvertising is null");
- return CA_STATUS_FAILED;
+ OIC_LOG(ERROR, TAG, "jni_mid_startAdvertising is null");
+ return CA_STATUS_FAILED;
}
(*env)->CallVoidMethod(env, jni_obj_getBluetoothLeAdvertiser, jni_mid_startAdvertising,
jni_obj_build_LeAdvertiseSettings, jni_obj_build_LeAdvertiseData,
- advertiseCallback);
-
- if ((*env)->ExceptionCheck(env))
+ jni_obj_build_LeAdvertiseDataForScanRsp, advertiseCallback);
+ if (CACheckJNIException(env))
{
OIC_LOG(ERROR, TAG, "StartAdvertising has failed");
- (*env)->ExceptionDescribe(env);
- (*env)->ExceptionClear(env);
return CA_STATUS_FAILED;
}
OIC_LOG(DEBUG, TAG, "Advertising started!!");
-
OIC_LOG(DEBUG, TAG, "OUT - CALEServerStartAdvertise");
return CA_STATUS_OK;
+
+error_exit:
+ CACheckJNIException(env);
+ return CA_STATUS_FAILED;
+}
+
+CAResult_t CALEServerStopAdvertise()
+{
+ if (!g_jvm)
+ {
+ OIC_LOG(ERROR, TAG, "g_jvm is null");
+ return CA_STATUS_FAILED;
+ }
+
+ bool isAttached = false;
+ JNIEnv* env = NULL;
+ jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
+ if (JNI_OK != res)
+ {
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
+ res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
+
+ if (JNI_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "AttachCurrentThread has failed");
+ return CA_STATUS_FAILED;
+ }
+ isAttached = true;
+ }
+
+ CAResult_t ret = CALEServerStopAdvertiseImpl(env, g_leAdvertiseCallback);
+ if (CA_STATUS_OK != ret)
+ {
+ OIC_LOG(ERROR, TAG, "CALEServerStopAdvertise has failed");
+ }
+
+ if (isAttached)
+ {
+ (*g_jvm)->DetachCurrentThread(g_jvm);
+ }
+
+ return ret;
}
-CAResult_t CALEServerStopAdvertise(JNIEnv *env, jobject advertiseCallback)
+CAResult_t CALEServerStopAdvertiseImpl(JNIEnv *env, jobject advertiseCallback)
{
- OIC_LOG(DEBUG, TAG, "IN - LEServerStopAdvertise");
+ OIC_LOG(DEBUG, TAG, "CALEServerStopAdvertiseImpl");
VERIFY_NON_NULL(env, TAG, "env is null");
VERIFY_NON_NULL(advertiseCallback, TAG, "advertiseCallback is null");
if (!jni_cid_BTAdapter)
{
OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
- return CA_STATUS_FAILED;
- }
-
- jclass jni_cid_leAdvertiser = (*env)->FindClass(env,
- "android/bluetooth/le/BluetoothLeAdvertiser");
- if (!jni_cid_leAdvertiser)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_leAdvertiser is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
"getDefaultAdapter",
"()Landroid/bluetooth/"
"BluetoothAdapter;");
- if (!jni_cid_leAdvertiser)
+ if (!jni_mid_getDefaultAdapter)
{
- OIC_LOG(ERROR, TAG, "jni_cid_leAdvertiser is null");
- return CA_STATUS_FAILED;
+ OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
+ goto error_exit;
}
jmethodID jni_mid_getBTLeAdvertiser = (*env)->GetMethodID(env, jni_cid_BTAdapter,
if (!jni_mid_getBTLeAdvertiser)
{
OIC_LOG(ERROR, TAG, "jni_mid_getBTLeAdvertiser is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
- jmethodID jni_mid_stopAdvertising = (*env)->GetMethodID(env, jni_cid_leAdvertiser,
- "stopAdvertising",
- "(Landroid/bluetooth/le/"
- "AdvertiseCallback;)V");
+ jmethodID jni_mid_stopAdvertising = CAGetJNIMethodID(env, "android/bluetooth/le/"
+ "BluetoothLeAdvertiser",
+ "stopAdvertising",
+ "(Landroid/bluetooth/le/"
+ "AdvertiseCallback;)V");
if (!jni_mid_stopAdvertising)
{
OIC_LOG(ERROR, TAG, "jni_mid_stopAdvertising is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
if (!jni_obj_BTAdapter)
{
OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_getBluetoothLeAdvertiser = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
if (!jni_obj_getBluetoothLeAdvertiser)
{
OIC_LOG(ERROR, TAG, "jni_obj_getBluetoothLeAdvertiser is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
(*env)->CallVoidMethod(env, jni_obj_getBluetoothLeAdvertiser, jni_mid_stopAdvertising,
advertiseCallback);
- if ((*env)->ExceptionCheck(env))
+ if (CACheckJNIException(env))
{
OIC_LOG(ERROR, TAG, "getBluetoothLeAdvertiser has failed");
- (*env)->ExceptionDescribe(env);
- (*env)->ExceptionClear(env);
return CA_STATUS_FAILED;
}
OIC_LOG(DEBUG, TAG, "Advertising stopped!!");
-
- OIC_LOG(DEBUG, TAG, "OUT - LEServerStopAdvertise");
return CA_STATUS_OK;
+
+error_exit:
+ CACheckJNIException(env);
+ return CA_STATUS_FAILED;
}
CAResult_t CALEServerStartGattServer(JNIEnv *env, jobject gattServerCallback)
if (!CALEIsEnableBTAdapter(env))
{
OIC_LOG(ERROR, TAG, "BT adapter is not enabled");
- return NULL;
+ goto error_exit;
}
jclass jni_cid_context = (*env)->FindClass(env, "android/content/Context");
if (!jni_cid_context)
{
OIC_LOG(ERROR, TAG, "jni_cid_context is null");
- return NULL;
- }
-
- jclass jni_cid_bluetoothManager = (*env)->FindClass(env, "android/bluetooth/BluetoothManager");
- if (!jni_cid_bluetoothManager)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothManager is null");
- return NULL;
+ goto error_exit;
}
jfieldID jni_fid_bluetoothService = (*env)->GetStaticFieldID(env, jni_cid_context,
if (!jni_fid_bluetoothService)
{
OIC_LOG(ERROR, TAG, "jni_fid_bluetoothService is null");
- return NULL;
+ goto error_exit;
}
jmethodID jni_mid_getSystemService = (*env)->GetMethodID(env, jni_cid_context,
if (!jni_mid_getSystemService)
{
OIC_LOG(ERROR, TAG, "jni_mid_getSystemService is null");
- return NULL;
+ goto error_exit;
}
- jmethodID jni_mid_openGattServer = (*env)->GetMethodID(env, jni_cid_bluetoothManager,
- "openGattServer",
- "(Landroid/content/Context;"
- "Landroid/bluetooth/"
- "BluetoothGattServerCallback;)"
- "Landroid/bluetooth/"
- "BluetoothGattServer;");
+ jmethodID jni_mid_openGattServer = CAGetJNIMethodID(env, "android/bluetooth/"
+ "BluetoothManager",
+ "openGattServer",
+ "(Landroid/content/Context;"
+ "Landroid/bluetooth/"
+ "BluetoothGattServerCallback;)"
+ "Landroid/bluetooth/"
+ "BluetoothGattServer;");
if (!jni_mid_openGattServer)
{
OIC_LOG(ERROR, TAG, "jni_mid_openGattServer is null");
if (!jni_obj_bluetoothService)
{
OIC_LOG(ERROR, TAG, "jni_obj_bluetoothService is null");
- return NULL;
+ goto error_exit;
}
jobject jni_obj_bluetoothManager = (*env)->CallObjectMethod(env, g_context,
if (!jni_obj_bluetoothManager)
{
OIC_LOG(ERROR, TAG, "jni_obj_bluetoothManager is null");
- return NULL;
+ goto error_exit;
+ }
+
+ if (g_bluetoothManager)
+ {
+ (*env)->DeleteGlobalRef(env, g_bluetoothManager);
}
+ g_bluetoothManager = (*env)->NewGlobalRef(env, jni_obj_bluetoothManager);
jobject jni_obj_bluetoothGattServer = (*env)->CallObjectMethod(env, jni_obj_bluetoothManager,
jni_mid_openGattServer,
if (!jni_obj_bluetoothGattServer)
{
OIC_LOG(ERROR, TAG, "jni_obj_bluetoothGattServer is null");
- return NULL;
+ goto error_exit;
}
OIC_LOG(DEBUG, TAG, "OUT - CALEServerOpenGattServer");
return jni_obj_bluetoothGattServer;
+
+error_exit:
+ CACheckJNIException(env);
+ return NULL;
}
jobject CALEServerCreateGattService(JNIEnv *env)
if (!jni_cid_bluetoothGattService)
{
OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattService is null");
- return NULL;
+ goto error_exit;
}
jclass jni_cid_bluetoothGattCharacteristic = (*env)->FindClass(env, "android/bluetooth/"
if (!jni_cid_bluetoothGattCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattCharacteristic is null");
- return NULL;
+ goto error_exit;
}
jfieldID jni_fid_serviceType = (*env)->GetStaticFieldID(env, jni_cid_bluetoothGattService,
if (!jni_fid_serviceType)
{
OIC_LOG(ERROR, TAG, "jni_fid_serviceType is null");
- return NULL;
+ goto error_exit;
}
- jfieldID jni_fid_readProperties = (*env)->GetStaticFieldID(env,
- jni_cid_bluetoothGattCharacteristic,
- "PROPERTY_READ", "I");
- if (!jni_fid_readProperties)
+ jfieldID jni_fid_readProperties = NULL;
+ jfieldID jni_fid_writeProperties = NULL;
+ if (g_setHighQoS)
{
- OIC_LOG(ERROR, TAG, "jni_fid_readProperties is null");
- return NULL;
- }
-
-#ifdef USE_PROPERTY_WRITE_RESPONSE
- jfieldID jni_fid_writeProperties = (*env)->GetStaticFieldID(env,
- jni_cid_bluetoothGattCharacteristic,
- "PROPERTY_WRITE", "I");
-#else
- jfieldID jni_fid_writeProperties = (*env)->GetStaticFieldID(env,
- jni_cid_bluetoothGattCharacteristic,
- "PROPERTY_WRITE_NO_RESPONSE", "I");
-#endif
+ jni_fid_readProperties = (*env)->GetStaticFieldID(env,
+ jni_cid_bluetoothGattCharacteristic,
+ "PROPERTY_INDICATE", "I");
+ if (!jni_fid_readProperties)
+ {
+ OIC_LOG(ERROR, TAG, "jni_fid_readProperties is null");
+ goto error_exit;
+ }
- if (!jni_fid_writeProperties)
+ jni_fid_writeProperties = (*env)->GetStaticFieldID(env,
+ jni_cid_bluetoothGattCharacteristic,
+ "PROPERTY_WRITE", "I");
+ if (!jni_fid_writeProperties)
+ {
+ OIC_LOG(ERROR, TAG, "jni_fid_writeProperties is null");
+ goto error_exit;
+ }
+ }
+ else
{
- OIC_LOG(ERROR, TAG, "jni_fid_writeProperties is null");
- return NULL;
+ jni_fid_readProperties = (*env)->GetStaticFieldID(env,
+ jni_cid_bluetoothGattCharacteristic,
+ "PROPERTY_NOTIFY", "I");
+ if (!jni_fid_readProperties)
+ {
+ OIC_LOG(ERROR, TAG, "jni_fid_readProperties is null");
+ goto error_exit;
+ }
+
+ jni_fid_writeProperties = (*env)->GetStaticFieldID(env,
+ jni_cid_bluetoothGattCharacteristic,
+ "PROPERTY_WRITE_NO_RESPONSE", "I");
+ if (!jni_fid_writeProperties)
+ {
+ OIC_LOG(ERROR, TAG, "jni_fid_writeProperties is null");
+ goto error_exit;
+ }
}
jfieldID jni_fid_readPermissions = (*env)->GetStaticFieldID(env,
if (!jni_fid_readPermissions)
{
OIC_LOG(ERROR, TAG, "jni_fid_readPermissions is null");
- return NULL;
+ goto error_exit;
}
jfieldID jni_fid_writePermissions = (*env)->GetStaticFieldID(
if (!jni_fid_writePermissions)
{
OIC_LOG(ERROR, TAG, "jni_fid_writePermissions is null");
- return NULL;
+ goto error_exit;
}
jmethodID jni_mid_bluetoothGattService = (*env)->GetMethodID(env, jni_cid_bluetoothGattService,
if (!jni_mid_bluetoothGattService)
{
OIC_LOG(ERROR, TAG, "jni_mid_bluetoothGattService is null");
- return NULL;
+ goto error_exit;
}
jmethodID jni_mid_addCharacteristic = (*env)->GetMethodID(env, jni_cid_bluetoothGattService,
if (!jni_mid_addCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_mid_addCharacteristic is null");
- return NULL;
+ goto error_exit;
}
jmethodID jni_mid_bluetoothGattCharacteristic = (*env)->GetMethodID(
if (!jni_mid_bluetoothGattCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_mid_bluetoothGattCharacteristic is null");
- return NULL;
+ goto error_exit;
}
jobject jni_obj_serviceUUID = CALEGetUuidFromString(env, OIC_GATT_SERVICE_UUID);
if (!jni_bluetoothGattService)
{
OIC_LOG(ERROR, TAG, "jni_bluetoothGattService is null");
- return NULL;
+ goto error_exit;
}
jobject jni_obj_readUuid = CALEGetUuidFromString(env, OIC_GATT_CHARACTERISTIC_RESPONSE_UUID);
jint jni_int_readProperties = (*env)->GetStaticIntField(env,
jni_cid_bluetoothGattCharacteristic,
jni_fid_readProperties);
+ CACheckJNIException(env);
jint jni_int_readPermissions = (*env)->GetStaticIntField(env,
jni_cid_bluetoothGattCharacteristic,
jni_fid_readPermissions);
+ CACheckJNIException(env);
+
+ jint jni_int_writePermissions = (*env)->GetStaticIntField(env,
+ jni_cid_bluetoothGattCharacteristic,
+ jni_fid_writePermissions);
+ CACheckJNIException(env);
jobject jni_readCharacteristic = (*env)->NewObject(env, jni_cid_bluetoothGattCharacteristic,
jni_mid_bluetoothGattCharacteristic,
jni_obj_readUuid, jni_int_readProperties,
- jni_int_readPermissions);
+ jni_int_readPermissions|
+ jni_int_writePermissions);
if (!jni_readCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_readCharacteristic is null");
- return NULL;
- }
-
- CAResult_t res = CALEServerAddDescriptor(env, jni_readCharacteristic);
- if (CA_STATUS_OK != res)
- {
- OIC_LOG(ERROR, TAG, "CALEServerAddDescriptor has failed");
- return NULL;
+ goto error_exit;
}
jboolean jni_boolean_addReadCharacteristic = (*env)->CallBooleanMethod(
if (!jni_boolean_addReadCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_boolean_addReadCharacteristic is null");
- return NULL;
+ goto error_exit;
}
jobject jni_obj_writeUuid = CALEGetUuidFromString(env, OIC_GATT_CHARACTERISTIC_REQUEST_UUID);
jint jni_int_writeProperties = (*env)->GetStaticIntField(env,
jni_cid_bluetoothGattCharacteristic,
jni_fid_writeProperties);
-
- jint jni_int_writePermissions = (*env)->GetStaticIntField(env,
- jni_cid_bluetoothGattCharacteristic,
- jni_fid_writePermissions);
+ CACheckJNIException(env);
jobject jni_writeCharacteristic = (*env)->NewObject(env, jni_cid_bluetoothGattCharacteristic,
jni_mid_bluetoothGattCharacteristic,
if (!jni_writeCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_writeCharacteristic is null");
- return NULL;
+ goto error_exit;
}
jboolean jni_boolean_addWriteCharacteristic = (*env)->CallBooleanMethod(
if (JNI_FALSE == jni_boolean_addWriteCharacteristic)
{
OIC_LOG(ERROR, TAG, "Fail to add jni_boolean_addReadCharacteristic");
- return NULL;
+ goto error_exit;
}
OIC_LOG(DEBUG, TAG, "OUT - CALEServerCreateGattService");
return jni_bluetoothGattService;
+
+error_exit:
+ CACheckJNIException(env);
+ return NULL;
}
CAResult_t CALEServerAddDescriptor(JNIEnv *env, jobject characteristic)
{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerAddDescriptor");
+ OIC_LOG(DEBUG, TAG, "CALEServerAddDescriptor");
VERIFY_NON_NULL(env, TAG, "env is null");
VERIFY_NON_NULL(characteristic, TAG, "characteristic is null");
if (!jni_cid_bluetoothGattDescriptor)
{
OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattDescriptor is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_bluetoothGattDescriptor = (*env)->GetMethodID(env,
if (!jni_mid_bluetoothGattDescriptor)
{
OIC_LOG(ERROR, TAG, "jni_mid_bluetoothGattDescriptor is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jfieldID jni_fid_readPermissions = (*env)->GetStaticFieldID(env,
if (!jni_fid_readPermissions)
{
OIC_LOG(ERROR, TAG, "jni_fid_readPermissions is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jobject jni_obj_readUuid = CALEGetUuidFromString(env, OIC_GATT_CHARACTERISTIC_CONFIG_UUID);
jint jni_int_readPermissions = (*env)->GetStaticIntField(env, jni_cid_bluetoothGattDescriptor,
jni_fid_readPermissions);
+ CACheckJNIException(env);
OIC_LOG(DEBUG, TAG, "initialize new Descriptor");
if (!jni_readDescriptor)
{
OIC_LOG(ERROR, TAG, "jni_readDescriptor is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jclass jni_cid_GattCharacteristic = (*env)->FindClass(env, "android/bluetooth/"
if (!jni_cid_GattCharacteristic)
{
OIC_LOG(ERROR, TAG, "jni_cid_GattCharacteristic is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jmethodID jni_mid_addDescriptor = (*env)->GetMethodID(env, jni_cid_GattCharacteristic,
if (!jni_mid_addDescriptor)
{
OIC_LOG(ERROR, TAG, "jni_mid_addDescriptor is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jboolean jni_boolean_addDescriptor = (*env)->CallBooleanMethod(env, characteristic,
if (JNI_FALSE == jni_boolean_addDescriptor)
{
OIC_LOG(ERROR, TAG, "addDescriptor has failed");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
else
{
OIC_LOG(DEBUG, TAG, "addDescriptor success");
}
-
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerAddDescriptor");
return CA_STATUS_OK;
+
+error_exit:
+ CACheckJNIException(env);
+ return CA_STATUS_FAILED;
}
CAResult_t CALEServerAddGattService(JNIEnv *env, jobject bluetoothGattServer,
return CA_ADAPTER_NOT_ENABLED;
}
- jclass jni_cid_bluetoothGattServer = (*env)->FindClass(env,
- "android/bluetooth/BluetoothGattServer");
- if (!jni_cid_bluetoothGattServer)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattServer is null");
- return CA_STATUS_FAILED;
- }
-
- jmethodID jni_mid_addService = (*env)->GetMethodID(env, jni_cid_bluetoothGattServer,
- "addService",
- "(Landroid/bluetooth/BluetoothGattService;)"
- "Z");
- if (!jni_mid_addService)
- {
- OIC_LOG(ERROR, TAG, "jni_mid_addService is null");
- return CA_STATUS_FAILED;
- }
+ jmethodID jni_mid_addService = CAGetJNIMethodID(env, CLASSPATH_BT_GATTSERVER,
+ "addService",
+ "(Landroid/bluetooth/BluetoothGattService;)"
+ "Z");
+ if (!jni_mid_addService)
+ {
+ OIC_LOG(ERROR, TAG, "jni_mid_addService is null");
+ return CA_STATUS_FAILED;
+ }
jboolean jni_boolean_addService = (*env)->CallBooleanMethod(env, bluetoothGattServer,
jni_mid_addService,
if (JNI_FALSE == jni_boolean_addService)
{
OIC_LOG(ERROR, TAG, "Fail to add GATT service");
+ CACheckJNIException(env);
return CA_STATUS_FAILED;
}
return CA_ADAPTER_NOT_ENABLED;
}
- jclass jni_cid_bluetoothGattServer = (*env)->FindClass(env,
- "android/bluetooth/BluetoothGattServer");
- if (!jni_cid_bluetoothGattServer)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattServer is null");
- return CA_STATUS_FAILED;
- }
-
- jmethodID jni_mid_connect = (*env)->GetMethodID(env, jni_cid_bluetoothGattServer, "connect",
- "(Landroid/bluetooth/BluetoothDevice;Z)Z");
+ jmethodID jni_mid_connect = CAGetJNIMethodID(env, CLASSPATH_BT_GATTSERVER,
+ "connect",
+ "(Landroid/bluetooth/BluetoothDevice;Z)Z");
if (!jni_mid_connect)
{
OIC_LOG(ERROR, TAG, "jni_mid_connect is null");
if (JNI_FALSE == jni_boolean_connect)
{
OIC_LOG(ERROR, TAG, "Fail to connect");
+ CACheckJNIException(env);
return CA_STATUS_FAILED;
}
OIC_LOG(DEBUG, TAG, "IN - CALEServerDisconnectAllDevices");
VERIFY_NON_NULL(env, TAG, "env is null");
- ca_mutex_lock(g_connectedDeviceListMutex);
+ oc_mutex_lock(g_connectedDeviceListMutex);
if (!g_connectedDeviceList)
{
OIC_LOG(ERROR, TAG, "g_connectedDeviceList is null");
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_FAILED;
}
}
}
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
OIC_LOG(DEBUG, TAG, "OUT - CALEServerDisconnectAllDevices");
return CA_STATUS_OK;
}
return CA_ADAPTER_NOT_ENABLED;
}
- jclass jni_cid_bluetoothGattServer = (*env)->FindClass(env,
- "android/bluetooth/BluetoothGattServer");
- if (!jni_cid_bluetoothGattServer)
- {
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothGattServer is null");
- return CA_STATUS_FAILED;
- }
-
- jmethodID jni_mid_cancelConnection = (*env)->GetMethodID(env, jni_cid_bluetoothGattServer,
- "cancelConnection",
- "(Landroid/bluetooth/BluetoothDevice;)"
- "V");
+ jmethodID jni_mid_cancelConnection = CAGetJNIMethodID(env, CLASSPATH_BT_GATTSERVER,
+ "cancelConnection",
+ "(Landroid/bluetooth/BluetoothDevice;)"
+ "V");
if (!jni_mid_cancelConnection)
{
OIC_LOG(ERROR, TAG, "jni_mid_cancelConnection is null");
(*env)->CallVoidMethod(env, g_bluetoothGattServer, jni_mid_cancelConnection, bluetoothDevice);
- if ((*env)->ExceptionCheck(env))
+ if (CACheckJNIException(env))
{
OIC_LOG(ERROR, TAG, "cancelConnection has failed");
- (*env)->ExceptionDescribe(env);
- (*env)->ExceptionClear(env);
return CA_STATUS_FAILED;
}
return CA_STATUS_OK;
}
+CAResult_t CALEServerGattClose(JNIEnv *env, jobject bluetoothGattServer)
+{
+ // GATT CLOSE
+ OIC_LOG(DEBUG, TAG, "GattServer Close");
+ VERIFY_NON_NULL(bluetoothGattServer, TAG, "bluetoothGattServer is null");
+ VERIFY_NON_NULL(env, TAG, "env is null");
+
+ // get BluetoothGatt class
+ OIC_LOG(DEBUG, TAG, "get BluetoothGatt class");
+ jmethodID jni_mid_closeGatt = CAGetJNIMethodID(env, CLASSPATH_BT_GATTSERVER,
+ "close", "()V");
+ if (!jni_mid_closeGatt)
+ {
+ OIC_LOG(ERROR, TAG, "jni_mid_closeGatt is null");
+ return CA_STATUS_OK;
+ }
+
+ // call disconnect gatt method
+ OIC_LOG(DEBUG, TAG, "request to close GATT");
+ (*env)->CallVoidMethod(env, bluetoothGattServer, jni_mid_closeGatt);
+
+ if (CACheckJNIException(env))
+ {
+ OIC_LOG(ERROR, TAG, "closeGATT has failed");
+ return CA_STATUS_FAILED;
+ }
+
+ return CA_STATUS_OK;
+}
+
CAResult_t CALEServerSend(JNIEnv *env, jobject bluetoothDevice, jbyteArray responseData)
{
OIC_LOG(DEBUG, TAG, "IN - CALEServerSend");
return result;
}
-CAResult_t CALEServerInitialize(ca_thread_pool_t handle)
+CAResult_t CALEServerInitialize()
{
OIC_LOG(DEBUG, TAG, "IN - CALEServerInitialize");
}
bool isAttached = false;
- JNIEnv* env;
+ JNIEnv* env = NULL;
jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
if (JNI_OK != res)
{
return ret;
}
- g_threadPoolHandle = handle;
+ g_threadSendNotifyCond = oc_cond_new();
ret = CALEServerInitMutexVaraibles();
if (CA_STATUS_OK != ret)
}
bool isAttached = false;
- JNIEnv* env;
+ JNIEnv* env = NULL;
jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
if (JNI_OK != res)
{
- OIC_LOG(ERROR, TAG, "Could not get JNIEnv pointer");
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
if (JNI_OK != res)
isAttached = true;
}
- CAResult_t ret = CALEServerStopMulticastServer(0);
- if (CA_STATUS_OK != ret)
+ if (g_sendBuffer)
{
- OIC_LOG(ERROR, TAG, "CALEServerStopMulticastServer has failed");
+ (*env)->DeleteGlobalRef(env, g_sendBuffer);
+ g_sendBuffer = NULL;
}
- ret = CALEServerDisconnectAllDevices(env);
- if (CA_STATUS_OK != ret)
+ if (g_bluetoothManager)
{
- OIC_LOG(ERROR, TAG, "CALEServerDisconnectAllDevices has failed");
+ (*env)->DeleteGlobalRef(env, g_bluetoothManager);
+ g_bluetoothManager = NULL;
}
- ret = CALEServerRemoveAllDevices(env);
- if (CA_STATUS_OK != ret)
- {
- OIC_LOG(ERROR, TAG, "CALEServerRemoveAllDevices has failed");
- }
-
- if (g_leAdvertiseCallback)
- {
- (*env)->DeleteGlobalRef(env, g_leAdvertiseCallback);
- }
-
- if (g_bluetoothGattServer)
- {
- (*env)->DeleteGlobalRef(env, g_bluetoothGattServer);
- }
-
- if (g_bluetoothGattServerCallback)
- {
- (*env)->DeleteGlobalRef(env, g_bluetoothGattServerCallback);
- }
+ oc_cond_free(g_threadSendNotifyCond);
+ g_threadSendNotifyCond = NULL;
CALEServerTerminateMutexVaraibles();
CALEServerTerminateConditionVaraibles();
- g_isStartServer = false;
g_isInitializedServer = false;
if (isAttached)
OIC_LOG(DEBUG, TAG, "OUT - CALEServerTerminate");
}
-CAResult_t CALEServerSendUnicastMessage(const char* address, const char* data, uint32_t dataLen)
+CAResult_t CALEServerSendUnicastMessage(const char* address, const uint8_t* data, uint32_t dataLen)
{
- OIC_LOG_V(DEBUG, TAG, "IN - CALEServerSendUnicastMessage(%s, %s)", address, data);
+ OIC_LOG_V(DEBUG, TAG, "CALEServerSendUnicastMessage(%s, %p)", address, data);
VERIFY_NON_NULL(address, TAG, "address is null");
VERIFY_NON_NULL(data, TAG, "data is null");
}
bool isAttached = false;
- JNIEnv* env;
+ JNIEnv* env = NULL;
jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
if (JNI_OK != res)
{
- OIC_LOG(ERROR, TAG, "Could not get JNIEnv pointer");
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
if (JNI_OK != res)
(*g_jvm)->DetachCurrentThread(g_jvm);
}
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerSendUnicastMessage");
return ret;
}
-CAResult_t CALEServerSendMulticastMessage(const char* data, uint32_t dataLen)
+CAResult_t CALEServerSendMulticastMessage(const uint8_t* data, uint32_t dataLen)
{
- OIC_LOG_V(DEBUG, TAG, "IN - CALEServerSendMulticastMessage(%s)", data);
+ OIC_LOG_V(DEBUG, TAG, "CALEServerSendMulticastMessage(%p)", data);
VERIFY_NON_NULL(data, TAG, "data is null");
if (!g_jvm)
}
bool isAttached = false;
- JNIEnv* env;
+ JNIEnv* env = NULL;
jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
if (JNI_OK != res)
{
- OIC_LOG(ERROR, TAG, "Could not get JNIEnv pointer");
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
if (JNI_OK != res)
(*g_jvm)->DetachCurrentThread(g_jvm);
}
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerSendMulticastMessage");
return ret;
}
}
bool isAttached = false;
- JNIEnv* env;
+ JNIEnv* env = NULL;
jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
if (JNI_OK != res)
{
- OIC_LOG(ERROR, TAG, "Could not get JNIEnv pointer");
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
if (JNI_OK != res)
}
// start advertise
- ret = CALEServerStartAdvertise(env, g_leAdvertiseCallback);
+ ret = CALEServerStartAdvertise();
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, TAG, "CALEServerStartAdvertise has failed");
}
+ // get Constants Value from Android Platform
+ g_state_connected = CALEGetConstantsValue(env, CLASSPATH_BT_PROFILE, "STATE_CONNECTED");
+ g_state_disconnected = CALEGetConstantsValue(env, CLASSPATH_BT_PROFILE, "STATE_DISCONNECTED");
+
if (isAttached)
{
(*g_jvm)->DetachCurrentThread(g_jvm);
return CA_STATUS_FAILED;
}
- if (!g_jvm)
- {
- OIC_LOG(ERROR, TAG, "g_jvm is null");
- return CA_STATUS_FAILED;
- }
-
- bool isAttached = false;
- JNIEnv* env;
- jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
- if (JNI_OK != res)
- {
- OIC_LOG(ERROR, TAG, "Could not get JNIEnv pointer");
- res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
-
- if (JNI_OK != res)
- {
- OIC_LOG(ERROR, TAG, "AttachCurrentThread has failed");
- return CA_STATUS_FAILED;
- }
- isAttached = true;
- }
-
- CAResult_t ret = CALEServerStopAdvertise(env, g_leAdvertiseCallback);
+ CAResult_t ret = CALEServerStopAdvertise();
if (CA_STATUS_OK != ret)
{
OIC_LOG(ERROR, TAG, "CALEServerStopAdvertise has failed");
g_isStartServer = false;
- if (isAttached)
- {
- (*g_jvm)->DetachCurrentThread(g_jvm);
- }
-
OIC_LOG(DEBUG, TAG, "OUT - CALEServerStopMulticastServer");
return ret;
}
g_packetReceiveCallback = callback;
}
-CAResult_t CALEServerSendUnicastMessageImpl(JNIEnv *env, const char* address, const char* data,
+CAResult_t CALEServerSendUnicastMessageImpl(JNIEnv *env, const char* address, const uint8_t* data,
uint32_t dataLen)
{
- OIC_LOG_V(DEBUG, TAG, "IN - CALEServerSendUnicastMessageImpl, address: %s, data: %s",
+ OIC_LOG_V(DEBUG, TAG, "CALEServerSendUnicastMessageImpl, address: %s, data: %p",
address, data);
VERIFY_NON_NULL(env, TAG, "env is null");
VERIFY_NON_NULL(address, TAG, "address is null");
return CA_STATUS_FAILED;
}
- jobject jni_obj_bluetoothDevice = NULL;
+ oc_mutex_lock(g_threadSendMutex);
+
uint32_t length = u_arraylist_length(g_connectedDeviceList);
for (uint32_t index = 0; index < length; index++)
{
if (!jarrayObj)
{
OIC_LOG(ERROR, TAG, "jarrayObj is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
jstring jni_setAddress = CALEGetAddressFromBTDevice(env, jarrayObj);
if (!jni_setAddress)
{
OIC_LOG(ERROR, TAG, "jni_setAddress is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
const char* setAddress = (*env)->GetStringUTFChars(env, jni_setAddress, NULL);
if (!setAddress)
{
OIC_LOG(ERROR, TAG, "setAddress is null");
- return CA_STATUS_FAILED;
+ goto error_exit;
}
OIC_LOG_V(DEBUG, TAG, "setAddress : %s", setAddress);
OIC_LOG_V(DEBUG, TAG, "address : %s", address);
- if (!strcmp(setAddress, address))
+ if (!strcasecmp(setAddress, address))
{
OIC_LOG(DEBUG, TAG, "found the device");
- jni_obj_bluetoothDevice = jarrayObj;
+
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+
+ if (jarrayObj)
+ {
+ g_obj_bluetoothDevice = (*env)->NewGlobalRef(env, jarrayObj);
+ CACheckJNIException(env);
+ }
(*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
break;
}
(*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
}
- if (jni_obj_bluetoothDevice)
+ if (g_obj_bluetoothDevice)
{
- jbyteArray jni_bytearr_data = (*env)->NewByteArray(env, dataLen);
- (*env)->SetByteArrayRegion(env, jni_bytearr_data, 0, dataLen, (jbyte*) data);
+ jbyteArray jni_arr = (*env)->NewByteArray(env, dataLen);
+ CACheckJNIException(env);
+ (*env)->SetByteArrayRegion(env, jni_arr, 0, dataLen, (jbyte*) data);
+ CACheckJNIException(env);
+ g_sendBuffer = (jbyteArray)(*env)->NewGlobalRef(env, jni_arr);
+ CACheckJNIException(env);
- CAResult_t res = CALEServerSend(env, jni_obj_bluetoothDevice, jni_bytearr_data);
+ CAResult_t res = CALEServerSend(env, g_obj_bluetoothDevice, g_sendBuffer);
if (CA_STATUS_OK != res)
{
OIC_LOG(ERROR, TAG, "send has failed");
- return CA_SEND_FAILED;
+ goto error_exit;
}
}
else
{
OIC_LOG(ERROR, TAG, "There are no device to send in the list");
- return CA_STATUS_FAILED;
+ goto error_exit;
+ }
+
+ if (g_sendBuffer)
+ {
+ (*env)->DeleteGlobalRef(env, g_sendBuffer);
+ g_sendBuffer = NULL;
}
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerSendUnicastMessageImpl");
+ oc_mutex_unlock(g_threadSendMutex);
+ OIC_LOG(INFO, TAG, "unicast - send request is successful");
return CA_STATUS_OK;
+
+error_exit:
+ if (g_sendBuffer)
+ {
+ (*env)->DeleteGlobalRef(env, g_sendBuffer);
+ g_sendBuffer = NULL;
+ }
+
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+
+ oc_mutex_unlock(g_threadSendMutex);
+ return CA_SEND_FAILED;
}
-CAResult_t CALEServerSendMulticastMessageImpl(JNIEnv *env, const char *data, uint32_t dataLen)
+CAResult_t CALEServerSendMulticastMessageImpl(JNIEnv *env, const uint8_t *data, uint32_t dataLen)
{
- OIC_LOG_V(DEBUG, TAG, "IN - CALEServerSendMulticastMessageImpl, send to, data: %s", data);
+ OIC_LOG_V(DEBUG, TAG, "CALEServerSendMulticastMessageImpl, send to, data: %s", data);
VERIFY_NON_NULL(env, TAG, "env is null");
VERIFY_NON_NULL(data, TAG, "data is null");
return CA_STATUS_FAILED;
}
+ oc_mutex_lock(g_threadSendMutex);
+
+ OIC_LOG(DEBUG, TAG, "set data into g_sendBuffer for notify");
+ if (g_sendBuffer)
+ {
+ (*env)->DeleteGlobalRef(env, g_sendBuffer);
+ g_sendBuffer = NULL;
+ }
+ jbyteArray jni_arr = (*env)->NewByteArray(env, dataLen);
+ CACheckJNIException(env);
+ (*env)->SetByteArrayRegion(env, jni_arr, 0, dataLen, (jbyte*) data);
+ CACheckJNIException(env);
+ g_sendBuffer = (jbyteArray)(*env)->NewGlobalRef(env, jni_arr);
+ CACheckJNIException(env);
+
uint32_t length = u_arraylist_length(g_connectedDeviceList);
for (uint32_t index = 0; index < length; index++)
{
if (!jarrayObj)
{
OIC_LOG(ERROR, TAG, "jarrayObj is null");
- return CA_STATUS_FAILED;
+ continue;
}
// send data for all device
jbyteArray jni_bytearr_data = (*env)->NewByteArray(env, dataLen);
+ CACheckJNIException(env);
(*env)->SetByteArrayRegion(env, jni_bytearr_data, 0, dataLen, (jbyte*) data);
- CAResult_t res = CALEServerSend(env, jarrayObj, jni_bytearr_data);
+ CACheckJNIException(env);
+
+ jstring jni_address = CALEGetAddressFromBTDevice(env, jarrayObj);
+ if (!jni_address)
+ {
+ OIC_LOG(ERROR, TAG, "CALEGetAddressFromBTDevice has failed");
+ continue;
+ }
+
+ const char* address = (*env)->GetStringUTFChars(env, jni_address, NULL);
+ if (!address)
+ {
+ OIC_LOG(ERROR, TAG, "address is not available");
+ continue;
+ }
+
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+
+ if (jarrayObj)
+ {
+ g_obj_bluetoothDevice = (*env)->NewGlobalRef(env, jarrayObj);
+ CACheckJNIException(env);
+ }
+
+ CAResult_t res = CALEServerSend(env, g_obj_bluetoothDevice, jni_bytearr_data);
if (CA_STATUS_OK != res)
{
- OIC_LOG(ERROR, TAG, "send has failed");
- return CA_SEND_FAILED;
+ OIC_LOG_V(ERROR, TAG, "send has failed for the device[%s]", address);
+ (*env)->ReleaseStringUTFChars(env, jni_address, address);
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+ continue;
}
+
+ OIC_LOG_V(INFO, TAG, "unicast - send request is successful for a device[%s]", address);
+ (*env)->ReleaseStringUTFChars(env, jni_address, address);
+ }
+
+ if (g_sendBuffer)
+ {
+ (*env)->DeleteGlobalRef(env, g_sendBuffer);
+ g_sendBuffer = NULL;
}
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerSendMulticastMessageImpl");
+ oc_mutex_unlock(g_threadSendMutex);
return CA_STATUS_OK;
}
void CALEServerCreateCachedDeviceList()
{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerCreateCachedDeviceList");
-
- ca_mutex_lock(g_connectedDeviceListMutex);
+ oc_mutex_lock(g_connectedDeviceListMutex);
// create new object array
if (!g_connectedDeviceList)
{
OIC_LOG(DEBUG, TAG, "Create device list");
g_connectedDeviceList = u_arraylist_create();
}
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerCreateCachedDeviceList");
+ oc_mutex_lock(g_deviceStateListMutex);
+ // create new object array
+ if (!g_deviceStateList)
+ {
+ OIC_LOG(DEBUG, TAG, "Create device list");
+ g_deviceStateList = u_arraylist_create();
+ }
+ oc_mutex_unlock(g_deviceStateListMutex);
}
bool CALEServerIsDeviceInList(JNIEnv *env, const char* remoteAddress)
{
- OIC_LOG(DEBUG, TAG, "IN - CALEServerIsDeviceInList");
VERIFY_NON_NULL_RET(env, TAG, "env is null", false);
VERIFY_NON_NULL_RET(remoteAddress, TAG, "remoteAddress is null", false);
return false;
}
- if (!strcmp(remoteAddress, setAddress))
+ if (!strcasecmp(remoteAddress, setAddress))
{
OIC_LOG(ERROR, TAG, "the device is already set");
(*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
}
OIC_LOG(DEBUG, TAG, "there are no device in the list");
- OIC_LOG(DEBUG, TAG, "OUT - CALEServerCreateCachedDeviceList");
return false;
}
VERIFY_NON_NULL(device, TAG, "device is null");
VERIFY_NON_NULL(env, TAG, "env is null");
- ca_mutex_lock(g_connectedDeviceListMutex);
+ oc_mutex_lock(g_connectedDeviceListMutex);
if (!g_connectedDeviceList)
{
OIC_LOG(ERROR, TAG, "list is null");
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_FAILED;
}
if (!jni_remoteAddress)
{
OIC_LOG(ERROR, TAG, "jni_remoteAddress is null");
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_FAILED;
}
if (!remoteAddress)
{
OIC_LOG(ERROR, TAG, "remoteAddress is null");
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_FAILED;
}
}
(*env)->ReleaseStringUTFChars(env, jni_remoteAddress, remoteAddress);
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
OIC_LOG(DEBUG, TAG, "OUT - CALEServerAddDeviceToList");
return CA_STATUS_OK;
}
OIC_LOG(DEBUG, TAG, "IN - CALEServerRemoveAllDevices");
VERIFY_NON_NULL(env, TAG, "env is null");
- ca_mutex_lock(g_connectedDeviceListMutex);
+ oc_mutex_lock(g_connectedDeviceListMutex);
if (!g_connectedDeviceList)
{
OIC_LOG(ERROR, TAG, "g_connectedDeviceList is null");
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_FAILED;
}
OICFree(g_connectedDeviceList);
g_connectedDeviceList = NULL;
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
OIC_LOG(DEBUG, TAG, "OUT - CALEServerRemoveAllDevices");
return CA_STATUS_OK;
VERIFY_NON_NULL(env, TAG, "env is null");
VERIFY_NON_NULL(address, TAG, "address is null");
- ca_mutex_lock(g_connectedDeviceListMutex);
+ oc_mutex_lock(g_connectedDeviceListMutex);
if (!g_connectedDeviceList)
{
OIC_LOG(ERROR, TAG, "no deviceList");
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_FAILED;
}
continue;
}
- if (!strcmp(setAddress, remoteAddress))
+ if (!strcasecmp(setAddress, remoteAddress))
{
OIC_LOG_V(DEBUG, TAG, "device address : %s", remoteAddress);
(*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
(*env)->ReleaseStringUTFChars(env, address, remoteAddress);
(*env)->DeleteGlobalRef(env, jarrayObj);
+ jarrayObj = NULL;
- CAResult_t res = CALEServerReorderinglist(index);
- if (CA_STATUS_OK != res)
+ if (NULL == u_arraylist_remove(g_connectedDeviceList, index))
{
- OIC_LOG(ERROR, TAG, "CALEServerReorderinglist has failed");
- ca_mutex_unlock(g_connectedDeviceListMutex);
- return res;
+ OIC_LOG(ERROR, TAG, "List removal failed.");
+ oc_mutex_unlock(g_connectedDeviceListMutex);
+ return CA_STATUS_FAILED;
}
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
return CA_STATUS_OK;
}
(*env)->ReleaseStringUTFChars(env, jni_setAddress, setAddress);
}
}
- ca_mutex_unlock(g_connectedDeviceListMutex);
+ oc_mutex_unlock(g_connectedDeviceListMutex);
OIC_LOG(DEBUG, TAG, "there are no device in the device list");
return CA_STATUS_FAILED;
}
-CAResult_t CALEServerReorderinglist(uint32_t index)
-{
- if (!g_connectedDeviceList)
- {
- OIC_LOG(ERROR, TAG, "g_connectedDeviceList is null");
- return CA_STATUS_FAILED;
- }
-
- if (index >= g_connectedDeviceList->length)
- {
- OIC_LOG(ERROR, TAG, "index is not available");
- return CA_STATUS_FAILED;
- }
-
- if (index < g_connectedDeviceList->length - 1)
- {
- memmove(&g_connectedDeviceList->data[index], &g_connectedDeviceList->data[index + 1],
- (g_connectedDeviceList->length - index - 1) * sizeof(void *));
- }
-
- g_connectedDeviceList->size--;
- g_connectedDeviceList->length--;
-
- return CA_STATUS_OK;
-}
-
JNIEXPORT void JNICALL
Java_org_iotivity_ca_CaLeServerInterface_caLeRegisterGattServerCallback(JNIEnv *env, jobject obj,
- jobject callback)
+ jobject callback)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - Register Le Gatt Server Callback");
- VERIFY_NON_NULL_VOID(env, TAG, "env is null");
- VERIFY_NON_NULL_VOID(callback, TAG, "callback is null");
+ OIC_LOG(DEBUG, TAG, "Register Le Gatt Server Callback");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(callback, TAG, "callback");
g_bluetoothGattServerCallback = (*env)->NewGlobalRef(env, callback);
+ CACheckJNIException(env);
}
JNIEXPORT void JNICALL
jobject obj,
jobject callback)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - Register Le Advertise Callback");
- VERIFY_NON_NULL_VOID(env, TAG, "env is null");
- VERIFY_NON_NULL_VOID(callback, TAG, "callback is null");
+ OIC_LOG(DEBUG, TAG, "Register Le Advertise Callback");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(callback, TAG, "callback");
g_leAdvertiseCallback = (*env)->NewGlobalRef(env, callback);
+ CACheckJNIException(env);
}
JNIEXPORT void JNICALL
Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerConnectionStateChangeCallback(
JNIEnv *env, jobject obj, jobject device, jint status, jint newState)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - Gatt Server ConnectionStateChange Callback");
+ OIC_LOG(DEBUG, TAG, " Gatt Server ConnectionStateChange Callback");
OIC_LOG_V(DEBUG, TAG, "New connection State: %d", newState);
- VERIFY_NON_NULL_VOID(env, TAG, "env is null");
- VERIFY_NON_NULL_VOID(device, TAG, "device is null");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(device, TAG, "device");
- jclass jni_cid_bluetoothProfile = (*env)->FindClass(env, "android/bluetooth/BluetoothProfile");
- if (!jni_cid_bluetoothProfile)
+ jstring jni_remoteAddress = CALEGetAddressFromBTDevice(env, device);
+ if (!jni_remoteAddress)
{
- OIC_LOG(ERROR, TAG, "jni_cid_bluetoothProfile is null");
+ OIC_LOG(ERROR, TAG, "jni_remoteAddress is null");
return;
}
- jfieldID jni_fid_state_connected = (*env)->GetStaticFieldID(env, jni_cid_bluetoothProfile,
- "STATE_CONNECTED", "I");
- if(!jni_fid_state_connected)
+ const char* remoteAddress = (*env)->GetStringUTFChars(env, jni_remoteAddress, NULL);
+ if (!remoteAddress)
{
- OIC_LOG(ERROR, TAG, "jni_fid_state_connected is null");
+ OIC_LOG(ERROR, TAG, "remoteAddress is null");
+ CACheckJNIException(env);
return;
}
- jfieldID jni_fid_state_disconnected = (*env)->GetStaticFieldID(env, jni_cid_bluetoothProfile,
- "STATE_DISCONNECTED", "I");
- if(!jni_fid_state_disconnected)
+ if (newState == g_state_connected)
{
- OIC_LOG(ERROR, TAG, "jni_fid_state_disconnected is null");
- return;
- }
+ OIC_LOG(DEBUG, TAG, "LE CONNECTED");
- // STATE_CONNECTED
- jint jni_int_state_connected = (*env)->GetStaticIntField(env, jni_cid_bluetoothProfile,
- jni_fid_state_connected);
+ if (false == CALEServerIsDeviceInList(env, remoteAddress))
+ {
+ OIC_LOG(DEBUG, TAG, "add connected device to cache");
+ CALEServerAddDeviceToList(env, device);
+ }
- // STATE_DISCONNECTED
- jint jni_int_state_disconnected = (*env)->GetStaticIntField(env, jni_cid_bluetoothProfile,
- jni_fid_state_disconnected);
+ CAResult_t res = CALEUpdateDeviceState(remoteAddress,
+ CA_LE_CONNECTION_STATE,
+ STATE_CONNECTED,
+ g_deviceStateList,
+ g_deviceStateListMutex);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "CALEUpdateDeviceState has failed");
+ }
- if (newState == jni_int_state_connected)
+ res = CALEServerStopAdvertise();
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(DEBUG, TAG, "CALEServerStopAdvertise has failed");
+ }
+ }
+ else if (newState == g_state_disconnected)
{
-
- OIC_LOG(DEBUG, TAG, "LE CONNECTED");
+ OIC_LOG(DEBUG, TAG, "LE DISCONNECTED");
jstring jni_remoteAddress = CALEGetAddressFromBTDevice(env, device);
- if (!jni_remoteAddress)
+ CAResult_t res = CALEServerRemoveDevice(env, jni_remoteAddress);
+ if (CA_STATUS_OK != res)
{
- OIC_LOG(ERROR, TAG, "jni_remoteAddress is null");
- return;
+ OIC_LOG(ERROR, TAG, "CALEServerRemoveDevice has failed");
}
- const char* remoteAddress = (*env)->GetStringUTFChars(env, jni_remoteAddress, NULL);
- if (!remoteAddress)
+ res = CALEUpdateDeviceState(remoteAddress,
+ CA_LE_CONNECTION_STATE,
+ STATE_DISCONNECTED,
+ g_deviceStateList,
+ g_deviceStateListMutex);
+ if (CA_STATUS_OK != res)
{
- OIC_LOG(ERROR, TAG, "remoteAddress is null");
- return;
+ OIC_LOG(ERROR, TAG, "CALEUpdateDeviceState has failed");
}
- if (false == CALEServerIsDeviceInList(env, remoteAddress))
+ // start advertise
+ res = CALEServerStartAdvertise();
+ if (CA_STATUS_OK != res)
{
- OIC_LOG(DEBUG, TAG, "add connected device to cache");
- CALEServerAddDeviceToList(env, device);
+ OIC_LOG(ERROR, TAG, "CALEServerStartAdvertise has failed");
}
- (*env)->ReleaseStringUTFChars(env, jni_remoteAddress, remoteAddress);
- }
- else if (newState == jni_int_state_disconnected)
- {
- OIC_LOG(DEBUG, TAG, "LE DISCONNECTED");
}
else
{
+#ifndef TB_LOG
+ (void)status;
+#endif
OIC_LOG_V(DEBUG, TAG, "LE Connection state is [newState : %d, status %d]", newState,
status);
}
+ (*env)->ReleaseStringUTFChars(env, jni_remoteAddress, remoteAddress);
+ (*env)->DeleteLocalRef(env, jni_remoteAddress);
}
JNIEXPORT void JNICALL
Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerServiceAddedCallback(JNIEnv *env,
- jobject obj,
- jint status,
- jobject gattService)
+ jobject obj,
+ jint status,
+ jobject gattService)
{
- OIC_LOG_V(DEBUG, TAG, "CaLeServerInterface - Gatt Service Added Callback(%d)", status);
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(gattService, TAG, "gattService");
+#ifndef TB_LOG
+ (void)status;
+#endif
+ OIC_LOG_V(DEBUG, TAG, "Gatt Service Added Callback(%d)", status);
}
JNIEXPORT void JNICALL
Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerCharacteristicReadRequestCallback(
- JNIEnv *env, jobject obj, jobject device, jint requestId, jint offset,
- jobject characteristic, jbyteArray data)
+ JNIEnv *env, jobject obj, jobject device, jbyteArray data)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - Gatt Server Characteristic Read Request Callback");
- VERIFY_NON_NULL_VOID(env, TAG, "env is null");
- VERIFY_NON_NULL_VOID(device, TAG, "device is null");
-
-#ifdef USE_PROPERTY_WRITE_RESPONSE
- CALEServerSendResponse(env, device, requestId, 0, offset, NULL);
-#endif
-
+ OIC_LOG(DEBUG, TAG, " Gatt Server Characteristic Read Request Callback");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(device, TAG, "device");
+ VERIFY_NON_NULL_VOID(data, TAG, "data");
}
JNIEXPORT void JNICALL
Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerCharacteristicWriteRequestCallback(
- JNIEnv *env, jobject obj, jobject device, jint requestId, jobject characteristic,
- jbyteArray data, jboolean preparedWrite, jboolean responseNeeded, jint offset,
- jbyteArray value)
+ JNIEnv *env, jobject obj, jobject device, jbyteArray data,
+ jint requestId, jint offset, jbyteArray value)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - Gatt Server Characteristic Write Request Callback");
- VERIFY_NON_NULL_VOID(env, TAG, "env is null");
- VERIFY_NON_NULL_VOID(device, TAG, "device is null");
- VERIFY_NON_NULL_VOID(value, TAG, "value is null");
- VERIFY_NON_NULL_VOID(data, TAG, "data is null");
-
-#ifdef USE_PROPERTY_WRITE_RESPONSE
- CALEServerSendResponse(env, device, requestId, 0, offset, value);
-#endif
+ OIC_LOG_V(DEBUG, TAG, "Gatt Server Characteristic Write Request Callback");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(device, TAG, "device");
+ VERIFY_NON_NULL_VOID(data, TAG, "data");
- // get Byte Array and covert to char*
+ if (g_setHighQoS)
+ {
+ CALEServerSendResponse(env, device, requestId, 0, offset, value);
+ }
+ else
+ {
+ (void)requestId;
+ (void)offset;
+ (void)value;
+ }
+
+ // get Byte Array and covert to uint8_t*
jint length = (*env)->GetArrayLength(env, data);
+ CACheckJNIException(env);
jboolean isCopy;
jbyte *jni_byte_requestData = (jbyte *) (*env)->GetByteArrayElements(env, data, &isCopy);
+ CACheckJNIException(env);
- char* requestData = NULL;
- requestData = (char*) OICMalloc(sizeof(char) * length + 1);
+ uint8_t* requestData = NULL;
+ requestData = OICMalloc(length);
if (!requestData)
{
OIC_LOG(ERROR, TAG, "requestData is null");
return;
}
- memcpy(requestData, (const char*) jni_byte_requestData, length);
- requestData[length] = '\0';
+ memcpy(requestData, jni_byte_requestData, length);
(*env)->ReleaseByteArrayElements(env, data, jni_byte_requestData, JNI_ABORT);
jstring jni_address = CALEGetAddressFromBTDevice(env, device);
if (!address)
{
OIC_LOG(ERROR, TAG, "address is null");
+ CACheckJNIException(env);
OICFree(requestData);
return;
}
- OIC_LOG_V(DEBUG, TAG, "remote device address : %s, %s, %d", address, requestData, length);
+ OIC_LOG_V(DEBUG, TAG, "remote device address : %s, %p, %d", address, requestData, length);
- ca_mutex_lock(g_bleClientBDAddressMutex);
+ oc_mutex_lock(g_bleClientBDAddressMutex);
uint32_t sentLength = 0;
- g_CABLEServerDataReceivedCallback(address, OIC_GATT_SERVICE_UUID, requestData, length,
+ g_CABLEServerDataReceivedCallback(address, requestData, length,
&sentLength);
- ca_mutex_unlock(g_bleClientBDAddressMutex);
+ oc_mutex_unlock(g_bleClientBDAddressMutex);
(*env)->ReleaseStringUTFChars(env, jni_address, address);
}
JNIEXPORT void JNICALL
-Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerDescriptorReadRequestCallback(
- JNIEnv *env, jobject obj, jobject device, jint requestId, jint offset, jobject descriptor)
+Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerNotificationSentCallback(JNIEnv *env,
+ jobject obj,
+ jobject device,
+ jint status)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface_CALeGattServerDescriptorReadRequestCallback");
-}
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(device, TAG, "device");
-JNIEXPORT void JNICALL
-Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerDescriptorWriteRequestCallback(
- JNIEnv *env, jobject obj, jobject device, jint requestId, jobject descriptor,
- jboolean preparedWrite, jboolean responseNeeded, jint offset, jbyteArray value)
-{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface_CALeGattServerDescriptorWriteRequestCallback");
-}
+ OIC_LOG_V(DEBUG, TAG, "Gatt Server Notification Sent Callback (status : %d)",
+ status);
-JNIEXPORT void JNICALL
-Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerExecuteWriteCallback(JNIEnv *env,
- jobject obj,
- jobject device,
- jint requestId,
- jboolean execute)
-{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface_CALeGattServerExecuteWriteCallback");
- VERIFY_NON_NULL_VOID(env, TAG, "env is null");
- VERIFY_NON_NULL_VOID(device, TAG, "device is null");
+ jstring jni_address = CALEGetAddressFromBTDevice(env, device);
+ if (!jni_address)
+ {
+ OIC_LOG(ERROR, TAG, "jni_address is null");
+ return;
+ }
+
+ const char* address = (*env)->GetStringUTFChars(env, jni_address, NULL);
+ if (!address)
+ {
+ OIC_LOG(ERROR, TAG, "address is not available");
+ (*env)->DeleteLocalRef(env, jni_address);
+ return;
+ }
+
+ jint gatt_success = CALEGetConstantsValue(env, CLASSPATH_BT_GATT, "GATT_SUCCESS");
+ if (gatt_success != status) // error case
+ {
+ OIC_LOG(ERROR, TAG, "it will be sent again.");
+
+ CAResult_t res = CALEServerSend(env, device, g_sendBuffer);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "send has failed");
+
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+
+ oc_mutex_lock(g_threadSendNotifyMutex);
+ g_isSignalSetFlag = true;
+ oc_cond_signal(g_threadSendNotifyCond);
+ oc_mutex_unlock(g_threadSendNotifyMutex);
+
+ (*env)->ReleaseStringUTFChars(env, jni_address, address);
+ (*env)->DeleteLocalRef(env, jni_address);
+ return;
+ }
+
+ CALogSendStateInfo(CA_ADAPTER_GATT_BTLE, address, 0, -1,
+ false, "notifyChar failure");
+ }
+ else
+ {
+ OIC_LOG(DEBUG, TAG, "notify success");
+
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+
+ // next data can be sent
+ oc_mutex_lock(g_threadSendNotifyMutex);
+ OIC_LOG(DEBUG, TAG, "g_isSignalSetFlag is set true and signal");
+ g_isSignalSetFlag = true;
+ oc_cond_signal(g_threadSendNotifyCond);
+ oc_mutex_unlock(g_threadSendNotifyMutex);
+
+ CALogSendStateInfo(CA_ADAPTER_GATT_BTLE, address, 0, -1,
+ true, "notifyChar success");
+ }
+ (*env)->ReleaseStringUTFChars(env, jni_address, address);
+ (*env)->DeleteLocalRef(env, jni_address);
-// CALEServerSendResponse(env, device, requestId, 0, 0, NULL);
}
JNIEXPORT void JNICALL
-Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerNotificationSentCallback(JNIEnv *env,
- jobject obj,
- jobject device,
- jint status)
+Java_org_iotivity_ca_CaLeServerInterface_caLeAdvertiseStartSuccessCallback(JNIEnv *env,
+ jobject obj,
+ jobject settingsInEffect)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - Gatt Server Notification Sent Callback");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(settingsInEffect, TAG, "settingsInEffect");
+
+ OIC_LOG(DEBUG, TAG, "LE Advertise Start Success Callback");
}
JNIEXPORT void JNICALL
-Java_org_iotivity_ca_CaLeServerInterface_caLeAdvertiseStartSuccessCallback(
- JNIEnv *env, jobject obj, jobject settingsInEffect)
+Java_org_iotivity_ca_CaLeServerInterface_caLeAdvertiseStartFailureCallback(JNIEnv *env,
+ jobject obj,
+ jint errorCode)
{
- OIC_LOG(DEBUG, TAG, "CaLeServerInterface - LE Advertise Start Success Callback");
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+
+ OIC_LOG_V(INFO, TAG, "LE Advertise Start Failure Callback(%d)", errorCode);
+
+ jint data_too_large = CALEGetConstantsValue(env, CLASSPATH_BT_ADVERTISE_CB,
+ "ADVERTISE_FAILED_DATA_TOO_LARGE");
+ jint already_started = CALEGetConstantsValue(env, CLASSPATH_BT_ADVERTISE_CB,
+ "ADVERTISE_FAILED_ALREADY_STARTED");
+
+ if (data_too_large == errorCode)
+ {
+ OIC_LOG_V(ERROR, TAG, "advertise data too large. please check length of device name");
+ }
+ else if (already_started == errorCode)
+ {
+ OIC_LOG_V(INFO, TAG, "advertising is already started");
+ }
}
JNIEXPORT void JNICALL
-Java_org_iotivity_ca_CaLeServerInterface_caLeAdvertiseStartFailureCallback(JNIEnv *env,
- jobject obj,
- jint errorCode)
+Java_org_iotivity_ca_CaLeServerInterface_caLeGattServerMtuChangedCallback(JNIEnv * env,
+ jobject obj,
+ jobject device,
+ jint mtu)
{
- OIC_LOG_V(ERROR, TAG, "CaLeServerInterface - LE Advertise Start Failure Callback(%)",
- errorCode);
+ VERIFY_NON_NULL_VOID(env, TAG, "env");
+ VERIFY_NON_NULL_VOID(obj, TAG, "obj");
+ VERIFY_NON_NULL_VOID(device, TAG, "device");
+
+ OIC_LOG_V(INFO, TAG, "gatt MTU size is changed (%d byte)", mtu);
+
+ jstring jni_address = CALEGetAddressFromBTDevice(env, device);
+ if (!jni_address)
+ {
+ OIC_LOG(ERROR, TAG, "jni_address is null");
+ return;
+ }
+
+ const char* address = (*env)->GetStringUTFChars(env, jni_address, NULL);
+ if (!address)
+ {
+ OIC_LOG(ERROR, TAG, "address is not available");
+ (*env)->DeleteLocalRef(env, jni_address);
+ return;
+ }
+
+ // update mtu size
+ CAResult_t res = CALESetMtuSize(address, mtu - CA_BLE_MTU_HEADER_SIZE,
+ g_deviceStateList, g_deviceStateListMutex);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "CALESetMtuSize has failed");
+ }
+
+ res = CALEUpdateDeviceState(address, CA_LE_SEND_STATE,
+ STATE_SEND_MTU_NEGO_SUCCESS,
+ g_deviceStateList,
+ g_deviceStateListMutex);
+ if (CA_STATUS_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "CALEUpdateDeviceState has failed");
+ }
+
+ (*env)->ReleaseStringUTFChars(env, jni_address, address);
+ (*env)->DeleteLocalRef(env, jni_address);
}
/**
* adapter common
*/
-CAResult_t CAStartBleGattServer()
+CAResult_t CAStartLEGattServer()
{
- OIC_LOG(DEBUG, TAG, "IN");
+ // start gatt service
+ CALEServerStartMulticastServer();
+
+ return CA_STATUS_OK;
+}
+
+CAResult_t CAStopLEGattServer()
+{
+ OIC_LOG(DEBUG, TAG, "CAStopLEGattServer");
+
+ if (!g_jvm)
+ {
+ OIC_LOG(ERROR, TAG, "g_jvm is null");
+ return CA_STATUS_FAILED;
+ }
+
+ bool isAttached = false;
+ JNIEnv* env = NULL;
+ jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
+ if (JNI_OK != res)
+ {
+ OIC_LOG(INFO, TAG, "Could not get JNIEnv pointer");
+ res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
+
+ if (JNI_OK != res)
+ {
+ OIC_LOG(ERROR, TAG, "AttachCurrentThread has failed");
+ return CA_STATUS_FAILED;
+ }
+ isAttached = true;
+ }
- CAResult_t ret = CALEServerInitMutexVaraibles();
+ CAResult_t ret = CALEServerGattClose(env, g_bluetoothGattServer);
if (CA_STATUS_OK != ret)
{
- OIC_LOG(ERROR, TAG, "CALEServerInitMutexVaraibles has failed!");
- CALEServerTerminateMutexVaraibles();
- return CA_SERVER_NOT_STARTED;
+ OIC_LOG(ERROR, TAG, "CALEServerGattClose has failed");
+ return CA_STATUS_FAILED;
}
- ret = CALEServerInitConditionVaraibles();
+ ret = CALEServerStopMulticastServer();
if (CA_STATUS_OK != ret)
{
- OIC_LOG(ERROR, TAG, "CALEServerInitConditionVaraibles has failed!");
- CALEServerTerminateConditionVaraibles();
- return CA_SERVER_NOT_STARTED;
+ OIC_LOG(ERROR, TAG, "CALEServerStopMulticastServer has failed");
+ return CA_STATUS_FAILED;
}
- // start gatt service
- CALEServerStartMulticastServer();
+ ret = CALEServerDisconnectAllDevices(env);
+ if (CA_STATUS_OK != ret)
+ {
+ OIC_LOG(ERROR, TAG, "CALEServerDisconnectAllDevices has failed");
+ return CA_STATUS_FAILED;
+ }
- OIC_LOG(DEBUG, TAG, "OUT");
- return CA_STATUS_OK;
-}
+ ret = CALEServerRemoveAllDevices(env);
+ if (CA_STATUS_OK != ret)
+ {
+ OIC_LOG(ERROR, TAG, "CALEServerRemoveAllDevices has failed");
+ return CA_STATUS_FAILED;
+ }
-CAResult_t CAStopBleGattServer()
-{
- OIC_LOG(DEBUG, TAG, "IN");
+ if (g_leAdvertiseCallback)
+ {
+ (*env)->DeleteGlobalRef(env, g_leAdvertiseCallback);
+ }
+
+ if (g_bluetoothGattServer)
+ {
+ (*env)->DeleteGlobalRef(env, g_bluetoothGattServer);
+ }
+
+ if (g_bluetoothGattServerCallback)
+ {
+ (*env)->DeleteGlobalRef(env, g_bluetoothGattServerCallback);
+ }
+
+ if (g_obj_bluetoothDevice)
+ {
+ (*env)->DeleteGlobalRef(env, g_obj_bluetoothDevice);
+ g_obj_bluetoothDevice = NULL;
+ }
+
+ oc_mutex_lock(g_threadSendNotifyMutex);
+ oc_cond_signal(g_threadSendNotifyCond);
+ oc_mutex_unlock(g_threadSendNotifyMutex);
+
+ g_isStartServer = false;
+
+ if (isAttached)
+ {
+ (*g_jvm)->DetachCurrentThread(g_jvm);
+ }
- OIC_LOG(DEBUG, TAG, "OUT");
return CA_STATUS_OK;
}
-void CATerminateBleGattServer()
+CAResult_t CAInitializeLEGattServer()
{
- OIC_LOG(DEBUG, TAG, "IN");
+ OIC_LOG(DEBUG, TAG, "Initialize Gatt Server");
+ return CALEServerInitialize();
+}
- OIC_LOG(DEBUG, TAG, "Terminat Gatt Server");
+void CATerminateLEGattServer()
+{
+ OIC_LOG(DEBUG, TAG, "Terminate Gatt Server");
CALEServerTerminate();
-
- OIC_LOG(DEBUG, TAG, "OUT");
}
-void CASetBLEReqRespServerCallback(CABLEServerDataReceivedCallback callback)
+void CASetLEReqRespServerCallback(CABLEDataReceivedCallback callback)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- ca_mutex_lock(g_bleReqRespCbMutex);
+ oc_mutex_lock(g_bleReqRespCbMutex);
g_CABLEServerDataReceivedCallback = callback;
- ca_mutex_unlock(g_bleReqRespCbMutex);
-
- OIC_LOG(DEBUG, TAG, "OUT");
+ oc_mutex_unlock(g_bleReqRespCbMutex);
}
void CASetBLEServerErrorHandleCallback(CABLEErrorHandleCallback callback)
g_serverErrorCallback = callback;
}
-CAResult_t CAUpdateCharacteristicsToGattClient(const char* address, const char *charValue,
- const uint32_t charValueLen)
+CAResult_t CAUpdateCharacteristicsToGattClient(const char *address,
+ const uint8_t *charValue,
+ uint32_t charValueLen)
{
CAResult_t result = CA_SEND_FAILED;
- OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL(address, TAG, "env is null");
VERIFY_NON_NULL(charValue, TAG, "device is null");
if (address)
{
- OIC_LOG(DEBUG, TAG, "CALEServerSendUnicastData");
result = CALEServerSendUnicastMessage(address, charValue, charValueLen);
}
- OIC_LOG(DEBUG, TAG, "OUT");
-
return result;
}
-CAResult_t CAUpdateCharacteristicsToAllGattClients(const char *charValue,
- const uint32_t charValueLen)
+CAResult_t CAUpdateCharacteristicsToAllGattClients(const uint8_t *charValue,
+ uint32_t charValueLen)
{
- OIC_LOG(DEBUG, TAG, "IN");
VERIFY_NON_NULL(charValue, TAG, "device is null");
- OIC_LOG(DEBUG, TAG, "CALEServerSendMulticastMessage");
CAResult_t result = CALEServerSendMulticastMessage(charValue, charValueLen);
- OIC_LOG(DEBUG, TAG, "OUT");
return result;
}
-void CASetBleServerThreadPoolHandle(ca_thread_pool_t handle)
+void CASetLEServerThreadPoolHandle(ca_thread_pool_t handle)
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- CALEServerInitialize(handle);
-
- OIC_LOG(DEBUG, TAG, "OUT");
+ OIC_LOG(INFO, TAG, "CASetLEServerThreadPoolHandle is not support");
+ (void)handle;
}
CAResult_t CALEServerInitMutexVaraibles()
{
- OIC_LOG(DEBUG, TAG, "IN");
if (NULL == g_bleReqRespCbMutex)
{
- g_bleReqRespCbMutex = ca_mutex_new();
+ g_bleReqRespCbMutex = oc_mutex_new();
if (NULL == g_bleReqRespCbMutex)
{
- OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
+ OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
return CA_STATUS_FAILED;
}
}
if (NULL == g_bleClientBDAddressMutex)
{
- g_bleClientBDAddressMutex = ca_mutex_new();
+ g_bleClientBDAddressMutex = oc_mutex_new();
if (NULL == g_bleClientBDAddressMutex)
{
- OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
+ OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
return CA_STATUS_FAILED;
}
}
if (NULL == g_connectedDeviceListMutex)
{
- g_connectedDeviceListMutex = ca_mutex_new();
+ g_connectedDeviceListMutex = oc_mutex_new();
if (NULL == g_connectedDeviceListMutex)
{
- OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
+ OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
return CA_STATUS_FAILED;
}
}
- OIC_LOG(DEBUG, TAG, "OUT");
- return CA_STATUS_OK;
-}
+ if (NULL == g_threadSendMutex)
+ {
+ g_threadSendMutex = oc_mutex_new();
+ if (NULL == g_threadSendMutex)
+ {
+ OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
+ return CA_STATUS_FAILED;
+ }
+ }
+
+ if (NULL == g_threadSendNotifyMutex)
+ {
+ g_threadSendNotifyMutex = oc_mutex_new();
+ if (NULL == g_threadSendNotifyMutex)
+ {
+ OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
+ return CA_STATUS_FAILED;
+ }
+ }
+
+ if (NULL == g_deviceStateListMutex)
+ {
+ g_deviceStateListMutex = oc_mutex_new();
+ if (NULL == g_deviceStateListMutex)
+ {
+ OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
+ return CA_STATUS_FAILED;
+ }
+ }
-CAResult_t CALEServerInitConditionVaraibles()
-{
- OIC_LOG(DEBUG, TAG, "this method is not supported");
return CA_STATUS_OK;
}
void CALEServerTerminateMutexVaraibles()
{
- OIC_LOG(DEBUG, TAG, "IN");
-
- ca_mutex_free(g_bleReqRespCbMutex);
+ oc_mutex_free(g_bleReqRespCbMutex);
g_bleReqRespCbMutex = NULL;
- ca_mutex_free(g_bleClientBDAddressMutex);
+ oc_mutex_free(g_bleClientBDAddressMutex);
g_bleClientBDAddressMutex = NULL;
- ca_mutex_free(g_connectedDeviceListMutex);
+ oc_mutex_free(g_connectedDeviceListMutex);
g_connectedDeviceListMutex = NULL;
- OIC_LOG(DEBUG, TAG, "OUT");
+ oc_mutex_free(g_threadSendMutex);
+ g_threadSendMutex = NULL;
+
+ oc_mutex_free(g_threadSendNotifyMutex);
+ g_threadSendNotifyMutex = NULL;
+
+ oc_mutex_free(g_deviceStateListMutex);
+ g_deviceStateListMutex = NULL;
}
void CALEServerTerminateConditionVaraibles()
{
OIC_LOG(DEBUG, TAG, "this method is not supported");
}
+
+bool CALEServerIsConnected(const char* address)
+{
+ if (CALEIsValidState(address, CA_LE_CONNECTION_STATE,
+ STATE_SERVICE_CONNECTED,
+ g_deviceStateList,
+ g_deviceStateListMutex))
+ {
+ OIC_LOG(DEBUG, TAG, "current state is connected");
+ return true;
+ }
+ OIC_LOG(DEBUG, TAG, "current state is not connected");
+ return false;
+}
+
+uint16_t CALEServerGetMtuSize(const char* address)
+{
+ return CALEGetMtuSize(address, g_deviceStateList, g_deviceStateListMutex);
+}
+