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     ca_mutex_lock(g_connectRetryMutex);
 124
 125     bool isAutoConnecting = false;
 126     if (CA_STATUS_OK != CAManagerGetAutoConnectingFlag(env, remote_le_address, &isAutoConnecting))
 127     {
 128         OIC_LOG(DEBUG, TAG, "CAManagerIsAutoConnecting has failed");
 129         ca_mutex_unlock(g_connectRetryMutex);
 130         return CA_STATUS_FAILED;
 131     }
 132
 133     if (isAutoConnecting)
 134     {
 135         OIC_LOG(INFO, TAG, "connection has been already in progress or completed");
 136         ca_mutex_unlock(g_connectRetryMutex);
 137         return CA_STATUS_FAILED;
 138     }
 139
 140     for (size_t retry_cnt = 0 ; retry_cnt < MAX_RETRY_COUNT ; retry_cnt++)
 141     {
 142         // there is retry logic 5 times when connectGatt call has failed
 143         // because BT adapter might be not ready yet.
 144         if (NULL == CAManagerConnectGatt(env, remote_le_address))
 145         {
 146             OIC_LOG_V(INFO, TAG, "retry will be started at least %d times after delay 1sec",
 147                       MAX_RETRY_COUNT - retry_cnt - 1);
 148             if (ca_cond_wait_for(g_connectRetryCond, g_connectRetryMutex, TIMEOUT) == 0)
 149             {
 150                 ca_mutex_unlock(g_connectRetryMutex);
 151                 OIC_LOG(INFO, TAG, "request to connect gatt was canceled");
 152                 return CA_STATUS_OK;
 153             }
 154             // time out. retry connection
 155         }
 156         else
 157         {
 158             OIC_LOG(INFO, TAG, "ConnectGatt has called successfully");
 159             break;
 160         }
 161     }
 162     ca_mutex_unlock(g_connectRetryMutex);
 163     OIC_LOG(DEBUG, TAG, "OUT - CAManagerStartAutoConnection");
 164     return CA_STATUS_OK;
 165 }
 166
 167 jobject CAManagerConnectGatt(JNIEnv *env, jstring remote_le_address)
 168 {
 169     VERIFY_NON_NULL_RET(env, TAG, "env", NULL);
 170     VERIFY_NON_NULL_RET(remote_le_address, TAG, "remote_le_address", NULL);
 171
 172     OIC_LOG(DEBUG, TAG, "IN - CAManagerConnectGatt");
 173
 174     jobject jni_bluetooth = CAManagerGetRemoteDevice(env, remote_le_address);
 175     if (!jni_bluetooth)
 176     {
 177         OIC_LOG(ERROR, TAG, "jni_bluetooth is null");
 178         return NULL;
 179     }
 180
 181     if (!CAManagerIsDeviceBonded(env, jni_bluetooth))
 182     {
 183         OIC_LOG(INFO, TAG, "device is BONDED_NONE");
 184     }
 185
 186     // request to connection with AutoConnection Flag
 187     OIC_LOG(INFO, TAG, "request gatt connection by CM auto connector");
 188     jobject newGatt = (jobject)CALEClientConnect(env, jni_bluetooth, JNI_TRUE);
 189     if (NULL == newGatt)
 190     {
 191         OIC_LOG(INFO, TAG, "re-connection will be started");
 192         return NULL;
 193     }
 194
 195     // set flag auto connection is requested.
 196     CAManagerSetAutoConnectingFlag(env, remote_le_address, true);
 197
 198     OIC_LOG(DEBUG, TAG, "OUT - CAManagerConnectGatt");
 199     return newGatt;
 200 }
 201
 202 CAResult_t CAManagerProcessRecovery(JNIEnv *env, uint16_t adapter_state)
 203 {
 204     VERIFY_NON_NULL(env, TAG, "env");
 205     OIC_LOG(DEBUG, TAG, "IN - CAManagerProcessRecovery");
 206
 207     ca_mutex_lock(g_recoveryMutex);
 208     CAResult_t res = CA_STATUS_OK;
 209
 210     switch(adapter_state)
 211     {
 212         case STATE_OFF:
 213             // adapter will be enabled automatically after WAITING_TIME.
 214             if (ca_cond_wait_for(g_recoveryCond, g_recoveryMutex, WAITING_TIME) == 0)
 215             {
 216                 OIC_LOG(INFO, TAG, "BT recovery was canceled");
 217             }
 218             else
 219             {
 220                 // enabled
 221                 if (!CAManagerControlAdapter(env, true))
 222                 {
 223                     OIC_LOG(ERROR, TAG, "BT recovery(enable) failure");
 224                     res = CA_STATUS_FAILED;
 225                 }
 226             }
 227             CAManagerSetBTRecovery(false);
 228             break;
 229         case START_RECOVERY:
 230             if (!CAManagerControlAdapter(env, false))
 231             {
 232                 OIC_LOG(ERROR, TAG, "BT recovery(disable) failure");
 233                 res = CA_STATUS_FAILED;
 234             }
 235             CAManagerSetBTRecovery(true);
 236             break;
 237         default:
 238             break;
 239     }
 240
 241     ca_mutex_unlock(g_recoveryMutex);
 242     OIC_LOG(DEBUG, TAG, "OUT - CAManagerProcessRecovery");
 243
 244     return res;
 245 }