resource/csdk/connectivity/util/src/camanager/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 "camutex.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 ca_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     ca_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     ca_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 = ca_mutex_new();
  94         if (NULL == g_deviceACDataListMutex)
  95         {
  96             OIC_LOG(ERROR, TAG, "ca_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         ca_mutex_free(g_deviceACDataListMutex);
 108         g_deviceACDataListMutex = NULL;
 109     }
 110 }
 111
 112 static CAManagerACData_t *CAManagerCreateACData(jstring jaddress)
 113 {
 114     OIC_LOG(DEBUG, TAG, "IN - CAManagerCreateACData");
 115     VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", NULL);
 116
 117     // create AC data
 118     CAManagerACData_t *data = (CAManagerACData_t *) OICCalloc(1, sizeof(*data));
 119     if (!data)
 120     {
 121         OIC_LOG(ERROR, TAG, "memory alloc has failed");
 122         return NULL;
 123     }
 124
 125     data->address = jaddress;
 126     data->isAutoConnecting = false;
 127
 128     OIC_LOG(DEBUG, TAG, "OUT - CAManagerCreateACData");
 129     return data;
 130 }
 131
 132 bool CAManagerIsInACDataList(JNIEnv *env, jstring jaddress)
 133 {
 134     VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
 135     VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", false);
 136
 137     ca_mutex_lock(g_deviceACDataListMutex);
 138
 139     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 140     if (!address)
 141     {
 142         OIC_LOG(ERROR, TAG, "address is null");
 143         ca_mutex_unlock(g_deviceACDataListMutex);
 144         return false;
 145     }
 146
 147     size_t length = u_arraylist_length(g_deviceACDataList);
 148     for (size_t idx = 0; idx < length; idx++)
 149     {
 150         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 151                                                                            idx);
 152         if (!curData)
 153         {
 154             OIC_LOG(ERROR, TAG, "curData is null");
 155             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 156             ca_mutex_unlock(g_deviceACDataListMutex);
 157             return false;
 158         }
 159
 160         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 161         if (!setAddress)
 162         {
 163             OIC_LOG(ERROR, TAG, "address is null");
 164             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 165             ca_mutex_unlock(g_deviceACDataListMutex);
 166             return false;
 167         }
 168
 169         if (!strcmp(setAddress, address))
 170         {
 171             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 172             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 173             ca_mutex_unlock(g_deviceACDataListMutex);
 174             return true;
 175         }
 176         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 177     }
 178
 179     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 180     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 181     ca_mutex_unlock(g_deviceACDataListMutex);
 182
 183     return false;
 184 }
 185
 186 void CAManagerAddACData(JNIEnv *env, jstring jaddress)
 187 {
 188     OIC_LOG(DEBUG, TAG, "IN - CAManagerAddACData");
 189
 190     VERIFY_NON_NULL_VOID(env, TAG, "env");
 191     VERIFY_NON_NULL_VOID(jaddress, TAG, "jaddress");
 192
 193     if(!CAManagerIsInACDataList(env, jaddress))
 194     {
 195         OIC_LOG(DEBUG, TAG, "new ACdata will be added in List");
 196         // add CAManagerACData
 197         jobject gaddress = (*env)->NewGlobalRef(env, jaddress);
 198
 199         CAManagerACData_t *data = CAManagerCreateACData(gaddress);
 200
 201         ca_mutex_lock(g_deviceACDataListMutex);
 202         u_arraylist_add(g_deviceACDataList, data);
 203         ca_mutex_unlock(g_deviceACDataListMutex);
 204     }
 205     else
 206     {
 207         OIC_LOG(DEBUG, TAG, "the address is already in ACData list");
 208     }
 209
 210     OIC_LOG(DEBUG, TAG, "OUT - CAManagerAddACData");
 211 }
 212
 213 CAResult_t CAManagerRemoveACData(JNIEnv *env, jstring jaddress)
 214 {
 215     OIC_LOG(DEBUG, TAG, "CAManagerRemoveACData");
 216     VERIFY_NON_NULL(env, TAG, "env");
 217     VERIFY_NON_NULL(jaddress, TAG, "jaddress");
 218
 219     ca_mutex_lock(g_deviceACDataListMutex);
 220
 221     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 222     if (!address)
 223     {
 224         OIC_LOG(ERROR, TAG, "address is null");
 225         ca_mutex_unlock(g_deviceACDataListMutex);
 226         return CA_STATUS_FAILED;
 227     }
 228
 229     OIC_LOG_V(DEBUG, TAG, "[%s] will be removed", address);
 230
 231     size_t length = u_arraylist_length(g_deviceACDataList);
 232     for (size_t idx = 0; idx < length; idx++)
 233     {
 234         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 235                                                                            idx);
 236         if (!curData)
 237         {
 238             OIC_LOG(ERROR, TAG, "curData is null");
 239             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 240             ca_mutex_unlock(g_deviceACDataListMutex);
 241             return CA_STATUS_FAILED;
 242         }
 243
 244         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 245         if (!setAddress)
 246         {
 247             OIC_LOG(ERROR, TAG, "address is null");
 248             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 249             ca_mutex_unlock(g_deviceACDataListMutex);
 250             return CA_STATUS_FAILED;
 251         }
 252
 253         if (!strcmp(setAddress, address))
 254         {
 255             if (NULL == u_arraylist_remove(g_deviceACDataList, idx))
 256             {
 257                 OIC_LOG(ERROR, TAG, "removal has failed.");
 258                 (*env)->ReleaseStringUTFChars(env, jaddress, address);
 259                 (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 260                 ca_mutex_unlock(g_deviceACDataListMutex);
 261                 return CA_STATUS_FAILED;
 262             }
 263
 264             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 265
 266             if (curData->address)
 267             {
 268                 (*env)->DeleteGlobalRef(env, curData->address);
 269             }
 270
 271             OICFree(curData);
 272             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 273             ca_mutex_unlock(g_deviceACDataListMutex);
 274             OIC_LOG(DEBUG, TAG, "remove done");
 275             return CA_STATUS_OK;
 276         }
 277         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 278     }
 279
 280     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 281     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 282     ca_mutex_unlock(g_deviceACDataListMutex);
 283
 284     return CA_STATUS_OK;
 285 }
 286
 287 CAResult_t CAManagerRemoveAllACData(JNIEnv *env)
 288 {
 289     OIC_LOG(DEBUG, TAG, "IN - CAManagerRemoveAllACData");
 290     VERIFY_NON_NULL(env, TAG, "env");
 291
 292     ca_mutex_lock(g_deviceACDataListMutex);
 293
 294     size_t length = u_arraylist_length(g_deviceACDataList);
 295     for (size_t idx = 0; idx < length; idx++)
 296     {
 297         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 298                                                                            idx);
 299         if (!curData)
 300         {
 301             OIC_LOG(ERROR, TAG, "curData is null");
 302             ca_mutex_unlock(g_deviceACDataListMutex);
 303             return CA_STATUS_FAILED;
 304         }
 305
 306         if (NULL == u_arraylist_remove(g_deviceACDataList, idx))
 307         {
 308             OIC_LOG(ERROR, TAG, "removal has failed.");
 309             ca_mutex_unlock(g_deviceACDataListMutex);
 310             return CA_STATUS_FAILED;
 311         }
 312
 313         if (curData->address)
 314         {
 315             (*env)->DeleteGlobalRef(env, curData->address);
 316         }
 317
 318         OICFree(curData);
 319     }
 320     ca_mutex_unlock(g_deviceACDataListMutex);
 321     OIC_LOG(DEBUG, TAG, "OUT - CAManagerRemoveAllACData");
 322     return CA_STATUS_OK;
 323 }
 324
 325 CAResult_t CAManagerGetAutoConnectingFlag(JNIEnv *env, jstring jaddress, bool *flag)
 326 {
 327     OIC_LOG(DEBUG, TAG, "CAManagerGetAutoConnectingFlag");
 328     VERIFY_NON_NULL(env, TAG, "env");
 329     VERIFY_NON_NULL(jaddress, TAG, "jaddress");
 330
 331     ca_mutex_lock(g_deviceACDataListMutex);
 332
 333     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 334     if (!address)
 335     {
 336         OIC_LOG(ERROR, TAG, "address is null");
 337         ca_mutex_unlock(g_deviceACDataListMutex);
 338         return CA_STATUS_FAILED;
 339     }
 340
 341     size_t length = u_arraylist_length(g_deviceACDataList);
 342     for (size_t idx = 0; idx < length; idx++)
 343     {
 344         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 345                                                                            idx);
 346         if (!curData)
 347         {
 348             OIC_LOG(ERROR, TAG, "curData is null");
 349             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 350             ca_mutex_unlock(g_deviceACDataListMutex);
 351             return CA_STATUS_FAILED;
 352         }
 353
 354         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 355         if (!setAddress)
 356         {
 357             OIC_LOG(ERROR, TAG, "setAddress is null");
 358             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 359             ca_mutex_unlock(g_deviceACDataListMutex);
 360             return CA_STATUS_FAILED;
 361         }
 362
 363         if (!strcmp(setAddress, address))
 364         {
 365             OIC_LOG_V(DEBUG, TAG, "address : [%s], isAutoConnecting : %d", address,
 366                       curData->isAutoConnecting);
 367             *flag = curData->isAutoConnecting;
 368             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 369             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 370             ca_mutex_unlock(g_deviceACDataListMutex);
 371             return CA_STATUS_OK;
 372         }
 373         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 374     }
 375
 376     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 377     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 378     ca_mutex_unlock(g_deviceACDataListMutex);
 379
 380     return CA_STATUS_FAILED;
 381 }
 382
 383 bool CAManagerSetAutoConnectingFlag(JNIEnv *env, jstring jaddress, bool flag)
 384 {
 385     OIC_LOG(DEBUG, TAG, "CAManagerSetAutoConnectingFlag");
 386     VERIFY_NON_NULL_RET(env, TAG, "env", false);
 387     VERIFY_NON_NULL_RET(jaddress, TAG, "jaddress", false);
 388
 389     ca_mutex_lock(g_deviceACDataListMutex);
 390
 391     const char* address = (*env)->GetStringUTFChars(env, jaddress, NULL);
 392     if (!address)
 393     {
 394         OIC_LOG(ERROR, TAG, "address is null");
 395         ca_mutex_unlock(g_deviceACDataListMutex);
 396         return false;
 397     }
 398
 399     size_t length = u_arraylist_length(g_deviceACDataList);
 400     for (size_t idx = 0; idx < length; idx++)
 401     {
 402         CAManagerACData_t *curData = (CAManagerACData_t *) u_arraylist_get(g_deviceACDataList,
 403                                                                            idx);
 404         if (!curData)
 405         {
 406             OIC_LOG(ERROR, TAG, "curData is null");
 407             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 408             ca_mutex_unlock(g_deviceACDataListMutex);
 409             return false;
 410         }
 411
 412         const char* setAddress = (*env)->GetStringUTFChars(env, curData->address, NULL);
 413         if (!setAddress)
 414         {
 415             OIC_LOG(ERROR, TAG, "address is null");
 416             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 417             ca_mutex_unlock(g_deviceACDataListMutex);
 418             return false;
 419         }
 420
 421         if (!strcmp(setAddress, address))
 422         {
 423             OIC_LOG_V(DEBUG, TAG, "isAutoConnecting flag of [%s] is set to %d", address,
 424                       curData->isAutoConnecting);
 425             curData->isAutoConnecting = flag;
 426             (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 427             (*env)->ReleaseStringUTFChars(env, jaddress, address);
 428             ca_mutex_unlock(g_deviceACDataListMutex);
 429             return true;
 430         }
 431         (*env)->ReleaseStringUTFChars(env, curData->address, setAddress);
 432     }
 433
 434     OIC_LOG_V(DEBUG, TAG, "[%s] doesn't exist in list", address);
 435     (*env)->ReleaseStringUTFChars(env, jaddress, address);
 436     ca_mutex_unlock(g_deviceACDataListMutex);
 437
 438     return false;
 439 }
 440
 441 size_t CAManagerGetACDataLength()
 442 {
 443     return u_arraylist_length(g_deviceACDataList);
 444 }
 445
 446 void CAManagerSetBTRecovery(bool flag)
 447 {
 448     g_isBTRecovery = flag;
 449     OIC_LOG_V(DEBUG, TAG, "BT recovery flag is set to %d", g_isBTRecovery);
 450 }
 451
 452 bool CAManagerIsRecoveryFlagSet()
 453 {
 454     return g_isBTRecovery;
 455 }