resource/csdk/connectivity/util/src/camanager/bt_le_manager/android/camanagerdevice.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 "cacommon.h"
  23 #include "logger.h"
  24 #include "cacommonutil.h"
  25 #include "camanagerleutil.h"
  26 #include "uarraylist.h"
  27 #include "octhread.h"
  28 #include "camanagerdevice.h"
  29 #include "oic_malloc.h"
  30
  31 #define TAG "OIC_CA_MANAGER_DEVICE"
  32
  33 static u_arraylist_t *g_deviceACDataList = NULL;
  34 static oc_mutex g_deviceACDataListMutex = NULL;
  35 static bool g_isBTRecovery = false;
  36
  37 jstring CAManagerGetLEAddressFromACData(JNIEnv *env, size_t idx)
  38 {
  39     OIC_LOG_V(DEBUG, TAG, "CAManagerGetLEAddressFromACData (idx : %d)", idx);
  40     if (idx <= u_arraylist_length(g_deviceACDataList))
  41     {
  42         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(
  43                 g_deviceACDataList, idx);
  44         if (!curData)
  45         {
  46             OIC_LOG(ERROR, TAG, "curData is null");
  47             return NULL;
  48         }
  49
  50         const char* address = (*env)->GetStringUTFChars(env, curData->address, NULL);
  51         if (!address)
  52         {
  53             OIC_LOG(ERROR, TAG, "address is null");
  54             return NULL;
  55         }
  56         OIC_LOG_V(INFO, TAG, "found target address : %s", address);
  57         (*env)->ReleaseStringUTFChars(env, curData->address, address);
  58
  59         return curData->address;
  60     }
  61     OIC_LOG(DEBUG, TAG, "idx is greater than the length of ACDataList");
  62     return NULL;
  63 }
  64
  65 void CAManagerCreateACDataList()
  66 {
  67     OIC_LOG(DEBUG, TAG, "CAManagerCreateACDataList");
  68
  69     oc_mutex_lock(g_deviceACDataListMutex);
  70     if (NULL == g_deviceACDataList)
  71     {
  72         OIC_LOG(DEBUG, TAG, "Create AC Data list");
  73         g_deviceACDataList = u_arraylist_create();
  74     }
  75     oc_mutex_unlock(g_deviceACDataListMutex);
  76 }
  77
  78 void CAManagerDestroyACDataList()
  79 {
  80     OIC_LOG(DEBUG, TAG, "CAManagerDestroyACDataList");
  81     if (g_deviceACDataList)
  82     {
  83         OIC_LOG(DEBUG, TAG, "Destroy AC Data list");
  84         u_arraylist_free(&g_deviceACDataList);
  85         g_deviceACDataList = NULL;
  86     }
  87 }
  88
  89 CAResult_t CAManagerInitMutexVaraibles()
  90 {
  91     if (NULL == g_deviceACDataListMutex)
  92     {
  93         g_deviceACDataListMutex = oc_mutex_new();
  94         if (NULL == g_deviceACDataListMutex)
  95         {
  96             OIC_LOG(ERROR, TAG, "oc_mutex_new has failed");
  97             return CA_STATUS_FAILED;
  98         }
  99     }
 100     return CA_STATUS_OK;
 101 }
 102
 103 void CAManagerTerminateMutexVariables()
 104 {
 105     if (g_deviceACDataListMutex)
 106     {
 107         oc_mutex_free(g_deviceACDataListMutex);
 108         g_deviceACDataListMutex = NULL;
 109     }
 110 }
 111
 112 static CAManagerACData_t *CAManagerCreateACData(jstring jaddress)
 113 {
 114     VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", NULL);
 115
 116     // create AC data
 117     CAManagerACData_t *data = (CAManagerACData_t *) OICCalloc(1, sizeof(*data));
 118     if (!data)
 119     {
 120         OIC_LOG(ERROR, TAG, "memory alloc has failed");
 121         return NULL;
 122     }
 123
 124     data->address = jaddress;
 125     data->isAutoConnecting = false;
 126     return data;
 127 }
 128
 129 bool CAManagerIsInACDataList(JNIEnv *env, jstring jaddress)
 130 {
 131     VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
 132     VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", false);
 133
 134     oc_mutex_lock(g_deviceACDataListMutex);
 135
 136     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 137     if (!address)
 138     {
 139         OIC_LOG(ERROR, TAG, "address is null");
 140         oc_mutex_unlock(g_deviceACDataListMutex);
 141         return false;
 142     }
 143
 144     size_t length = u_arraylist_length(g_deviceACDataList);
 145     for (size_t idx = 0; idx < length; idx++)
 146     {
 147         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 148                                                                            idx);
 149         if (!curData)
 150         {
 151             OIC_LOG(ERROR, TAG, "curData is null");
 152             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 153             oc_mutex_unlock(g_deviceACDataListMutex);
 154             return false;
 155         }
 156
 157         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 158         if (!setAddress)
 159         {
 160             OIC_LOG(ERROR, TAG, "address is null");
 161             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 162             oc_mutex_unlock(g_deviceACDataListMutex);
 163             return false;
 164         }
 165
 166         if (!strcmp(setAddress, address))
 167         {
 168             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 169             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 170             oc_mutex_unlock(g_deviceACDataListMutex);
 171             return true;
 172         }
 173         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 174     }
 175
 176     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 177     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 178     oc_mutex_unlock(g_deviceACDataListMutex);
 179
 180     return false;
 181 }
 182
 183 void CAManagerAddACData(JNIEnv *env, jstring jaddress)
 184 {
 185     VERIFY_NON_NULL_VOID(env, TAG, "env");
 186     VERIFY_NON_NULL_VOID(jaddress, TAG, "jaddress");
 187
 188     if(!CAManagerIsInACDataList(env, jaddress))
 189     {
 190         OIC_LOG(DEBUG, TAG, "new ACdata will be added in List");
 191         // add CAManagerACData
 192         jobject gaddress = (*env)->NewGlobalRef(env, jaddress);
 193
 194         CAManagerACData_t *data = CAManagerCreateACData(gaddress);
 195
 196         oc_mutex_lock(g_deviceACDataListMutex);
 197         u_arraylist_add(g_deviceACDataList, data);
 198         oc_mutex_unlock(g_deviceACDataListMutex);
 199     }
 200     else
 201     {
 202         OIC_LOG(DEBUG, TAG, "the address is already in ACData list");
 203     }
 204 }
 205
 206 CAResult_t CAManagerRemoveACData(JNIEnv *env, jstring jaddress)
 207 {
 208     OIC_LOG(DEBUG, TAG, "CAManagerRemoveACData");
 209     VERIFY_NON_NULL(env, TAG, "env");
 210     VERIFY_NON_NULL(jaddress, TAG, "jaddress");
 211
 212     oc_mutex_lock(g_deviceACDataListMutex);
 213
 214     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 215     if (!address)
 216     {
 217         OIC_LOG(ERROR, TAG, "address is null");
 218         oc_mutex_unlock(g_deviceACDataListMutex);
 219         return CA_STATUS_FAILED;
 220     }
 221
 222     OIC_LOG_V(DEBUG, TAG, "[%s] will be removed", address);
 223
 224     size_t length = u_arraylist_length(g_deviceACDataList);
 225     for (size_t idx = 0; idx < length; idx++)
 226     {
 227         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 228                                                                            idx);
 229         if (!curData)
 230         {
 231             OIC_LOG(ERROR, TAG, "curData is null");
 232             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 233             oc_mutex_unlock(g_deviceACDataListMutex);
 234             return CA_STATUS_FAILED;
 235         }
 236
 237         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 238         if (!setAddress)
 239         {
 240             OIC_LOG(ERROR, TAG, "address is null");
 241             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 242             oc_mutex_unlock(g_deviceACDataListMutex);
 243             return CA_STATUS_FAILED;
 244         }
 245
 246         if (!strcmp(setAddress, address))
 247         {
 248             if (NULL == u_arraylist_remove(g_deviceACDataList, idx))
 249             {
 250                 OIC_LOG(ERROR, TAG, "removal has failed.");
 251                 (*env)->ReleaseStringUTFChars(env, jaddress, address);
 252                 (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 253                 oc_mutex_unlock(g_deviceACDataListMutex);
 254                 return CA_STATUS_FAILED;
 255             }
 256
 257             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 258
 259             if (curData->address)
 260             {
 261                 (*env)->DeleteGlobalRef(env, curData->address);
 262             }
 263
 264             OICFree(curData);
 265             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 266             oc_mutex_unlock(g_deviceACDataListMutex);
 267             OIC_LOG(DEBUG, TAG, "remove done");
 268             return CA_STATUS_OK;
 269         }
 270         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 271     }
 272
 273     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 274     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 275     oc_mutex_unlock(g_deviceACDataListMutex);
 276
 277     return CA_STATUS_OK;
 278 }
 279
 280 CAResult_t CAManagerRemoveAllACData(JNIEnv *env)
 281 {
 282     OIC_LOG(DEBUG, TAG, "IN - CAManagerRemoveAllACData");
 283     VERIFY_NON_NULL(env, TAG, "env");
 284
 285     oc_mutex_lock(g_deviceACDataListMutex);
 286
 287     size_t length = u_arraylist_length(g_deviceACDataList);
 288     for (size_t idx = 0; idx < length; idx++)
 289     {
 290         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 291                                                                            idx);
 292         if (!curData)
 293         {
 294             OIC_LOG(ERROR, TAG, "curData is null");
 295             oc_mutex_unlock(g_deviceACDataListMutex);
 296             return CA_STATUS_FAILED;
 297         }
 298
 299         if (NULL == u_arraylist_remove(g_deviceACDataList, idx))
 300         {
 301             OIC_LOG(ERROR, TAG, "removal has failed.");
 302             oc_mutex_unlock(g_deviceACDataListMutex);
 303             return CA_STATUS_FAILED;
 304         }
 305
 306         if (curData->address)
 307         {
 308             (*env)->DeleteGlobalRef(env, curData->address);
 309         }
 310
 311         OICFree(curData);
 312     }
 313     oc_mutex_unlock(g_deviceACDataListMutex);
 314     OIC_LOG(DEBUG, TAG, "OUT - CAManagerRemoveAllACData");
 315     return CA_STATUS_OK;
 316 }
 317
 318 CAResult_t CAManagerGetAutoConnectingFlag(JNIEnv *env, jstring jaddress, bool *flag)
 319 {
 320     OIC_LOG(DEBUG, TAG, "CAManagerGetAutoConnectingFlag");
 321     VERIFY_NON_NULL(env, TAG, "env");
 322     VERIFY_NON_NULL(jaddress, TAG, "jaddress");
 323
 324     oc_mutex_lock(g_deviceACDataListMutex);
 325
 326     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 327     if (!address)
 328     {
 329         OIC_LOG(ERROR, TAG, "address is null");
 330         oc_mutex_unlock(g_deviceACDataListMutex);
 331         return CA_STATUS_FAILED;
 332     }
 333
 334     size_t length = u_arraylist_length(g_deviceACDataList);
 335     for (size_t idx = 0; idx < length; idx++)
 336     {
 337         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 338                                                                            idx);
 339         if (!curData)
 340         {
 341             OIC_LOG(ERROR, TAG, "curData is null");
 342             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 343             oc_mutex_unlock(g_deviceACDataListMutex);
 344             return CA_STATUS_FAILED;
 345         }
 346
 347         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 348         if (!setAddress)
 349         {
 350             OIC_LOG(ERROR, TAG, "setAddress is null");
 351             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 352             oc_mutex_unlock(g_deviceACDataListMutex);
 353             return CA_STATUS_FAILED;
 354         }
 355
 356         if (!strcmp(setAddress, address))
 357         {
 358             OIC_LOG_V(DEBUG, TAG, "address : [%s], isAutoConnecting : %d", address,
 359                       curData->isAutoConnecting);
 360             *flag = curData->isAutoConnecting;
 361             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 362             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 363             oc_mutex_unlock(g_deviceACDataListMutex);
 364             return CA_STATUS_OK;
 365         }
 366         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 367     }
 368
 369     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 370     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 371     oc_mutex_unlock(g_deviceACDataListMutex);
 372
 373     return CA_STATUS_FAILED;
 374 }
 375
 376 bool CAManagerSetAutoConnectingFlag(JNIEnv *env, jstring jaddress, bool flag)
 377 {
 378     OIC_LOG(DEBUG, TAG, "CAManagerSetAutoConnectingFlag");
 379     VERIFY_NON_NULL_RET(env, TAG, "env", false);
 380     VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", false);
 381
 382     oc_mutex_lock(g_deviceACDataListMutex);
 383
 384     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 385     if (!address)
 386     {
 387         OIC_LOG(ERROR, TAG, "address is null");
 388         oc_mutex_unlock(g_deviceACDataListMutex);
 389         return false;
 390     }
 391
 392     size_t length = u_arraylist_length(g_deviceACDataList);
 393     for (size_t idx = 0; idx < length; idx++)
 394     {
 395         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 396                                                                            idx);
 397         if (!curData)
 398         {
 399             OIC_LOG(ERROR, TAG, "curData is null");
 400             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 401             oc_mutex_unlock(g_deviceACDataListMutex);
 402             return false;
 403         }
 404
 405         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 406         if (!setAddress)
 407         {
 408             OIC_LOG(ERROR, TAG, "address is null");
 409             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 410             oc_mutex_unlock(g_deviceACDataListMutex);
 411             return false;
 412         }
 413
 414         if (!strcmp(setAddress, address))
 415         {
 416             OIC_LOG_V(DEBUG, TAG, "isAutoConnecting flag of [%s] is set to %d", address,
 417                       curData->isAutoConnecting);
 418             curData->isAutoConnecting = flag;
 419             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 420             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 421             oc_mutex_unlock(g_deviceACDataListMutex);
 422             return true;
 423         }
 424         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 425     }
 426
 427     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 428     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 429     oc_mutex_unlock(g_deviceACDataListMutex);
 430
 431     return false;
 432 }
 433
 434 size_t CAManagerGetACDataLength()
 435 {
 436     return u_arraylist_length(g_deviceACDataList);
 437 }
 438
 439 void CAManagerSetBTRecovery(bool flag)
 440 {
 441     g_isBTRecovery = flag;
 442     OIC_LOG_V(DEBUG, TAG, "BT recovery flag is set to %d", g_isBTRecovery);
 443 }
 444
 445 bool CAManagerIsRecoveryFlagSet()
 446 {
 447     return g_isBTRecovery;
 448 }