1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "softbus_adapter_ble_gatt_client.h"
16 
17 #include "securec.h"
18 #include <stdbool.h>
19 
20 #include "c_header/ohos_bt_def.h"
21 #include "c_header/ohos_bt_gatt_client.h"
22 
23 #include "common_list.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_common.h"
26 #include "softbus_conn_common.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_utils.h"
30 
31 #include "conn_log.h"
32 #include "softbus_type_def.h"
33 
34 #include "adapter_bt_utils.h"
35 #define APP_UUID_LEN 2
36 #define INVALID_ID   (-1)
37 
38 static void GetGattcCallback(int32_t clientId, SoftBusGattcCallback *cb);
39 static int32_t SoftbusGattcAddMacAddrToList(int32_t clientId, const SoftBusBtAddr *addr);
40 static void SoftbusGattcDeleteMacAddrFromList(int32_t clientId);
41 
42 static BtGattClientCallbacks g_btGattClientCallbacks = { 0 };
43 static SoftBusList *g_softBusGattcManager = NULL;
44 static SoftBusList *g_btAddrs = NULL;
45 static SoftBusBleSendSignal g_clientSendSignal = {0};
46 typedef struct {
47     ListNode node;
48     char addr[BT_MAC_LEN];
49     int32_t clientId;
50 } BleConnMac;
51 
GattcConnectionStateChangedCallback(int clientId,int connectionState,int status)52 static void GattcConnectionStateChangedCallback(int clientId, int connectionState, int status)
53 {
54     CONN_LOGI(CONN_BLE, "clientId=%{public}d, state=%{public}d, status=%{public}d", clientId, connectionState, status);
55     if (connectionState != OHOS_STATE_CONNECTED && connectionState != OHOS_STATE_DISCONNECTED) {
56         CONN_LOGI(CONN_BLE, "ignore connection state");
57         return;
58     }
59 
60     SoftBusGattcCallback cb = { 0 };
61     GetGattcCallback(clientId, &cb);
62     if (cb.ConnectionStateCallback == NULL) {
63         CONN_LOGE(CONN_BLE, "get callback failed");
64         return;
65     }
66     cb.ConnectionStateCallback(clientId, connectionState, status);
67 }
68 
GattcConnectParaUpdateCallback(int clientId,int interval,int latency,int timeout,int status)69 static void GattcConnectParaUpdateCallback(int clientId, int interval, int latency, int timeout, int status)
70 {
71     CONN_LOGI(CONN_BLE, "ParaUpdateCallback");
72 }
73 
GattcSearchServiceCompleteCallback(int clientId,int status)74 static void GattcSearchServiceCompleteCallback(int clientId, int status)
75 {
76     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
77     SoftBusGattcCallback cb = { 0 };
78     GetGattcCallback(clientId, &cb);
79     if (cb.ServiceCompleteCallback == NULL) {
80         CONN_LOGE(CONN_BLE, "get callback failed");
81         return;
82     }
83     cb.ServiceCompleteCallback(clientId, status);
84 }
85 
GattcReadCharacteristicCallback(int clientId,BtGattReadData * readData,int status)86 static void GattcReadCharacteristicCallback(int clientId, BtGattReadData *readData, int status)
87 {
88     (void)readData;
89     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
90 }
91 
GattcWriteCharacteristicCallback(int clientId,BtGattCharacteristic * characteristic,int status)92 static void GattcWriteCharacteristicCallback(int clientId, BtGattCharacteristic *characteristic, int status)
93 {
94     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
95     CONN_CHECK_AND_RETURN_LOGE(
96         SoftBusMutexLock(&g_clientSendSignal.g_sendCondLock) == SOFTBUS_OK, CONN_BLE, "lock fail!");
97     g_clientSendSignal.isWriteAvailable = true;
98     (void)SoftBusCondBroadcast(&g_clientSendSignal.g_sendCond);
99     (void)SoftBusMutexUnlock(&g_clientSendSignal.g_sendCondLock);
100     (void)characteristic;
101 }
102 
GattcReadDescriptorCallback(int clientId,BtGattReadData * readData,int status)103 static void GattcReadDescriptorCallback(int clientId, BtGattReadData *readData, int status)
104 {
105     (void)readData;
106     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
107 }
108 
GattcWriteDescriptorCallback(int clientId,BtGattDescriptor * descriptor,int status)109 static void GattcWriteDescriptorCallback(int clientId, BtGattDescriptor *descriptor, int status)
110 {
111     (void)descriptor;
112     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
113 }
114 
GattcConfigureMtuSizeCallback(int clientId,int mtuSize,int status)115 static void GattcConfigureMtuSizeCallback(int clientId, int mtuSize, int status)
116 {
117     CONN_LOGI(CONN_BLE, "clientId=%{public}d, mtusize=%{public}d, status=%{public}d", clientId, mtuSize, status);
118     SoftBusGattcCallback cb = { 0 };
119     GetGattcCallback(clientId, &cb);
120     if (cb.ConfigureMtuSizeCallback == NULL) {
121         CONN_LOGE(CONN_BLE, "get callback failed");
122         return;
123     }
124     cb.ConfigureMtuSizeCallback(clientId, mtuSize, status);
125 }
126 
GattcRegisterNotificationCallback(int clientId,int status)127 static void GattcRegisterNotificationCallback(int clientId, int status)
128 {
129     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
130     SoftBusGattcCallback cb = { 0 };
131     GetGattcCallback(clientId, &cb);
132     if (cb.RegistNotificationCallback == NULL) {
133         CONN_LOGE(CONN_BLE, "get callback failed");
134         return;
135     }
136     cb.RegistNotificationCallback(clientId, status);
137 }
138 
GattcNotificationCallback(int clientId,BtGattReadData * notifyData,int status)139 static void GattcNotificationCallback(int clientId, BtGattReadData *notifyData, int status)
140 {
141     CONN_LOGI(CONN_BLE, "clientId=%{public}d, status=%{public}d", clientId, status);
142     if (notifyData == NULL) {
143         return;
144     }
145     SoftBusGattcNotify notify;
146     notify.dataLen = notifyData->dataLen;
147     notify.charaUuid.uuidLen = notifyData->attribute.characteristic.characteristicUuid.uuidLen;
148     notify.data = notifyData->data;
149     notify.charaUuid.uuid = notifyData->attribute.characteristic.characteristicUuid.uuid;
150 
151     SoftBusGattcCallback cb = { 0 };
152     GetGattcCallback(clientId, &cb);
153     if (cb.NotificationReceiveCallback == NULL) {
154         CONN_LOGE(CONN_BLE, "get callback failed");
155         return;
156     }
157     cb.NotificationReceiveCallback(clientId, &notify, status);
158 }
159 
SoftbusGattcRegisterCallback(SoftBusGattcCallback * cb,int32_t clientId)160 int32_t SoftbusGattcRegisterCallback(SoftBusGattcCallback *cb, int32_t clientId)
161 {
162     CONN_CHECK_AND_RETURN_RET_LOGE(cb != NULL, SOFTBUS_INVALID_PARAM, CONN_BLE, "cb is null");
163     CONN_CHECK_AND_RETURN_RET_LOGE(cb->ConnectionStateCallback != NULL, SOFTBUS_INVALID_PARAM, CONN_BLE,
164         "ConnectionStateCallback is null");
165     CONN_CHECK_AND_RETURN_RET_LOGE(cb->ConfigureMtuSizeCallback != NULL, SOFTBUS_INVALID_PARAM, CONN_BLE,
166         "ConfigureMtuSizeCallback is null");
167     CONN_CHECK_AND_RETURN_RET_LOGE(cb->NotificationReceiveCallback != NULL, SOFTBUS_INVALID_PARAM, CONN_BLE,
168         "NotificationReceiveCallback is null");
169     CONN_CHECK_AND_RETURN_RET_LOGE(cb->RegistNotificationCallback != NULL, SOFTBUS_INVALID_PARAM, CONN_BLE,
170         "RegistNotificationCallback is null");
171     CONN_CHECK_AND_RETURN_RET_LOGE(cb->ServiceCompleteCallback != NULL, SOFTBUS_INVALID_PARAM, CONN_BLE,
172         "ServiceCompleteCallback is null");
173     CONN_CHECK_AND_RETURN_RET_LOGE(clientId >= 0, SOFTBUS_INVALID_PARAM, CONN_BLE, "clientId < 0");
174     CONN_CHECK_AND_RETURN_RET_LOGE(g_softBusGattcManager != NULL, SOFTBUS_INVALID_PARAM,
175         CONN_BLE, "GattcManager is null");
176 
177     SoftBusGattcManager *gattcManager = (SoftBusGattcManager *)SoftBusCalloc(sizeof(SoftBusGattcManager));
178     if (gattcManager == NULL) {
179         CONN_LOGE(CONN_BLE, "calloc failed");
180         return SOFTBUS_MALLOC_ERR;
181     }
182 
183     gattcManager->callback = *cb;
184     gattcManager->clientId = clientId;
185     ListInit(&gattcManager->node);
186     if (SoftBusMutexLock(&g_softBusGattcManager->lock) != SOFTBUS_OK) {
187         SoftBusFree(gattcManager);
188         CONN_LOGE(CONN_BLE, "try to lock failed");
189         return SOFTBUS_LOCK_ERR;
190     }
191     ListAdd(&g_softBusGattcManager->list, &gattcManager->node);
192     (void)SoftBusMutexUnlock(&g_softBusGattcManager->lock);
193     CONN_LOGI(CONN_BLE, "clientId=%{public}d", gattcManager->clientId);
194     return SOFTBUS_OK;
195 }
196 
GetGattcCallback(int32_t clientId,SoftBusGattcCallback * cb)197 static void GetGattcCallback(int32_t clientId, SoftBusGattcCallback *cb)
198 {
199     CONN_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_softBusGattcManager->lock) == SOFTBUS_OK,
200         CONN_BLE, "try to lock failed, clientId=%{public}d", clientId);
201     SoftBusGattcManager *it = NULL;
202     LIST_FOR_EACH_ENTRY(it, &g_softBusGattcManager->list, SoftBusGattcManager, node) {
203         if (it->clientId == clientId) {
204             *cb = it->callback;
205             break;
206         }
207     }
208 
209     (void)SoftBusMutexUnlock(&g_softBusGattcManager->lock);
210 }
211 
SoftbusGattcRegister(void)212 int32_t SoftbusGattcRegister(void)
213 {
214     BtUuid appId;
215     char uuid[APP_UUID_LEN] = { 0xEE, 0xFD };
216     appId.uuid = uuid;
217     appId.uuidLen = APP_UUID_LEN;
218     int32_t clientId = BleGattcRegister(appId);
219     if (clientId <= 0) {
220         CONN_LOGE(CONN_BLE, "BleGattcRegister error");
221         return INVALID_ID;
222     }
223     CONN_LOGI(CONN_BLE, "clientId=%{public}d", clientId);
224     return clientId;
225 }
226 
SoftbusGattcUnRegister(int32_t clientId)227 int32_t SoftbusGattcUnRegister(int32_t clientId)
228 {
229     CONN_LOGI(CONN_BLE, "clientId=%{public}d", clientId);
230     int32_t ret = SOFTBUS_OK;
231     if (BleGattcUnRegister(clientId) != SOFTBUS_OK) {
232         CONN_LOGE(CONN_BLE, "BleGattcUnRegister error");
233         ret = SOFTBUS_GATTC_INTERFACE_FAILED;
234     }
235     CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_softBusGattcManager->lock) == SOFTBUS_OK,
236         SOFTBUS_LOCK_ERR, CONN_BLE, "try to lock failed, clientId=%{public}d", clientId);
237     SoftBusGattcManager *it = NULL;
238     SoftBusGattcManager *next = NULL;
239     LIST_FOR_EACH_ENTRY_SAFE(it, next, &g_softBusGattcManager->list, SoftBusGattcManager, node) {
240         if (it->clientId == clientId) {
241             ListDelete(&it->node);
242             SoftBusFree(it);
243             break;
244         }
245     }
246     (void)SoftBusMutexUnlock(&g_softBusGattcManager->lock);
247     SoftbusGattcDeleteMacAddrFromList(clientId);
248     return ret;
249 }
250 
SoftbusGattcCheckExistConnectionByAddr(const SoftBusBtAddr * btAddr)251 bool SoftbusGattcCheckExistConnectionByAddr(const SoftBusBtAddr *btAddr)
252 {
253     CONN_CHECK_AND_RETURN_RET_LOGE(btAddr != NULL, false, CONN_BLE, "btAddr is NULL");
254     bool isExist = false;
255     char macStr[BT_MAC_LEN] = {0};
256     if (ConvertBtMacToStr(macStr, BT_MAC_LEN, btAddr->addr, sizeof(btAddr->addr)) != SOFTBUS_OK) {
257         CONN_LOGE(CONN_BLE, "convert bt mac to str fail!");
258         return isExist;
259     }
260     CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_btAddrs->lock) == SOFTBUS_OK,
261         false, CONN_BLE, "try to lock failed");
262     BleConnMac *it = NULL;
263     BleConnMac *next = NULL;
264     LIST_FOR_EACH_ENTRY_SAFE(it, next, &g_btAddrs->list, BleConnMac, node) {
265         if (StrCmpIgnoreCase((const char *)it->addr, (const char *)macStr) == 0) {
266             char anomizeAddress[BT_MAC_LEN] = {0};
267             ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, macStr, BT_MAC_LEN);
268             CONN_LOGE(CONN_BLE, "connection exist, addr=%{public}s", anomizeAddress);
269             isExist = true;
270             break;
271         }
272     }
273     (void)SoftBusMutexUnlock(&g_btAddrs->lock);
274     return isExist;
275 }
276 
SoftbusGattcAddMacAddrToList(int32_t clientId,const SoftBusBtAddr * addr)277 static int32_t SoftbusGattcAddMacAddrToList(int32_t clientId, const SoftBusBtAddr *addr)
278 {
279     BleConnMac *bleConnAddr = (BleConnMac *)SoftBusCalloc(sizeof(BleConnMac));
280     CONN_CHECK_AND_RETURN_RET_LOGE(bleConnAddr != NULL, SOFTBUS_MALLOC_ERR, CONN_BLE,
281         "calloc failed, clientId=%{public}d", clientId);
282     ListInit(&bleConnAddr->node);
283     int32_t status = ConvertBtMacToStr(bleConnAddr->addr, BT_MAC_LEN, addr->addr, BT_ADDR_LEN);
284     if (status != SOFTBUS_OK) {
285         SoftBusFree(bleConnAddr);
286         CONN_LOGE(CONN_BLE, "convert bt mac to str fail, error=%{public}d", status);
287         return SOFTBUS_INVALID_PARAM;
288     }
289     bleConnAddr->clientId = clientId;
290 
291     if (SoftBusMutexLock(&g_btAddrs->lock) != SOFTBUS_OK) {
292         SoftBusFree(bleConnAddr);
293         CONN_LOGE(CONN_BLE, "try to lock failed");
294         return SOFTBUS_LOCK_ERR;
295     }
296     ListAdd(&g_btAddrs->list, &bleConnAddr->node);
297     (void)SoftBusMutexUnlock(&g_btAddrs->lock);
298     return SOFTBUS_OK;
299 }
300 
SoftbusGattcDeleteMacAddrFromList(int32_t clientId)301 static void SoftbusGattcDeleteMacAddrFromList(int32_t clientId)
302 {
303     CONN_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_btAddrs->lock) == SOFTBUS_OK,
304         CONN_BLE, "try to lock failed, clientId=%{public}d", clientId);
305     BleConnMac *it = NULL;
306     BleConnMac *next = NULL;
307     LIST_FOR_EACH_ENTRY_SAFE(it, next, &g_btAddrs->list, BleConnMac, node) {
308         if (it->clientId == clientId) {
309             ListDelete(&it->node);
310             SoftBusFree(it);
311             break;
312         }
313     }
314     (void)SoftBusMutexUnlock(&g_btAddrs->lock);
315 }
316 
SoftbusGattcConnect(int32_t clientId,SoftBusBtAddr * addr)317 int32_t SoftbusGattcConnect(int32_t clientId, SoftBusBtAddr *addr)
318 {
319     BdAddr bdAddr = {0};
320     if (memcpy_s(bdAddr.addr, OHOS_BD_ADDR_LEN, addr->addr, BT_ADDR_LEN) != EOK) {
321         CONN_LOGE(CONN_BLE, "SoftbusGattcConnect memcpy error");
322         return SOFTBUS_INVALID_PARAM;
323     }
324     int32_t status = SoftbusGattcAddMacAddrToList(clientId, addr);
325     if (status != SOFTBUS_OK) {
326         // fall-through
327         CONN_LOGW(CONN_BLE, "add mac addr fail, status=%{public}d", status);
328     }
329     status = BleOhosStatusToSoftBus(
330         BleGattcConnect(clientId, &g_btGattClientCallbacks, &bdAddr, false, OHOS_BT_TRANSPORT_TYPE_LE));
331     if (status != SOFTBUS_OK) {
332         CONN_LOGE(CONN_BLE, "status=%{public}d", status);
333         return SOFTBUS_GATTC_INTERFACE_FAILED;
334     }
335 
336     return SOFTBUS_OK;
337 }
338 
SoftbusBleGattcDisconnect(int32_t clientId,bool refreshGatt)339 int32_t SoftbusBleGattcDisconnect(int32_t clientId, bool refreshGatt)
340 {
341     (void)refreshGatt;
342     if (BleGattcDisconnect(clientId) != SOFTBUS_OK) {
343         CONN_LOGE(CONN_BLE, "BleGattcDisconnect error");
344         return SOFTBUS_GATTC_INTERFACE_FAILED;
345     }
346     return SOFTBUS_OK;
347 }
348 
SoftbusGattcSearchServices(int32_t clientId)349 int32_t SoftbusGattcSearchServices(int32_t clientId)
350 {
351     CONN_LOGI(CONN_BLE, "input param clientId = %{public}d", clientId);
352     int32_t status = BleOhosStatusToSoftBus(BleGattcSearchServices(clientId));
353     if (status != SOFTBUS_OK) {
354         CONN_LOGE(CONN_BLE, "status = %{public}d", status);
355         return SOFTBUS_GATTC_INTERFACE_FAILED;
356     }
357     return SOFTBUS_OK;
358 }
359 
SoftbusGattcRefreshServices(int32_t clientId)360 int32_t SoftbusGattcRefreshServices(int32_t clientId)
361 {
362     CONN_LOGI(CONN_BLE, "input param clientId = %{public}d", clientId);
363     return SOFTBUS_NOT_IMPLEMENT;
364 }
365 
SoftbusGattcGetService(int32_t clientId,SoftBusBtUuid * serverUuid)366 int32_t SoftbusGattcGetService(int32_t clientId, SoftBusBtUuid *serverUuid)
367 {
368     if (clientId <= 0) {
369         CONN_LOGE(CONN_BLE, "SoftbusGattcGetService invalid param");
370         return SOFTBUS_INVALID_PARAM;
371     }
372     BtUuid btUuid;
373     btUuid.uuid = serverUuid->uuid;
374     btUuid.uuidLen = serverUuid->uuidLen;
375     if (!BleGattcGetService(clientId, btUuid)) {
376         CONN_LOGE(CONN_BLE, "BleGattcGetService error");
377         return SOFTBUS_GATTC_INTERFACE_FAILED;
378     }
379     return SOFTBUS_OK;
380 }
381 
382 
SoftbusGattcRegisterNotification(int32_t clientId,SoftBusBtUuid * serverUuid,SoftBusBtUuid * charaUuid,SoftBusBtUuid * descriptorUuid)383 int32_t SoftbusGattcRegisterNotification(
384     int32_t clientId, SoftBusBtUuid *serverUuid, SoftBusBtUuid *charaUuid, SoftBusBtUuid *descriptorUuid)
385 {
386     (void)descriptorUuid;
387     BtGattCharacteristic btCharaUuid;
388     btCharaUuid.serviceUuid.uuid = serverUuid->uuid;
389     btCharaUuid.serviceUuid.uuidLen = serverUuid->uuidLen;
390     btCharaUuid.characteristicUuid.uuid = charaUuid->uuid;
391     btCharaUuid.characteristicUuid.uuidLen = charaUuid->uuidLen;
392     int32_t status = BleOhosStatusToSoftBus(BleGattcRegisterNotification(clientId, btCharaUuid, true));
393     if (status != SOFTBUS_OK) {
394         CONN_LOGE(CONN_BLE, "RegisterNotification error = %{public}d", status);
395         return SOFTBUS_GATTC_INTERFACE_FAILED;
396     }
397     return SOFTBUS_OK;
398 }
399 
SoftbusGattcConfigureMtuSize(int32_t clientId,int mtuSize)400 int32_t SoftbusGattcConfigureMtuSize(int32_t clientId, int mtuSize)
401 {
402     if (BleGattcConfigureMtuSize(clientId, mtuSize) != SOFTBUS_OK) {
403         CONN_LOGE(CONN_BLE, "BleGattcConfigureMtuSize error");
404         return SOFTBUS_GATTC_INTERFACE_FAILED;
405     }
406     return SOFTBUS_OK;
407 }
408 
ConvertBtWriteType(SoftBusGattWriteType writeType)409 static BtGattWriteType ConvertBtWriteType(SoftBusGattWriteType writeType)
410 {
411     switch (writeType) {
412         case SOFTBUS_GATT_WRITE_NO_RSP:
413             return OHOS_GATT_WRITE_NO_RSP;
414         case SOFTBUS_GATT_WRITE_DEFAULT:
415             return OHOS_GATT_WRITE_DEFAULT;
416         case SOFTBUS_GATT_WRITE_PREPARE:
417             return OHOS_GATT_WRITE_PREPARE;
418         case SOFTBUS_GATT_WRITE_SIGNED:
419             return OHOS_GATT_WRITE_SIGNED;
420         default:
421             return OHOS_GATT_WRITE_TYPE_UNKNOWN;
422     }
423 }
424 
SoftbusGattcWriteCharacteristic(int32_t clientId,SoftBusGattcData * clientData)425 int32_t SoftbusGattcWriteCharacteristic(int32_t clientId, SoftBusGattcData *clientData)
426 {
427     if (clientId <= 0 || clientData == NULL) {
428         CONN_LOGE(CONN_BLE, "SoftbusGattcWriteCharacteristic invalid param");
429         return SOFTBUS_INVALID_PARAM;
430     }
431 
432     CONN_CHECK_AND_RETURN_RET_LOGE(
433         SoftBusMutexLock(&g_clientSendSignal.g_sendCondLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, CONN_BLE, "lock fail!");
434     if (!g_clientSendSignal.isWriteAvailable) {
435         SoftBusSysTime waitTime = {0};
436         SoftBusComputeWaitBleSendDataTime(BLE_WRITE_TIMEOUT_IN_MS, &waitTime);
437         int32_t ret = SoftBusCondWait(&g_clientSendSignal.g_sendCond, &g_clientSendSignal.g_sendCondLock, &waitTime);
438         if (ret != SOFTBUS_OK) {
439             CONN_LOGE(CONN_BLE, "SoftBusCondWait fail, ret=%{public}d, isWriteAvailable=%{public}d",
440                 ret, g_clientSendSignal.isWriteAvailable);
441             // fall-through: The protocol stack in the blue zone on a signal framework may not be called back.
442         }
443     }
444     g_clientSendSignal.isWriteAvailable = false;
445     (void)SoftBusMutexUnlock(&g_clientSendSignal.g_sendCondLock);
446     BtGattCharacteristic characteristic;
447     characteristic.serviceUuid.uuid = clientData->serviceUuid.uuid;
448     characteristic.serviceUuid.uuidLen = clientData->serviceUuid.uuidLen;
449     characteristic.characteristicUuid.uuid = clientData->characterUuid.uuid;
450     characteristic.characteristicUuid.uuidLen = clientData->characterUuid.uuidLen;
451     BtGattWriteType writeType = ConvertBtWriteType(clientData->writeType);
452     CONN_LOGI(CONN_BLE, "clientId = %{public}d, writeType=%{public}d", clientId, clientData->writeType);
453     if (BleGattcWriteCharacteristic(clientId, characteristic, writeType, clientData->valueLen,
454         (const char *)clientData->value) != SOFTBUS_OK) {
455         CONN_LOGE(CONN_BLE, "error");
456         CONN_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_clientSendSignal.g_sendCondLock) == SOFTBUS_OK,
457             SOFTBUS_LOCK_ERR, CONN_BLE, "lock fail!");
458         g_clientSendSignal.isWriteAvailable = true;
459         (void)SoftBusMutexUnlock(&g_clientSendSignal.g_sendCondLock);
460         return SOFTBUS_GATTC_INTERFACE_FAILED;
461     }
462     return SOFTBUS_OK;
463 }
464 
SoftbusGattcSetFastestConn(int32_t clientId)465 int32_t SoftbusGattcSetFastestConn(int32_t clientId)
466 {
467     if (clientId <= 0) {
468         CONN_LOGE(CONN_BLE, "invalid param, clientId = %{public}d", clientId);
469         return SOFTBUS_INVALID_PARAM;
470     }
471     int ret = BleGattcSetFastestConn(clientId, true);
472     if (ret != OHOS_BT_STATUS_SUCCESS) {
473         CONN_LOGE(CONN_BLE, "BleGattcSetFastestConn failed, return code = %{public}d", ret);
474         return SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_SET_FASTEST_ERR;
475     }
476     return SOFTBUS_OK;
477 }
478 
SoftbusGattcSetPriority(int32_t clientId,SoftBusBtAddr * addr,SoftbusBleGattPriority priority)479 int32_t SoftbusGattcSetPriority(int32_t clientId, SoftBusBtAddr *addr, SoftbusBleGattPriority priority)
480 {
481     if (clientId <= 0 || addr == NULL) {
482         CONN_LOGE(CONN_BLE, "invalid param, clientId = %{public}d", clientId);
483         return SOFTBUS_INVALID_PARAM;
484     }
485     BdAddr bdAddr = { 0 };
486     if (memcpy_s(bdAddr.addr, OHOS_BD_ADDR_LEN, addr->addr, BT_ADDR_LEN) != EOK) {
487         CONN_LOGE(CONN_BLE, "addr memory copy failed");
488         return SOFTBUS_INVALID_PARAM;
489     }
490     int ret = BleGattcSetPriority(clientId, &bdAddr, (BtGattPriority)priority);
491     if (ret != OHOS_BT_STATUS_SUCCESS) {
492         CONN_LOGE(CONN_BLE, "BleGattcSetPriority failed, return code = %{public}d", ret);
493         return SOFTBUS_CONN_BLE_UNDERLAY_CLIENT_SET_PRIORITY_ERR;
494     }
495     return SOFTBUS_OK;
496 }
497 
InitSoftbusAdapterClient(void)498 int32_t InitSoftbusAdapterClient(void)
499 {
500     g_softBusGattcManager = CreateSoftBusList();
501     if (g_softBusGattcManager == NULL) {
502         return SOFTBUS_CREATE_LIST_ERR;
503     }
504     g_btAddrs = CreateSoftBusList();
505     if (g_btAddrs == NULL) {
506         DestroySoftBusList(g_softBusGattcManager);
507         g_softBusGattcManager = NULL;
508         return SOFTBUS_CREATE_LIST_ERR;
509     }
510 
511     if (SoftBusMutexInit(&g_clientSendSignal.g_sendCondLock, NULL) != SOFTBUS_OK) {
512         CONN_LOGE(CONN_INIT, "mutex init failed");
513         DestroySoftBusList(g_softBusGattcManager);
514         DestroySoftBusList(g_btAddrs);
515         return SOFTBUS_NO_INIT;
516     }
517     if (SoftBusCondInit(&g_clientSendSignal.g_sendCond) != SOFTBUS_OK) {
518         DestroySoftBusList(g_softBusGattcManager);
519         DestroySoftBusList(g_btAddrs);
520         (void)SoftBusMutexDestroy(&g_clientSendSignal.g_sendCondLock);
521         return SOFTBUS_NO_INIT;
522     }
523     g_clientSendSignal.isWriteAvailable = true;
524     g_btGattClientCallbacks.ConnectionStateCb = GattcConnectionStateChangedCallback;
525     g_btGattClientCallbacks.connectParaUpdateCb = GattcConnectParaUpdateCallback;
526     g_btGattClientCallbacks.searchServiceCompleteCb = GattcSearchServiceCompleteCallback;
527     g_btGattClientCallbacks.readCharacteristicCb = GattcReadCharacteristicCallback;
528     g_btGattClientCallbacks.writeCharacteristicCb = GattcWriteCharacteristicCallback;
529     g_btGattClientCallbacks.readDescriptorCb = GattcReadDescriptorCallback;
530     g_btGattClientCallbacks.writeDescriptorCb = GattcWriteDescriptorCallback;
531     g_btGattClientCallbacks.configureMtuSizeCb = GattcConfigureMtuSizeCallback;
532     g_btGattClientCallbacks.registerNotificationCb = GattcRegisterNotificationCallback;
533     g_btGattClientCallbacks.notificationCb = GattcNotificationCallback;
534     return SOFTBUS_OK;
535 }