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