resource/csdk/connectivity/util/src/camanager/android/caleconnectionmanager.c

   1 /* ****************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include <jni.h>
  22 #include "logger.h"
  23 #include "cautilinterface.h"
  24 #include "camanagerleinterface.h"
  25 #include "camanagerleutil.h"
  26 #include "caleautoconnector.h"
  27 #include "cacommon.h"
  28 #include "cacommonutil.h"
  29 #include "camanagerdevice.h"
  30 #include "caleclient.h"
  31 #include "caleutils.h"
  32
  33 #define TAG "OIC_CA_MANAGER_LE"
  34
  35 static const jint SUPPORT_ADNROID_API_LEVEL = 18;
  36 static const jint AUTH_FAIL = 5;
  37 static const jint LINK_LOSS = 8;
  38 static const jint ACCEPT_TIMEOUT_EXCEPTION = 16;
  39 static const jint REMOTE_DISCONNECT = 19;
  40 static const jint LOCAL_DISCONNECT = 22;
  41 static const jint USER_REMOVED_BOND = 68;
  42 static JavaVM *g_jvm = NULL;
  43 static jobject g_context = NULL;
  44 static jobject g_connectedDeviceSet = NULL;
  45
  46
  47 CAResult_t CASetLEClientAutoConnectionDeviceInfo(const char* address)
  48 {
  49     OIC_LOG(DEBUG, TAG, "CASetClientAutoConnectionDeviceInfo");
  50     VERIFY_NON_NULL(address, TAG, "address");
  51
  52     bool isAttached = false;
  53     JNIEnv* env = NULL;
  54     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
  55     if (JNI_OK != res)
  56     {
  57         OIC_LOG(DEBUG, TAG, "AttachCurrentThread will be called for JNIEnv pointer");
  58         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
  59
  60         if (JNI_OK != res)
  61         {
  62             OIC_LOG(ERROR, TAG, "AttachCurrentThread has failed");
  63             return CA_STATUS_FAILED;
  64         }
  65         isAttached = true;
  66     }
  67     OIC_LOG_V(DEBUG, TAG, "set [%s] for Auto Connection", address);
  68
  69     jstring jni_leAddress = (*env)->NewStringUTF(env, address);
  70     if (!jni_leAddress)
  71     {
  72         OIC_LOG(ERROR, TAG, "jni_leAddress is null");
  73         goto error_exit;
  74     }
  75
  76     if (!CAManagerCheckBTAddress(env, jni_leAddress))
  77     {
  78         OIC_LOG(ERROR, TAG, "this address is not BT address string format");
  79         goto error_exit;
  80     }
  81
  82     // if there is target address in SharedPreference, it will be reset.
  83     if (CAManagerIsConnectedDeviceAddress(env, g_context, jni_leAddress, g_connectedDeviceSet))
  84     {
  85         if (!CAManagerRemoveConnectedDeviceAddress(env, g_context, jni_leAddress,
  86                                                    g_connectedDeviceSet))
  87         {
  88             OIC_LOG(ERROR, TAG, "Preference - remove has failed");
  89         }
  90         else
  91         {
  92             OIC_LOG(INFO, TAG, "Preference - remove success");
  93         }
  94     }
  95
  96     // it will be added new target address.
  97     if (!CAManagerAddConnectedDeviceAddress(env, g_context, jni_leAddress, g_connectedDeviceSet))
  98     {
  99         OIC_LOG(ERROR, TAG, "Preference - putting has failed");
 100     }
 101     else
 102     {
 103         OIC_LOG(INFO, TAG, "Preference - putting success");
 104     }
 105
 106     if (isAttached)
 107     {
 108         (*g_jvm)->DetachCurrentThread(g_jvm);
 109     }
 110
 111     return CA_STATUS_OK;
 112
 113 error_exit:
 114
 115     if (isAttached)
 116     {
 117         (*g_jvm)->DetachCurrentThread(g_jvm);
 118     }
 119
 120     return CA_STATUS_FAILED;
 121 }
 122
 123 CAResult_t CAUnsetLEClientAutoConnectionDeviceInfo(const char* address)
 124 {
 125     OIC_LOG(DEBUG, TAG, "CAUnsetClientAutoConnectionDeviceInfo");
 126     VERIFY_NON_NULL(address, TAG, "address");
 127
 128     bool isAttached = false;
 129     JNIEnv* env = NULL;
 130     jint res = (*g_jvm)->GetEnv(g_jvm, (void**) &env, JNI_VERSION_1_6);
 131     if (JNI_OK != res)
 132     {
 133         OIC_LOG(DEBUG, TAG, "AttachCurrentThread will be called for JNIEnv pointer");
 134         res = (*g_jvm)->AttachCurrentThread(g_jvm, &env, NULL);
 135
 136         if (JNI_OK != res)
 137         {
 138             OIC_LOG(ERROR, TAG, "AttachCurrentThread has failed");
 139             return CA_STATUS_FAILED;
 140         }
 141         isAttached = true;
 142     }
 143     OIC_LOG_V(DEBUG, TAG, "unset [%s] for Auto Connection", address);
 144
 145     jstring jni_leAddress = (*env)->NewStringUTF(env, address);
 146     if (!jni_leAddress)
 147     {
 148         OIC_LOG(ERROR, TAG, "jni_leAddress is null");
 149         goto error_exit;
 150     }
 151
 152     if (!CAManagerCheckBTAddress(env, jni_leAddress))
 153     {
 154         OIC_LOG(ERROR, TAG, "this address is not BT address string format");
 155         goto error_exit;
 156     }
 157
 158     // if there is target address in SharedPreference, it will be removed
 159     if (CAManagerIsConnectedDeviceAddress(env, g_context, jni_leAddress, g_connectedDeviceSet))
 160     {
 161         if (!CAManagerRemoveConnectedDeviceAddress(env, g_context, jni_leAddress,
 162                                                    g_connectedDeviceSet))
 163         {
 164             OIC_LOG(ERROR, TAG, "Preference - remove has failed");
 165         }
 166         else
 167         {
 168             OIC_LOG(INFO, TAG, "Preference - remove success");
 169         }
 170     }
 171
 172     // remove target device for auto connection
 173     CAResult_t ret = CAManagerRemoveACData(env, jni_leAddress);
 174     if (CA_STATUS_OK != ret)
 175     {
 176         OIC_LOG(ERROR, TAG, "CAManagerRemoveACData has failed");
 177     }
 178
 179     if (isAttached)
 180     {
 181         (*g_jvm)->DetachCurrentThread(g_jvm);
 182     }
 183
 184     return ret;
 185
 186 error_exit:
 187
 188     if (isAttached)
 189     {
 190         (*g_jvm)->DetachCurrentThread(g_jvm);
 191     }
 192
 193     return CA_STATUS_FAILED;
 194 }
 195
 196 CAResult_t CAManagerLEClientInitialize(JNIEnv *env, JavaVM *jvm, jobject context)
 197 {
 198     OIC_LOG(DEBUG, TAG, "CAManagerClientInitialize");
 199     VERIFY_NON_NULL(env, TAG, "env");
 200     VERIFY_NON_NULL(jvm, TAG, "jvm");
 201     VERIFY_NON_NULL(context, TAG, "context");
 202
 203     jint jni_int_sdk = CALEGetBuildVersion(env);
 204     if (jni_int_sdk < SUPPORT_ADNROID_API_LEVEL)
 205     {
 206         OIC_LOG_V(ERROR, TAG, "it is not supported (%d)", jni_int_sdk);
 207         return CA_STATUS_FAILED;
 208     }
 209
 210     g_jvm = jvm;
 211     g_context = (*env)->NewGlobalRef(env, context);;
 212
 213     CAManagerInitMutexVaraibles();
 214     CAManagerInitLEAutoConnection();
 215     CAManagerCreateACDataList();
 216
 217     // get last connected device list
 218     jobject set = NULL;
 219     set = CAManagerGetConnectedDeviceAddress(env, g_context);
 220     if (!set)
 221     {
 222         // create new set<String> object
 223         set = CAManagerCreateSetString(env);
 224         if (!set)
 225         {
 226             OIC_LOG(ERROR, TAG, "CAManagerCreateSetString has failed");
 227             return CA_STATUS_FAILED;
 228         }
 229         OIC_LOG(DEBUG, TAG, "created new SetString");
 230     }
 231     else
 232     {
 233         OIC_LOG(DEBUG, TAG, "get previous Set<String> object");
 234     }
 235
 236     g_connectedDeviceSet = (jobject)(*env)->NewGlobalRef(env, set);
 237     if (!g_connectedDeviceSet)
 238     {
 239         OIC_LOG(ERROR, TAG, "g_connectedDeviceSet is null");
 240         return CA_STATUS_FAILED;
 241     }
 242
 243     return CA_STATUS_OK;
 244 }
 245
 246 CAResult_t CAManagerLEClientTerminate(JNIEnv *env)
 247 {
 248     OIC_LOG(DEBUG, TAG, "CAManagerClientTerminate");
 249     VERIFY_NON_NULL(env, TAG, "env");
 250
 251     // stop gatt connection
 252     CAResult_t res = CALEClientDisconnectAll(env);
 253     if (CA_STATUS_OK != res)
 254     {
 255         OIC_LOG(ERROR, TAG, "CALEClientDisconnectAll has failed");
 256     }
 257
 258     res = CAManagerRemoveAllACData(env);
 259     if (CA_STATUS_OK != res)
 260     {
 261         OIC_LOG(ERROR, TAG, "CAManagerRemoveAllACData has failed");
 262     }
 263
 264     CAManagerDestroyACDataList();
 265     CAManagerTerminateLEAutoConnection();
 266     CAManagerTerminateMutexVariables();
 267
 268     if (g_context)
 269     {
 270         (*env)->DeleteGlobalRef(env, g_context);
 271         g_context = NULL;
 272     }
 273
 274     if (g_connectedDeviceSet)
 275     {
 276         (*env)->DeleteGlobalRef(env, g_connectedDeviceSet);
 277         g_connectedDeviceSet = NULL;
 278     }
 279
 280     return res;
 281 }
 282
 283 void CAManagerLESetScanInterval(jint interval, jint count)
 284 {
 285     OIC_LOG(DEBUG, TAG, "CAManagerLESetScanInterval");
 286     CALERestartScanWithInterval(interval, count, BLE_SCAN_ENABLE);
 287 }
 288
 289 JNIEXPORT void JNICALL
 290 Java_org_iotivity_ca_CaLeClientInterface_caManagerAdapterStateChangedCallback(
 291         JNIEnv *env, jobject obj, jint state)
 292 {
 293     OIC_LOG_V(INFO, TAG, "caManagerAdapterStateChangedCallback - state %d", state);
 294     VERIFY_NON_NULL_VOID(env, TAG, "env");
 295     VERIFY_NON_NULL_VOID(obj, TAG, "obj");
 296
 297     jint state_on = CALEGetConstantsValue(env, CLASSPATH_BT_ADAPTER, "STATE_ON");
 298     jint state_off = CALEGetConstantsValue(env, CLASSPATH_BT_ADAPTER, "STATE_OFF");
 299     jint state_turning_off = CALEGetConstantsValue(env, CLASSPATH_BT_ADAPTER, "STATE_TURNING_OFF");
 300
 301     if (state_on == state)
 302     {
 303         OIC_LOG(DEBUG, TAG, "AdapterStateChangedCallback : state_on");
 304
 305         // when BT state is on. recovery flag has to be reset.
 306         CAManagerSetBTRecovery(false);
 307
 308         // find target device for autoconnect
 309         size_t length = CAManagerGetACDataLength();
 310         OIC_LOG_V(DEBUG, TAG, "length of ACDataList : %d", length);
 311         for (size_t idx = 0; idx < length; idx++)
 312         {
 313             jstring leAddress = CAManagerGetLEAddressFromACData(env, idx);
 314             if (leAddress)
 315             {
 316                 CAResult_t res = CAManagerStartAutoConnection(env, leAddress);
 317                 if (CA_STATUS_OK != res)
 318                 {
 319                     OIC_LOG(ERROR, TAG, "CAManagerStartAutoConnection has failed");
 320                     return;
 321                 }
 322             }
 323         }
 324     }
 325     else if (state_off == state)
 326     {
 327         OIC_LOG(DEBUG, TAG, "AdapterStateChangedCallback : state_off");
 328
 329         // reset isAutoConnecting flag for all target devices
 330         size_t length = CAManagerGetACDataLength();
 331         OIC_LOG_V(DEBUG, TAG, "length of ACDataList : %d", length);
 332         for (size_t idx = 0; idx < length; idx++)
 333         {
 334             jstring address = CAManagerGetLEAddressFromACData(env, idx);
 335             if (address)
 336             {
 337                 CAManagerSetAutoConnectingFlag(env, address, false);
 338             }
 339         }
 340
 341         // check whether BT recovery is needed or not
 342         if (CAManagerIsRecoveryFlagSet())
 343         {
 344             CAManagerProcessRecovery(env, STATE_OFF);
 345         }
 346     }
 347     else if (state_turning_off == state)
 348     {
 349         OIC_LOG(DEBUG, TAG, "AdapterStateChangedCallback : state_turning_off");
 350     }
 351     else
 352     {
 353         OIC_LOG(INFO, TAG, "AdapterStateChangedCallback state is not available");
 354     }
 355 }
 356
 357 JNIEXPORT void JNICALL
 358 Java_org_iotivity_ca_CaLeClientInterface_caManagerBondStateChangedCallback(
 359         JNIEnv *env, jobject obj, jobject device)
 360 {
 361     OIC_LOG(INFO, TAG, "caManagerBondStateChangedCallback");
 362     // this callback is called by CaLeClientInterface
 363     // only when bond state is changed from BOND_BONDED to BOND_NONE
 364     OIC_LOG(DEBUG, TAG, "bond state is changed from BOND_BONDED to BOND_NONE");
 365     VERIFY_NON_NULL_VOID(env, TAG, "env");
 366     VERIFY_NON_NULL_VOID(obj, TAG, "obj");
 367     VERIFY_NON_NULL_VOID(device, TAG, "device");
 368
 369     // get ble address from Bluetooth Device object
 370     jstring jni_leAddress = CALEClientGetLEAddressFromBTDevice(env, device);
 371     if (!jni_leAddress)
 372     {
 373         OIC_LOG(INFO, TAG, "unbonded : it isn't same device type");
 374         return;
 375     }
 376
 377     char* leAddress = (char*)(*env)->GetStringUTFChars(env, jni_leAddress, NULL);
 378     if (!leAddress)
 379     {
 380         OIC_LOG(ERROR, TAG, "leAddress is null");
 381         return;
 382     }
 383
 384     // if there is no data, CAData will be created.
 385     OIC_LOG_V(DEBUG, TAG, "bond none device : %s", leAddress);
 386
 387     CAResult_t res = CAManagerRemoveACData(env, jni_leAddress);
 388     if (CA_STATUS_OK != res)
 389     {
 390         OIC_LOG(ERROR, TAG, "CAManagerRemoveACData has failed");
 391     }
 392
 393     (*env)->ReleaseStringUTFChars(env, jni_leAddress, leAddress);
 394
 395     if (!CAManagerRemoveConnectedDeviceAddress(env, g_context, jni_leAddress,
 396                                                g_connectedDeviceSet))
 397     {
 398         OIC_LOG(ERROR, TAG, "CAManagerRemoveConnectedDeviceAddress has failed");
 399     }
 400 }
 401
 402 JNIEXPORT void JNICALL
 403 Java_org_iotivity_ca_CaLeClientInterface_caManagerLeGattConnectionStateChangeCB(
 404         JNIEnv *env, jobject obj, jobject gatt, jint status, jint newState)
 405 {
 406     OIC_LOG_V(INFO, TAG, "caManagerLeGattConnectionStateChangeCB - status %d, newState %d",
 407               status, newState);
 408
 409     VERIFY_NON_NULL_VOID(env, TAG, "env");
 410     VERIFY_NON_NULL_VOID(obj, TAG, "obj");
 411     VERIFY_NON_NULL_VOID(gatt, TAG, "gatt");
 412
 413     jint state_connected = CALEGetConstantsValue(env, CLASSPATH_BT_PROFILE, "STATE_CONNECTED");
 414     jint state_disconnected = CALEGetConstantsValue(env, CLASSPATH_BT_PROFILE, "STATE_DISCONNECTED");
 415
 416     jstring jni_address = CALEGetAddressFromGatt(env, gatt);
 417     if (!jni_address)
 418     {
 419         OIC_LOG(ERROR, TAG, "CALEGetAddressFromGatt is null");
 420         return;
 421     }
 422
 423     char* address = (char*)(*env)->GetStringUTFChars(env, jni_address, NULL);
 424     if (!address)
 425     {
 426         OIC_LOG(ERROR, TAG, "address is null");
 427         (*env)->DeleteLocalRef(env, jni_address);
 428         return;
 429     }
 430
 431     OIC_LOG_V(DEBUG, TAG, "caManagerLeGattConnectionStateChangeCB - address [%s]", address);
 432
 433     if (GATT_SUCCESS == status && state_connected == newState) // le connected
 434     {
 435         OIC_LOG(DEBUG, TAG, "LE is connected");
 436
 437         CAResult_t res = CAManagerReadRemoteRssi(env, gatt);
 438         if (CA_STATUS_OK != res)
 439         {
 440             OIC_LOG(ERROR, TAG, "CAManagerReadRemoteRssi has failed");
 441             goto exit;
 442         }
 443     }
 444     else if (state_disconnected == newState)// le disconnected
 445     {
 446         OIC_LOG(DEBUG, TAG, "LE is disconnected");
 447
 448         if (LINK_LOSS == status || REMOTE_DISCONNECT == status)
 449         {
 450             if (!CAManagerIsInACDataList(env, jni_address))
 451             {
 452                 OIC_LOG_V(DEBUG, TAG, "this[%s] is not target address for Auto Connection",
 453                           address);
 454                 goto exit;
 455             }
 456
 457             CAManagerSetAutoConnectingFlag(env, jni_address, false);
 458
 459             CAResult_t res = CAManagerStartAutoConnection(env, jni_address);
 460             if (CA_STATUS_OK != res)
 461             {
 462                 OIC_LOG(ERROR, TAG, "CAManagerStartAutoConnection has failed");
 463                 goto exit;
 464             }
 465         }
 466         else if (ACCEPT_TIMEOUT_EXCEPTION == status)
 467         {
 468             CAManagerProcessRecovery(env, START_RECOVERY);
 469         }
 470     }
 471
 472 exit:
 473     (*env)->ReleaseStringUTFChars(env, jni_address, address);
 474     (*env)->DeleteLocalRef(env, jni_address);
 475 }
 476
 477 /*
 478  * Class:     org_iotivity_ca_jar_caleinterface
 479  * Method:    caManagerLeServicesDiscoveredCallback
 480  * Signature: (Landroid/bluetooth/BluetoothGatt;I)V
 481  */
 482 JNIEXPORT void JNICALL
 483 Java_org_iotivity_ca_CaLeClientInterface_caManagerLeServicesDiscoveredCallback(JNIEnv *env,
 484                                                                                jobject obj,
 485                                                                                jobject gatt,
 486                                                                                jint status)
 487 {
 488     OIC_LOG_V(INFO, TAG, "caManagerLeServicesDiscoveredCallback - status %d", status);
 489     VERIFY_NON_NULL_VOID(env, TAG, "env");
 490     VERIFY_NON_NULL_VOID(obj, TAG, "obj");
 491     VERIFY_NON_NULL_VOID(gatt, TAG, "gatt");
 492
 493     if (GATT_SUCCESS == status)
 494     {
 495         if (!g_connectedDeviceSet)
 496         {
 497             OIC_LOG(ERROR, TAG, "g_connectedDeviceSet is null");
 498             return;
 499         }
 500
 501         jstring jni_address = CALEGetAddressFromGatt(env, gatt);
 502         if (!jni_address)
 503         {
 504             OIC_LOG(ERROR, TAG, "CALEGetAddressFromGatt is null");
 505             return;
 506         }
 507
 508         char* address = (char*)(*env)->GetStringUTFChars(env, jni_address, NULL);
 509         if (!address)
 510         {
 511             OIC_LOG(ERROR, TAG, "address is null");
 512             (*env)->DeleteLocalRef(env, jni_address);
 513             return;
 514         }
 515
 516         OIC_LOG_V(DEBUG, TAG, "ServicesDiscovered device : %s", address);
 517
 518         if (CAManagerIsConnectedDeviceAddress(env, g_context, jni_address, g_connectedDeviceSet))
 519         {
 520             OIC_LOG(INFO, TAG, "AC list - the address will be added to ACData list");
 521             CAManagerAddACData(env, jni_address);
 522             CAManagerSetAutoConnectingFlag(env, jni_address, false);
 523
 524             // next connection will be requested with JNI_TRUE on autoConnect flag
 525             // after first connection
 526             CALEClientSetFlagToState(env, jni_address, CA_LE_AUTO_CONNECT_FLAG, JNI_TRUE);
 527         }
 528         else
 529         {
 530             OIC_LOG(DEBUG, TAG, "AC list - the address is not set to AutoConnect");
 531         }
 532
 533         (*env)->ReleaseStringUTFChars(env, jni_address, address);
 534         (*env)->DeleteLocalRef(env, jni_address);
 535
 536         OIC_LOG(INFO, TAG, "ServicesDiscovery is successful");
 537     }
 538     else
 539     {
 540         OIC_LOG(ERROR, TAG, "ServicesDiscovery has failed");
 541     }
 542 }
 543
 544 /*
 545  * Class:     org_iotivity_ca_jar_caleinterface
 546  * Method:    caManagerLeRemoteRssiCallback
 547  * Signature: (Landroid/bluetooth/BluetoothGatt;I)V
 548  */
 549 JNIEXPORT void JNICALL
 550 Java_org_iotivity_ca_CaLeClientInterface_caManagerLeRemoteRssiCallback(JNIEnv *env,
 551                                                                        jobject obj,
 552                                                                        jobject gatt,
 553                                                                        jint rssi,
 554                                                                        jint status)
 555 {
 556 #ifndef TB_LOG
 557     (void)rssi;
 558     (void)status;
 559 #endif
 560     OIC_LOG_V(DEBUG, TAG, "caManagerLeRemoteRssiCallback - rssi : %d: ", rssi);
 561     OIC_LOG_V(DEBUG, TAG, "caManagerLeRemoteRssiCallback - status : %d: ", status);
 562     VERIFY_NON_NULL_VOID(env, TAG, "env");
 563     VERIFY_NON_NULL_VOID(obj, TAG, "obj");
 564     VERIFY_NON_NULL_VOID(gatt, TAG, "gatt");
 565 }