resource/csdk/connectivity/util/src/camanager/android/caleautoconnector.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 "caleclient.h"
  24 #include "camanagerleutil.h"
  25 #include "camanagerdevice.h"
  26 #include "caleautoconnector.h"
  27 #include "cacommonutil.h"
  28 #include "logger.h"
  29 #include "camutex.h"
  30
  31 #define TAG "OIC_CA_LE_AUTO_CONN"
  32
  33 static const size_t MAX_RETRY_COUNT = 5;
  34 static const size_t TIMEOUT = 1000000;
  35 static const size_t WAITING_TIME = 500000;
  36
  37 static ca_mutex g_connectRetryMutex = NULL;
  38 static ca_cond g_connectRetryCond = NULL;
  39
  40 static ca_mutex g_recoveryMutex = NULL;
  41 static ca_cond g_recoveryCond = NULL;
  42
  43 CAResult_t CAManagerInitLEAutoConnection()
  44 {
  45     if (NULL == g_connectRetryMutex)
  46     {
  47         g_connectRetryMutex = ca_mutex_new();
  48         if (NULL == g_connectRetryMutex)
  49         {
  50             OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
  51             return CA_STATUS_FAILED;
  52         }
  53     }
  54
  55     if (NULL == g_connectRetryCond)
  56     {
  57         g_connectRetryCond = ca_cond_new();
  58         if (NULL == g_connectRetryCond)
  59         {
  60             OIC_LOG(ERROR, TAG, "ca_cond_new has failed");
  61             return CA_STATUS_FAILED;
  62         }
  63     }
  64
  65     if (NULL == g_recoveryMutex)
  66     {
  67         g_recoveryMutex = ca_mutex_new();
  68         if (NULL == g_recoveryMutex)
  69         {
  70             OIC_LOG(ERROR, TAG, "ca_mutex_new has failed");
  71             return CA_STATUS_FAILED;
  72         }
  73     }
  74
  75     if (NULL == g_recoveryCond)
  76     {
  77         g_recoveryCond = ca_cond_new();
  78         if (NULL == g_recoveryCond)
  79         {
  80             OIC_LOG(ERROR, TAG, "ca_cond_new has failed");
  81             return CA_STATUS_FAILED;
  82         }
  83     }
  84
  85     return CA_STATUS_OK;
  86 }
  87
  88 void CAManagerTerminateLEAutoConnection()
  89 {
  90     if (g_connectRetryCond)
  91     {
  92         ca_cond_signal(g_connectRetryCond);
  93         ca_cond_free(g_connectRetryCond);
  94         g_connectRetryCond = NULL;
  95     }
  96
  97     if (g_connectRetryMutex)
  98     {
  99         ca_mutex_free(g_connectRetryMutex);
 100         g_connectRetryMutex = NULL;
 101     }
 102
 103     if (g_recoveryCond)
 104     {
 105         ca_cond_signal(g_recoveryCond);
 106         ca_cond_free(g_recoveryCond);
 107         g_recoveryCond = NULL;
 108     }
 109
 110     if (g_recoveryMutex)
 111     {
 112         ca_mutex_free(g_recoveryMutex);
 113         g_recoveryMutex = NULL;
 114     }
 115 }
 116
 117 CAResult_t CAManagerStartAutoConnection(JNIEnv *env, jstring remote_le_address)
 118 {
 119     VERIFY_NON_NULL(env, TAG, "env is null");
 120     VERIFY_NON_NULL(remote_le_address, TAG, "remote_le_address is null");
 121
 122     OIC_LOG(DEBUG, TAG, "IN - CAManagerStartAutoConnection");
 123
 124     if (true == CAManagerGetAutoConnectionFlag(env, remote_le_address))
 125     {
 126         OIC_LOG(INFO, TAG, "auto connecting.");
 127         return CA_STATUS_FAILED;
 128     }
 129
 130     ca_mutex_lock(g_connectRetryMutex);
 131
 132     for (size_t retry_cnt = 0 ; retry_cnt < MAX_RETRY_COUNT ; retry_cnt++)
 133     {
 134         // there is retry logic 5 times when connectGatt call has failed
 135         // because BT adapter might be not ready yet.
 136         if (NULL == CAManagerConnectGatt(env, remote_le_address))
 137         {
 138             OIC_LOG_V(INFO, TAG, "retry will be started at least %d times after delay 1sec",
 139                       MAX_RETRY_COUNT - retry_cnt - 1);
 140             if (ca_cond_wait_for(g_connectRetryCond, g_connectRetryMutex, TIMEOUT) == 0)
 141             {
 142                 OIC_LOG(INFO, TAG, "request to connect gatt was canceled");
 143                 ca_mutex_unlock(g_connectRetryMutex);
 144                 return CA_STATUS_OK;
 145             }
 146             // time out. retry connection
 147         }
 148         else
 149         {
 150             OIC_LOG(INFO, TAG, "ConnectGatt has called successfully");
 151             break;
 152         }
 153     }
 154     ca_mutex_unlock(g_connectRetryMutex);
 155     OIC_LOG(DEBUG, TAG, "OUT - CAManagerStartAutoConnection");
 156     return CA_STATUS_OK;
 157 }
 158
 159 jobject CAManagerConnectGatt(JNIEnv *env, jstring remote_le_address)
 160 {
 161     VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
 162     VERIFY_NON_NULL_RET(remote_le_address, TAG, "remote_le_address", NULL);
 163
 164     OIC_LOG(DEBUG, TAG, "IN - CAManagerConnectGatt");
 165
 166     jobject jni_bluetooth = CAManagerGetRemoteDevice(env, remote_le_address);
 167     if (!jni_bluetooth)
 168     {
 169         OIC_LOG(ERROR, TAG, "jni_bluetooth is null");
 170         return NULL;
 171     }
 172
 173     if (!CAManagerIsDeviceBonded(env, jni_bluetooth))
 174     {
 175         OIC_LOG(INFO, TAG, "device is BONDED_NONE");
 176     }
 177
 178     // request to connection with AutoConnection Flag
 179     OIC_LOG(INFO, TAG, "request to gatt connection for auto connection");
 180     jobject newGatt = (jobject)CALEClientConnect(env, jni_bluetooth, JNI_TRUE);
 181     if (NULL == newGatt)
 182     {
 183         OIC_LOG(INFO, TAG, "re-connection will be started");
 184         return NULL;
 185     }
 186
 187     // set flag auto connection is requested.
 188     CAManagerSetAutoConnectionFlag(env, remote_le_address, true);
 189
 190     OIC_LOG(DEBUG, TAG, "OUT - CAManagerConnectGatt");
 191     return newGatt;
 192 }
 193
 194 CAResult_t CAManagerProcessRecovery(JNIEnv *env, uint16_t adapter_state)
 195 {
 196     VERIFY_NON_NULL(env, TAG, "env");
 197     OIC_LOG(DEBUG, TAG, "IN - CAManagerProcessRecovery");
 198
 199     ca_mutex_lock(g_recoveryMutex);
 200     CAResult_t res = CA_STATUS_OK;
 201
 202     switch(adapter_state)
 203     {
 204         case STATE_OFF:
 205             // adapter will be enabled automatically after WAITING_TIME.
 206             if (ca_cond_wait_for(g_recoveryCond, g_recoveryMutex, WAITING_TIME) == 0)
 207             {
 208                 OIC_LOG(INFO, TAG, "BT recovery was canceled");
 209             }
 210             else
 211             {
 212                 // enabled
 213                 if (!CAManagerControlAdapter(env, true))
 214                 {
 215                     OIC_LOG(ERROR, TAG, "BT recovery(enable) failure");
 216                     res = CA_STATUS_FAILED;
 217                 }
 218             }
 219             CAManagerSetBTRecovery(false);
 220             break;
 221         case START_RECOVERY:
 222             if (!CAManagerControlAdapter(env, false))
 223             {
 224                 OIC_LOG(ERROR, TAG, "BT recovery(disable) failure");
 225                 res = CA_STATUS_FAILED;
 226             }
 227             CAManagerSetBTRecovery(true);
 228             break;
 229         default:
 230             break;
 231     }
 232
 233     ca_mutex_unlock(g_recoveryMutex);
 234     OIC_LOG(DEBUG, TAG, "OUT - CAManagerProcessRecovery");
 235
 236     return res;
 237 }