resource/csdk/connectivity/src/bt_le_adapter/android/caleutils.c

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  ******************************************************************/
  20
  21 #include <jni.h>
  22 #include <stdio.h>
  23 #include <android/log.h>
  24
  25 #include "caleutils.h"
  26 #include "logger.h"
  27 #include "cathreadpool.h"
  28 #include "uarraylist.h"
  29 #include "caadapterutils.h"
  30
  31 #define TAG PCF("OIC_CA_LE_UTILS")
  32
  33 jobject CALEGetUuidFromString(JNIEnv *env, const char* uuid)
  34 {
  35     VERIFY_NON_NULL_RET(uuid, TAG, "uuid is null", NULL);
  36     VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
  37
  38     jclass jni_cid_UUID = (*env)->FindClass(env, "java/util/UUID");
  39     if (!jni_cid_UUID)
  40     {
  41         OIC_LOG(ERROR, TAG, "jni_cid_UUID is not available");
  42         return NULL;
  43     }
  44
  45     jmethodID jni_mid_fromString = (*env)->GetStaticMethodID(env, jni_cid_UUID, "fromString",
  46                                                              "(Ljava/lang/String;)"
  47                                                              "Ljava/util/UUID;");
  48     if (!jni_mid_fromString)
  49     {
  50         OIC_LOG(ERROR, TAG, "jni_mid_fromString is not available");
  51         return NULL;
  52     }
  53
  54     jstring str_uuid = (*env)->NewStringUTF(env, uuid);
  55     if (!str_uuid)
  56     {
  57         OIC_LOG(ERROR, TAG, "str_uuid is not available");
  58         return NULL;
  59     }
  60
  61     jobject jni_obj_uuid = (*env)->CallStaticObjectMethod(env, jni_cid_UUID, jni_mid_fromString,
  62                                                           str_uuid);
  63     if (!jni_obj_uuid)
  64     {
  65         OIC_LOG(ERROR, TAG, "Fail to get jni uuid object");
  66         return NULL;
  67     }
  68
  69     return jni_obj_uuid;
  70 }
  71
  72 jobject CALEGetParcelUuid(JNIEnv *env, jobject uuid)
  73 {
  74     VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
  75     VERIFY_NON_NULL_RET(uuid, TAG, "uuid is null", NULL);
  76
  77     jclass jni_cid_ParcelUuid = (*env)->FindClass(env, "android/os/ParcelUuid");
  78     if (!jni_cid_ParcelUuid)
  79     {
  80         OIC_LOG(ERROR, TAG, "jni_cid_ParcelUuid is not available");
  81         return NULL;
  82     }
  83
  84     jmethodID jni_mid_ParcelUuid = (*env)->GetMethodID(env, jni_cid_ParcelUuid, "<init>",
  85                                                        "(Ljava/util/UUID;)V");
  86     if (!jni_mid_ParcelUuid)
  87     {
  88         OIC_LOG(ERROR, TAG, "jni_mid_ParcelUuid is not available");
  89         return NULL;
  90     }
  91
  92     jobject jni_ParcelUuid = (*env)->NewObject(env, jni_cid_ParcelUuid, jni_mid_ParcelUuid, uuid);
  93     if (!jni_ParcelUuid)
  94     {
  95         OIC_LOG(ERROR, TAG, "Fail to get jni ParcelUuid");
  96         return NULL;
  97     }
  98
  99     return jni_ParcelUuid;
 100 }
 101
 102 bool CALEIsBondedDevice(JNIEnv *env, jobject bluetoothDevice)
 103 {
 104     VERIFY_NON_NULL_RET(env, TAG, "env is null", false);
 105     VERIFY_NON_NULL_RET(bluetoothDevice, TAG, "bluetoothDevice is null", false);
 106
 107     jclass jni_cid_device_list = (*env)->FindClass(env, "android/bluetooth/BluetoothDevice");
 108     if (!jni_cid_device_list)
 109     {
 110         OIC_LOG(ERROR, TAG, "jni_cid_device_list is null");
 111         return false;
 112     }
 113
 114     jmethodID jni_mid_getBondState = (*env)->GetMethodID(env, jni_cid_device_list, "getBondState",
 115                                                          "()I");
 116     if (!jni_mid_getBondState)
 117     {
 118         OIC_LOG(ERROR, TAG, "jni_mid_getBondState is null");
 119         return false;
 120     }
 121
 122     jint jni_bondState = (jint)(*env)->CallIntMethod(env, bluetoothDevice, jni_mid_getBondState);
 123
 124     OIC_LOG_V(DEBUG, TAG, "bond state is %d", jni_bondState);
 125
 126     if (BOND_BONDED == jni_bondState)
 127     {
 128         OIC_LOG(DEBUG, TAG, "remote device is bonded");
 129         return true;
 130     }
 131     else
 132     {
 133         OIC_LOG(DEBUG, TAG, "remote device is not bonded");
 134         return false;
 135     }
 136
 137     return false;
 138 }
 139
 140 jobjectArray CALEGetBondedDevices(JNIEnv *env)
 141 {
 142     VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
 143
 144     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADAPTER);
 145     if (!jni_cid_BTAdapter)
 146     {
 147         OIC_LOG(ERROR, TAG, "getBondedDevices: jni_cid_BTAdapter is null");
 148         return NULL;
 149     }
 150
 151     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 152                                                                     "getDefaultAdapter",
 153                                                                     METHODID_OBJECTNONPARAM);
 154
 155     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 156                                                                jni_mid_getDefaultAdapter);
 157     if (!jni_obj_BTAdapter)
 158     {
 159         OIC_LOG(ERROR, TAG, "getBondedDevices: bluetooth adapter is null");
 160         return NULL;
 161     }
 162
 163     // Get a list of currently paired devices
 164     jmethodID jni_mid_getBondedDevices = (*env)->GetMethodID(env, jni_cid_BTAdapter,
 165                                                              "getBondedDevices",
 166                                                              "()Ljava/util/Set;");
 167     if (!jni_mid_getBondedDevices)
 168     {
 169         OIC_LOG(ERROR, TAG, "getBondedDevices: jni_mid_getBondedDevicesr is null");
 170         return NULL;
 171     }
 172
 173     jobject jni_obj_setPairedDevices = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
 174                                                                 jni_mid_getBondedDevices);
 175     if (!jni_obj_setPairedDevices)
 176     {
 177         OIC_LOG(ERROR, TAG, "getBondedDevices: jni_obj_setPairedDevices is null");
 178         return NULL;
 179     }
 180
 181     jclass jni_cid_Set = (*env)->FindClass(env, "java/util/Set");
 182     if (!jni_cid_Set)
 183     {
 184         OIC_LOG(ERROR, TAG, "getBondedDevices : jni_cid_Set is null");
 185         return NULL;
 186     }
 187
 188     jmethodID jni_mid_toArray = (*env)->GetMethodID(env, jni_cid_Set, "toArray",
 189                                                     "()[Ljava/lang/Object;");
 190     if (!jni_mid_toArray)
 191     {
 192         OIC_LOG(ERROR, TAG, "getBondedDevices: jni_mid_toArray is null");
 193         return NULL;
 194     }
 195
 196     jobjectArray jni_arrayPairedDevices = (jobjectArray)(
 197             (*env)->CallObjectMethod(env, jni_obj_setPairedDevices, jni_mid_toArray));
 198     if (!jni_arrayPairedDevices)
 199     {
 200         OIC_LOG(ERROR, TAG, "getBondedDevices: jni_arrayPairedDevices is null");
 201         return NULL;
 202     }
 203
 204     return jni_arrayPairedDevices;
 205 }
 206
 207 jint CALEGetBTStateOnInfo(JNIEnv *env)
 208 {
 209     VERIFY_NON_NULL_RET(env, TAG, "env is null", -1);
 210
 211     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADAPTER);
 212     if (!jni_cid_BTAdapter)
 213     {
 214         OIC_LOG(ERROR, TAG, "getBTStateOnInfo: jni_cid_BTAdapter is null");
 215         return -1;
 216     }
 217
 218     jfieldID jni_fid_stateon = (*env)->GetStaticFieldID(env, jni_cid_BTAdapter, "STATE_ON", "I");
 219     if (!jni_fid_stateon)
 220     {
 221         OIC_LOG(ERROR, TAG, "get_field_state is not available");
 222         return -1;
 223     }
 224
 225     jint jni_int_val = (*env)->GetStaticIntField(env, jni_cid_BTAdapter, jni_fid_stateon);
 226     OIC_LOG_V(DEBUG, TAG, "bluetooth.STATE_ON state integer value : %d", jni_int_val);
 227
 228     return jni_int_val;
 229 }
 230
 231 CAResult_t CALECheckPlatformVersion(JNIEnv *env, uint16_t level)
 232 {
 233     jint jni_int_sdk = CALEGetBuildVersion(env);
 234     if (jni_int_sdk < level)
 235     {
 236         OIC_LOG(ERROR, TAG, "it is not supported");
 237         return CA_NOT_SUPPORTED;
 238     }
 239
 240     return CA_STATUS_OK;
 241 }
 242
 243 jint CALEGetBuildVersion(JNIEnv *env)
 244 {
 245     VERIFY_NON_NULL_RET(env, TAG, "env is null", -1);
 246
 247     // VERSION is a nested class within android.os.Build (hence "$" rather than "/")
 248     jclass jni_cls_version = (*env)->FindClass(env, "android/os/Build$VERSION");
 249     if (!jni_cls_version)
 250     {
 251         OIC_LOG(ERROR, TAG, "jni_cls_version is null");
 252         return -1;
 253     }
 254
 255     jfieldID jni_fid_sdk = (*env)->GetStaticFieldID(env, jni_cls_version, "SDK_INT", "I");
 256     if (!jni_fid_sdk)
 257     {
 258         OIC_LOG(ERROR, TAG, "jni_fid_sdk is null");
 259         return -1;
 260     }
 261
 262     jint jni_int_sdk = (*env)->GetStaticIntField(env, jni_cls_version, jni_fid_sdk);
 263     OIC_LOG_V(DEBUG, TAG, "sdk version is %d", jni_int_sdk);
 264
 265     return jni_int_sdk;
 266 }
 267
 268 jint CALEGetBuildVersionCodeForName(JNIEnv *env, const char* versionName)
 269 {
 270     VERIFY_NON_NULL_RET(env, TAG, "env is null", -1);
 271     VERIFY_NON_NULL_RET(versionName, TAG, "versionName is null", -1);
 272
 273     // VERSION is a nested class within android.os.Build (hence "$" rather than "/")
 274     jclass jni_cls_version = (*env)->FindClass(env, "android/os/Build$VERSION_CODES");
 275     if (!jni_cls_version)
 276     {
 277         OIC_LOG(ERROR, TAG, "jni_cls_version is null");
 278         return -1;
 279     }
 280
 281     jfieldID jni_fid_version = (*env)->GetStaticFieldID(env, jni_cls_version, versionName, "I");
 282     if (!jni_fid_version)
 283     {
 284         OIC_LOG(ERROR, TAG, "jni_fid_version is null");
 285         return -1;
 286     }
 287
 288     jint jni_int_version = (*env)->GetStaticIntField(env, jni_cls_version, jni_fid_version);
 289     OIC_LOG_V(DEBUG, TAG, "version [%s] is %d",versionName, jni_int_version);
 290
 291     return jni_int_version;
 292 }
 293
 294 jboolean CALEIsEnableBTAdapter(JNIEnv *env)
 295 {
 296     VERIFY_NON_NULL_RET(env, TAG, "env is null", JNI_FALSE);
 297
 298     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADAPTER);
 299     if (!jni_cid_BTAdapter)
 300     {
 301         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter: jni_cid_BTAdapter is null");
 302         return JNI_FALSE;
 303     }
 304
 305     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 306                                                                     "getDefaultAdapter",
 307                                                                     METHODID_OBJECTNONPARAM);
 308     if (!jni_mid_getDefaultAdapter)
 309     {
 310         OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
 311         return JNI_FALSE;
 312     }
 313
 314     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 315                                                                jni_mid_getDefaultAdapter);
 316     if (!jni_obj_BTAdapter)
 317     {
 318         OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
 319         return JNI_FALSE;
 320     }
 321
 322     // isEnable()
 323     jmethodID jni_mid_isEnable = (*env)->GetMethodID(env, jni_cid_BTAdapter, "isEnabled", "()Z");
 324     if (!jni_mid_isEnable)
 325     {
 326         OIC_LOG(ERROR, TAG, "jni_mid_isEnable is null");
 327         return JNI_FALSE;
 328     }
 329
 330     jboolean jni_isEnable = (*env)->CallBooleanMethod(env, jni_obj_BTAdapter, jni_mid_isEnable);
 331     OIC_LOG_V(DEBUG, TAG, "adapter state is %d", jni_isEnable);
 332
 333     return jni_isEnable;
 334 }
 335
 336 jstring CALEGetAddressFromBTDevice(JNIEnv *env, jobject bluetoothDevice)
 337 {
 338     VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
 339     VERIFY_NON_NULL_RET(bluetoothDevice, TAG, "bluetoothDevice is null", NULL);
 340
 341     jclass jni_cid_device_list = (*env)->FindClass(env, "android/bluetooth/BluetoothDevice");
 342     if (!jni_cid_device_list)
 343     {
 344         OIC_LOG(ERROR, TAG, "jni_cid_device_list is null");
 345         return NULL;
 346     }
 347
 348     jmethodID jni_mid_getAddress = (*env)->GetMethodID(env, jni_cid_device_list, "getAddress",
 349                                                        "()Ljava/lang/String;");
 350     if (!jni_mid_getAddress)
 351     {
 352         OIC_LOG(ERROR, TAG, "jni_mid_getAddress is null");
 353         return NULL;
 354     }
 355
 356     jstring jni_address = (jstring)(*env)->CallObjectMethod(env, bluetoothDevice,
 357                                                             jni_mid_getAddress);
 358     if (!jni_address)
 359     {
 360         OIC_LOG(ERROR, TAG, "jni_address is null");
 361         return NULL;
 362     }
 363
 364     return jni_address;
 365 }
 366
 367 jint CALEGetConstantsValue(JNIEnv *env, const char* classType, const char* name)
 368 {
 369     OIC_LOG(DEBUG, TAG, "CALEGetConstantsValue");
 370
 371     VERIFY_NON_NULL_RET(env, TAG, "env", -1);
 372     VERIFY_NON_NULL_RET(classType, TAG, "classType", -1);
 373     VERIFY_NON_NULL_RET(name, TAG, "name", -1);
 374
 375     jclass jni_cid = (*env)->FindClass(env, classType);
 376     if (!jni_cid)
 377     {
 378         OIC_LOG(ERROR, TAG, "jni_cid is null");
 379         return -1;
 380     }
 381
 382     jfieldID jni_fieldID = (*env)->GetStaticFieldID(env, jni_cid,
 383                                                     name, "I");
 384     if (!jni_fieldID)
 385     {
 386         OIC_LOG(ERROR, TAG, "jni_fieldID is null");
 387         return -1;
 388     }
 389
 390     return (*env)->GetStaticIntField(env, jni_cid, jni_fieldID);
 391 }
 392
 393 jobject CALEGetRemoteDevice(JNIEnv *env, jstring address)
 394 {
 395     OIC_LOG(DEBUG, TAG, "IN - CALEGetRemoteDevice");
 396
 397     VERIFY_NON_NULL_RET(env, TAG, "env is null", NULL);
 398     VERIFY_NON_NULL_RET(address, TAG, "address is null", NULL);
 399
 400     jclass jni_cid_BTAdapter = (*env)->FindClass(env, CLASSPATH_BT_ADAPTER);
 401     if (!jni_cid_BTAdapter)
 402     {
 403         OIC_LOG(ERROR, TAG, "jni_cid_BTAdapter is null");
 404         return NULL;
 405     }
 406
 407     // get remote bt adapter method
 408     jmethodID jni_mid_getDefaultAdapter = (*env)->GetStaticMethodID(env, jni_cid_BTAdapter,
 409                                                                     "getDefaultAdapter",
 410                                                                     METHODID_OBJECTNONPARAM);
 411     if (!jni_mid_getDefaultAdapter)
 412     {
 413         OIC_LOG(ERROR, TAG, "jni_mid_getDefaultAdapter is null");
 414         return NULL;
 415     }
 416
 417     // gat bt adapter object
 418     jobject jni_obj_BTAdapter = (*env)->CallStaticObjectMethod(env, jni_cid_BTAdapter,
 419                                                                jni_mid_getDefaultAdapter);
 420     if (!jni_obj_BTAdapter)
 421     {
 422         OIC_LOG(ERROR, TAG, "jni_obj_BTAdapter is null");
 423         return NULL;
 424     }
 425
 426     jmethodID jni_mid_getRemoteDevice = (*env)->GetMethodID(env, jni_cid_BTAdapter,
 427                                                             "getRemoteDevice",
 428                                                             METHODID_BT_REMOTE_DEVICE);
 429     if (!jni_mid_getRemoteDevice)
 430     {
 431         OIC_LOG(ERROR, TAG, "jni_mid_getRemoteDevice is null");
 432         return NULL;
 433     }
 434
 435     jobject jni_obj_device = (*env)->CallObjectMethod(env, jni_obj_BTAdapter,
 436                                                       jni_mid_getRemoteDevice,
 437                                                       address);
 438     if (!jni_obj_device)
 439     {
 440         OIC_LOG(ERROR, TAG, "jni_obj_device is null");
 441         return NULL;
 442     }
 443
 444     OIC_LOG(DEBUG, TAG, "OUT - CALEGetRemoteDevice");
 445     return jni_obj_device;
 446 }