1 /*
2 * Copyright (c) 2021-2024 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
16 #include "softbus_adapter_bt_common.h"
17
18 #include <stdbool.h>
19
20 #include "c_header/ohos_bt_def.h"
21 #include "c_header/ohos_bt_gap.h"
22 #include "c_header/ohos_bt_socket.h"
23 #include "comm_log.h"
24 #include "securec.h"
25 #include "softbus_def.h"
26 #include "softbus_utils.h"
27 #include "softbus_common.h"
28 #include "softbus_error_code.h"
29
30 #define STATE_LISTENER_MAX_NUM 20
31 #define BR_STATE_CB_TRANSPORT 1
32
33 typedef struct {
34 bool isUsed;
35 SoftBusBtStateListener *listener;
36 } StateListener;
37
ConvertBtState(int transport,int state)38 static int ConvertBtState(int transport, int state)
39 {
40 switch (state) {
41 case OHOS_GAP_STATE_TURNING_ON:
42 return (transport == BR_STATE_CB_TRANSPORT) ? SOFTBUS_BR_STATE_TURNING_ON : SOFTBUS_BLE_STATE_TURNING_ON;
43 case OHOS_GAP_STATE_TURN_ON:
44 return (transport == BR_STATE_CB_TRANSPORT) ? SOFTBUS_BR_STATE_TURN_ON : SOFTBUS_BLE_STATE_TURN_ON;
45 case OHOS_GAP_STATE_TURNING_OFF:
46 return (transport == BR_STATE_CB_TRANSPORT) ? SOFTBUS_BR_STATE_TURNING_OFF : SOFTBUS_BLE_STATE_TURNING_OFF;
47 case OHOS_GAP_STATE_TURN_OFF:
48 return (transport == BR_STATE_CB_TRANSPORT) ? SOFTBUS_BR_STATE_TURN_OFF : SOFTBUS_BLE_STATE_TURN_OFF;
49 default:
50 return SOFTBUS_COMM_BLUETOOTH_SWITCH_STATE_ERR;
51 }
52 }
53
ConvertAclState(GapAclState state)54 static int ConvertAclState(GapAclState state)
55 {
56 switch (state) {
57 case OHOS_GAP_ACL_STATE_CONNECTED:
58 return SOFTBUS_ACL_STATE_CONNECTED;
59 case OHOS_GAP_ACL_STATE_DISCONNECTED:
60 return SOFTBUS_ACL_STATE_DISCONNECTED;
61 case OHOS_GAP_ACL_STATE_LE_CONNECTED:
62 return SOFTBUS_ACL_STATE_LE_CONNECTED;
63 case OHOS_GAP_ACL_STATE_LE_DISCONNECTED:
64 return SOFTBUS_ACL_STATE_LE_DISCONNECTED;
65 default:
66 break;
67 }
68 return SOFTBUS_COMM_BLUETOOTH_ACL_SWITCH_STATE_ERR;
69 }
70
ConvertBtAddr(const BdAddr * bdAddr)71 static SoftBusBtAddr ConvertBtAddr(const BdAddr *bdAddr)
72 {
73 SoftBusBtAddr btAddr = {0};
74 if (memcpy_s(btAddr.addr, sizeof(btAddr.addr), bdAddr->addr, sizeof(bdAddr->addr)) != EOK) {
75 COMM_LOGE(COMM_ADAPTER, "copy bdAddr fail");
76 }
77 return btAddr;
78 }
79
80 static StateListener g_stateListener[STATE_LISTENER_MAX_NUM];
81 static bool g_isBleTurnOn = false;
82 static bool g_isBrTurnOn = false;
83 static SoftBusMutex g_lock = {0};
IsRepeatNotify(int status)84 static bool IsRepeatNotify(int status)
85 {
86 COMM_LOGI(COMM_ADAPTER, "current state=%{public}d, isbleTurnOn=%{public}d, isbrTurnOn=%{public}d",
87 status, g_isBleTurnOn, g_isBrTurnOn);
88 COMM_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_lock) == SOFTBUS_OK, false,
89 COMM_ADAPTER, "try to lock failed");
90 bool result = false;
91 switch (status) {
92 case SOFTBUS_BLE_STATE_TURN_ON:
93 result = g_isBleTurnOn;
94 g_isBleTurnOn = true;
95 break;
96 case SOFTBUS_BR_STATE_TURN_ON:
97 result = g_isBrTurnOn;
98 g_isBrTurnOn = true;
99 break;
100 case SOFTBUS_BLE_STATE_TURN_OFF:
101 result = !g_isBleTurnOn;
102 g_isBleTurnOn = false;
103 break;
104 case SOFTBUS_BR_STATE_TURN_OFF:
105 result = !g_isBrTurnOn;
106 g_isBrTurnOn = false;
107 break;
108 default:
109 break;
110 }
111 (void)SoftBusMutexUnlock(&g_lock);
112 return result;
113 }
114
SoftBusOnBtSateChanged(int32_t status)115 static void SoftBusOnBtSateChanged(int32_t status)
116 {
117 if (IsRepeatNotify(status)) {
118 COMM_LOGI(COMM_ADAPTER, "current state=%{public}d, isbleTurnOn=%{public}d, isbrTurnOn=%{public}d",
119 status, g_isBleTurnOn, g_isBrTurnOn);
120 return;
121 }
122 int listenerId;
123 for (listenerId = 0; listenerId < STATE_LISTENER_MAX_NUM; listenerId++) {
124 if (g_stateListener[listenerId].isUsed &&
125 g_stateListener[listenerId].listener != NULL &&
126 g_stateListener[listenerId].listener->OnBtStateChanged != NULL) {
127 g_stateListener[listenerId].listener->OnBtStateChanged(listenerId, status);
128 }
129 }
130 }
131
WrapperStateChangeCallback(const int transport,const int status)132 static void WrapperStateChangeCallback(const int transport, const int status)
133 {
134 COMM_LOGI(COMM_ADAPTER, "transport = %{public}d (1-BT, 2-BLE), "
135 "status = %{public}d (0-turning on, 1-on, 2-turning off, 3-off)", transport, status);
136 int st = ConvertBtState(transport, status);
137 SoftBusOnBtSateChanged(st);
138 }
139
WrapperAclStateChangedCallback(const BdAddr * bdAddr,GapAclState state,unsigned int reason)140 static void WrapperAclStateChangedCallback(const BdAddr *bdAddr, GapAclState state, unsigned int reason)
141 {
142 if (bdAddr == NULL) {
143 COMM_LOGE(COMM_ADAPTER, "WrapperAclStateChangedCallback addr is null");
144 return;
145 }
146
147 COMM_LOGD(COMM_ADAPTER,
148 "WrapperAclStateChangedCallback, addr=%{public}02X:%{public}02X:***%{public}02X, state=%{public}d, "
149 "reason=%{public}u",
150 bdAddr->addr[MAC_FIRST_INDEX], bdAddr->addr[MAC_ONE_INDEX], bdAddr->addr[MAC_FIVE_INDEX], state, reason);
151 int listenerId;
152 int aclState = ConvertAclState(state);
153 SoftBusBtAddr btAddr = ConvertBtAddr(bdAddr);
154 for (listenerId = 0; listenerId < STATE_LISTENER_MAX_NUM; listenerId++) {
155 if (g_stateListener[listenerId].isUsed &&
156 g_stateListener[listenerId].listener != NULL &&
157 g_stateListener[listenerId].listener->OnBtAclStateChanged != NULL) {
158 g_stateListener[listenerId].listener->OnBtAclStateChanged(listenerId, &btAddr, aclState, 0);
159 }
160 }
161 }
162
WrapperPairRequestedCallback(const BdAddr * bdAddr,int transport)163 static void WrapperPairRequestedCallback(const BdAddr *bdAddr, int transport)
164 {
165 if (bdAddr == NULL) {
166 COMM_LOGE(COMM_ADAPTER, "WrapperPairRequestedCallback addr is null");
167 return;
168 }
169
170 COMM_LOGI(COMM_ADAPTER,
171 "WrapperPairRequestedCallback, addr=%{public}02X:%{public}02X:***%{public}02X, transport=%{public}d",
172 bdAddr->addr[MAC_FIRST_INDEX], bdAddr->addr[MAC_ONE_INDEX], bdAddr->addr[MAC_FIVE_INDEX], transport);
173 if (!PairRequestReply(bdAddr, transport, true)) {
174 COMM_LOGE(COMM_ADAPTER, "PairRequestReply error");
175 }
176 }
177
WrapperPairConfiremedCallback(const BdAddr * bdAddr,int transport,int reqType,int number)178 static void WrapperPairConfiremedCallback(const BdAddr *bdAddr, int transport, int reqType,
179 int number)
180 {
181 if (bdAddr == NULL) {
182 COMM_LOGE(COMM_ADAPTER, "WrapperPairConfirmedCallback addr is null");
183 return;
184 }
185
186 COMM_LOGI(COMM_ADAPTER,
187 "WrapperPairConfirmedCallback, addr=%{public}02X:%{public}02X:***%{public}02X, "
188 "transport=%{public}d, reqType=%{public}d, number=%{public}d",
189 bdAddr->addr[MAC_FIRST_INDEX], bdAddr->addr[MAC_ONE_INDEX], bdAddr->addr[MAC_FIVE_INDEX],
190 transport, reqType, number);
191 if (!SetDevicePairingConfirmation(bdAddr, transport, true)) {
192 COMM_LOGE(COMM_ADAPTER, "SetDevicePairingConfirmation error");
193 }
194 }
195
196 static BtGapCallBacks g_softbusGapCb = {
197 .stateChangeCallback = WrapperStateChangeCallback,
198 .aclStateChangedCallbak = WrapperAclStateChangedCallback,
199 .pairRequestedCallback = WrapperPairRequestedCallback,
200 .pairConfiremedCallback = WrapperPairConfiremedCallback
201 };
202
SoftBusAddBtStateListener(const SoftBusBtStateListener * listener,int * listenerId)203 int SoftBusAddBtStateListener(const SoftBusBtStateListener *listener, int *listenerId)
204 {
205 if (listener == NULL || listenerId == NULL) {
206 return SOFTBUS_INVALID_PARAM;
207 }
208 for (int index = 0; index < STATE_LISTENER_MAX_NUM; index++) {
209 if (!g_stateListener[index].isUsed) {
210 g_stateListener[index].isUsed = true;
211 g_stateListener[index].listener = (SoftBusBtStateListener *)listener;
212 *listenerId = index;
213 return SOFTBUS_OK;
214 }
215 }
216 COMM_LOGE(COMM_ADAPTER, "listener num max");
217 *listenerId = -1;
218 return SOFTBUS_COMM_BLUETOOTH_ADD_STATE_LISTENER_ERR;
219 }
220
SoftBusRemoveBtStateListener(int listenerId)221 int SoftBusRemoveBtStateListener(int listenerId)
222 {
223 if (listenerId < 0 || listenerId >= STATE_LISTENER_MAX_NUM) {
224 return SOFTBUS_INVALID_PARAM;
225 }
226 g_stateListener[listenerId].isUsed = false;
227 g_stateListener[listenerId].listener = NULL;
228 return SOFTBUS_OK;
229 }
230
SoftBusEnableBt(void)231 int SoftBusEnableBt(void)
232 {
233 if (EnableBle()) {
234 return SOFTBUS_OK;
235 }
236 return SOFTBUS_COMM_BLE_ENABLE_ERR;
237 }
238
SoftBusDisableBt(void)239 int SoftBusDisableBt(void)
240 {
241 if (DisableBle()) {
242 return SOFTBUS_OK;
243 }
244 return SOFTBUS_COMM_BLE_DISABLE_ERR;
245 }
246
SoftBusGetBtState(void)247 int SoftBusGetBtState(void)
248 {
249 if (IsBleEnabled()) {
250 return BLE_ENABLE;
251 }
252 return BLE_DISABLE;
253 }
254
SoftBusGetBrState(void)255 int SoftBusGetBrState(void)
256 {
257 if (GetBtState() == OHOS_GAP_STATE_TURN_ON) {
258 return BR_ENABLE;
259 }
260 return BR_DISABLE;
261 }
262
SoftBusGetBtMacAddr(SoftBusBtAddr * mac)263 int SoftBusGetBtMacAddr(SoftBusBtAddr *mac)
264 {
265 if (mac == NULL) {
266 return SOFTBUS_INVALID_PARAM;
267 }
268
269 if (!GetLocalAddr(mac->addr, BT_ADDR_LEN)) {
270 return SOFTBUS_COMM_BLUETOOTH_UNDERLAY_GET_ADDR_ERR;
271 }
272 return SOFTBUS_OK;
273 }
274
SoftBusGetBtName(unsigned char * name,unsigned int * len)275 int SoftBusGetBtName(unsigned char *name, unsigned int *len)
276 {
277 (void)name;
278 (void)len;
279 return SOFTBUS_OK;
280 }
281
SoftBusSetBtName(const char * name)282 int SoftBusSetBtName(const char *name)
283 {
284 if (name == NULL) {
285 COMM_LOGE(COMM_ADAPTER, "invalid parameter");
286 return SOFTBUS_INVALID_PARAM;
287 }
288 if (SetLocalName((unsigned char *)name, strlen(name))) {
289 return SOFTBUS_OK;
290 }
291 return SOFTBUS_COMM_BLUETOOTH_UNDERLAY_SET_NAME_ERR;
292 }
293
SoftBusGetRandomAddress(const char * addr,char * out,int tokenId)294 int SoftBusGetRandomAddress(const char *addr, char *out, int tokenId)
295 {
296 COMM_CHECK_AND_RETURN_RET_LOGE(addr != NULL, SOFTBUS_INVALID_PARAM,
297 COMM_ADAPTER, "get random address failed, addr is null");
298 COMM_CHECK_AND_RETURN_RET_LOGE(out != NULL, SOFTBUS_INVALID_PARAM,
299 COMM_ADAPTER, "get random address failed, outaddr is null");
300 uint8_t binaryAddr[BT_ADDR_LEN] = { 0 };
301 int32_t status = ConvertBtMacToBinary(addr, BT_MAC_LEN, binaryAddr, BT_ADDR_LEN);
302 COMM_CHECK_AND_RETURN_RET_LOGE(status == SOFTBUS_OK, status,
303 COMM_ADAPTER, "covert mac failed, status=%{public}d", status);
304 BdAddr bdAddr = {0};
305 status = memcpy_s(bdAddr.addr, OHOS_BD_ADDR_LEN, (unsigned char*)binaryAddr, BT_ADDR_LEN);
306 COMM_CHECK_AND_RETURN_RET_LOGE(status == EOK, SOFTBUS_MEM_ERR,
307 COMM_ADAPTER, "memcpy failed, status=%{public}d", status);
308
309 BdAddr randomAddr = {0};
310 status = GetRandomAddress(&bdAddr, &randomAddr, tokenId);
311 COMM_CHECK_AND_RETURN_RET_LOGE(status == OHOS_BT_STATUS_SUCCESS, status,
312 COMM_ADAPTER, "get random address failed, status=%{public}d", status);
313
314 status = ConvertBtMacToStr(out, BT_MAC_LEN, randomAddr.addr, sizeof(randomAddr.addr));
315 COMM_CHECK_AND_RETURN_RET_LOGE(status == OHOS_BT_STATUS_SUCCESS, status,
316 COMM_ADAPTER, "covert mac to str failed, status=%{public}d", status);
317 return SOFTBUS_OK;
318 }
319
SoftBusComputeWaitBleSendDataTime(uint32_t waitMillis,SoftBusSysTime * outtime)320 void SoftBusComputeWaitBleSendDataTime(uint32_t waitMillis, SoftBusSysTime *outtime)
321 {
322 #define USECTONSEC 1000
323 SoftBusSysTime now;
324 (void)SoftBusGetTime(&now);
325 int64_t time = now.sec * USECTONSEC * USECTONSEC + now.usec + (int64_t)waitMillis * USECTONSEC;
326 outtime->sec = time / USECTONSEC / USECTONSEC;
327 outtime->usec = time % (USECTONSEC * USECTONSEC);
328 }
329
SoftBusBtInit(void)330 int SoftBusBtInit(void)
331 {
332 if (SoftBusMutexInit(&g_lock, NULL) != SOFTBUS_OK) {
333 COMM_LOGE(COMM_ADAPTER, "init lock error");
334 return SOFTBUS_LOCK_ERR;
335 }
336 if (GapRegisterCallbacks(&g_softbusGapCb) != OHOS_BT_STATUS_SUCCESS) {
337 SoftBusMutexDestroy(&g_lock);
338 return SOFTBUS_COMM_BLUETOOTH_UNDERLAY_REGISTER_CB_ERR;
339 }
340 if (SoftBusGetBtState() == BLE_ENABLE) {
341 SoftBusOnBtSateChanged(SOFTBUS_BLE_STATE_TURN_ON);
342 }
343 if (SoftBusGetBrState() == BR_ENABLE) {
344 SoftBusOnBtSateChanged(SOFTBUS_BR_STATE_TURN_ON);
345 }
346 return SOFTBUS_OK;
347 }