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 
16 #include "gap_le.h"
17 #include "gap_internal.h"
18 
19 #include <securec.h>
20 
21 #include "allocator.h"
22 #include "log.h"
23 
24 #include "btm.h"
25 #include "hci/hci.h"
26 #include "hci/hci_error.h"
27 
28 typedef struct {
29     GapAdvCallback callback;
30     void *context;
31 } LeAdvCallback;
32 
33 typedef struct {
34     GapExAdvCallback callback;
35     void *context;
36 } LeExAdvCallback;
37 
38 static LeAdvCallback g_leAdvCallback;
39 static LeExAdvCallback g_leExAdvCallback;
40 
GapFindExAdvInfoByAdvHandle(void * nodeData,void * param)41 static bool GapFindExAdvInfoByAdvHandle(void *nodeData, void *param)
42 {
43     uint8_t advHandle = *(uint8_t *)param;
44 
45     return ((LeExAdvInfo *)nodeData)->advHandle == advHandle;
46 }
47 
GapLeReadMaximumAdvertisingDataLengthComplete(const HciLeReadMaximumAdvertisingDataLengthReturnParam * param)48 void GapLeReadMaximumAdvertisingDataLengthComplete(const HciLeReadMaximumAdvertisingDataLengthReturnParam *param)
49 {
50     LeExAdvBlock *exAdvBlock = GapGetLeExAdvBlock();
51     if (param->status == HCI_SUCCESS) {
52         exAdvBlock->exAdvDataMaxLen = param->maximumAdvertisingDataLength;
53     } else {
54         exAdvBlock->exAdvDataMaxLen = 0;
55     }
56 }
57 
GapLeReadNumberofSupportedAdvertisingSetsComplete(const HciLeReadNumberofSupportedAdvertisingSetsReturnParam * param)58 void GapLeReadNumberofSupportedAdvertisingSetsComplete(
59     const HciLeReadNumberofSupportedAdvertisingSetsReturnParam *param)
60 {
61     LeExAdvBlock *exAdvBlock = GapGetLeExAdvBlock();
62     if (param->status == HCI_SUCCESS) {
63         exAdvBlock->exAdvMaxNumber = param->numSupportedAdvertisingSets;
64     } else {
65         exAdvBlock->exAdvMaxNumber = 0;
66     }
67 }
68 
GAP_LeExAdvGetMaxDataLen(uint16_t * len)69 int GAP_LeExAdvGetMaxDataLen(uint16_t *len)
70 {
71     LOG_INFO("%{public}s:", __FUNCTION__);
72     LeExAdvBlock *exAdvBlock = GapGetLeExAdvBlock();
73     *len = exAdvBlock->exAdvDataMaxLen;
74     return GAP_SUCCESS;
75 }
76 
GAP_LeExAdvGetMaxHandleNum(uint8_t * num)77 int GAP_LeExAdvGetMaxHandleNum(uint8_t *num)
78 {
79     LOG_INFO("%{public}s:", __FUNCTION__);
80     LeExAdvBlock *exAdvBlock = GapGetLeExAdvBlock();
81     *num = exAdvBlock->exAdvMaxNumber;
82     return GAP_SUCCESS;
83 }
84 
GAP_RegisterExAdvCallback(const GapExAdvCallback * callback,void * context)85 int GAP_RegisterExAdvCallback(const GapExAdvCallback *callback, void *context)
86 {
87     LOG_INFO("%{public}s:%{public}s", __FUNCTION__, callback ? "register" : "NULL");
88     if (callback == NULL) {
89         (void)memset_s(
90             &g_leExAdvCallback.callback, sizeof(g_leExAdvCallback.callback), 0x00, sizeof(g_leExAdvCallback.callback));
91     } else {
92         g_leExAdvCallback.callback = *callback;
93     }
94     g_leExAdvCallback.context = context;
95     return GAP_SUCCESS;
96 }
97 
GAP_DeregisterExAdvCallback(void)98 int GAP_DeregisterExAdvCallback(void)
99 {
100     (void)memset_s(
101         &g_leExAdvCallback.callback, sizeof(g_leExAdvCallback.callback), 0x00, sizeof(g_leExAdvCallback.callback));
102     g_leExAdvCallback.context = NULL;
103     return GAP_SUCCESS;
104 }
105 
GapLeSetAdvertisingSetRandomAddress(uint8_t advHandle,const uint8_t addr[BT_ADDRESS_SIZE])106 static int GapLeSetAdvertisingSetRandomAddress(uint8_t advHandle, const uint8_t addr[BT_ADDRESS_SIZE])
107 {
108     HciLeSetAdvertisingSetRandomAddressParam hciCmdParam;
109 
110     LeExAdvInfo *info = ListForEachData(GapGetLeExAdvBlock()->exAdvInfoList, GapFindExAdvInfoByAdvHandle, &advHandle);
111     if (info != NULL) {
112         (void)memcpy_s(info->randomAddress, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
113     } else {
114         info = MEM_MALLOC.alloc(sizeof(LeExAdvInfo));
115         if (info != NULL) {
116             info->advHandle = advHandle;
117             (void)memcpy_s(info->randomAddress, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
118             ListAddLast(GapGetLeExAdvBlock()->exAdvInfoList, info);
119         }
120     }
121 
122     hciCmdParam.advertisingHandle = advHandle;
123     (void)memcpy_s(hciCmdParam.randomAddress, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
124 
125     return HCI_LeSetAdvertisingSetRandomAddress(&hciCmdParam);
126 }
127 
128 NO_SANITIZE("cfi")
GapLeSetAdvertisingSetRandomAddressComplete(const HciLeSetAdvertisingSetRandomAddressReturnParam * param)129 void GapLeSetAdvertisingSetRandomAddressComplete(const HciLeSetAdvertisingSetRandomAddressReturnParam *param)
130 {
131     if (g_leExAdvCallback.callback.exAdvSetRandAddrResult) {
132         g_leExAdvCallback.callback.exAdvSetRandAddrResult(param->status, g_leExAdvCallback.context);
133     }
134 }
135 
GAP_LeExAdvSetRandAddr(uint8_t advHandle,const uint8_t addr[BT_ADDRESS_SIZE])136 int GAP_LeExAdvSetRandAddr(uint8_t advHandle, const uint8_t addr[BT_ADDRESS_SIZE])
137 {
138     int ret;
139     LOG_INFO("%{public}s:" BT_ADDR_FMT, __FUNCTION__, BT_ADDR_FMT_OUTPUT(addr));
140     if (GapIsLeEnable() == false) {
141         return GAP_ERR_NOT_ENABLE;
142     }
143 
144     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
145         ret = GAP_ERR_INVAL_STATE;
146     } else {
147         ret = GapLeSetAdvertisingSetRandomAddress(advHandle, addr);
148     }
149     return ret;
150 }
151 
GapLeSetExtendedAdvertisingParameters(uint8_t advHandle,uint8_t properties,int8_t txPower,GapLeExAdvParam advExParam)152 static int GapLeSetExtendedAdvertisingParameters(
153     uint8_t advHandle, uint8_t properties, int8_t txPower, GapLeExAdvParam advExParam)
154 {
155     HciLeSetExtendedAdvertisingParametersParam hciCmdParam;
156     hciCmdParam.advertisingHandle = advHandle;
157     hciCmdParam.advertisingEventProperties = properties;
158     (void)memcpy_s(hciCmdParam.priAdvertisingIntervalMin,
159         sizeof(hciCmdParam.priAdvertisingIntervalMin),
160         &advExParam.advIntervalMin,
161         sizeof(hciCmdParam.priAdvertisingIntervalMin));
162     (void)memcpy_s(hciCmdParam.priAdvertisingIntervalMax,
163         sizeof(hciCmdParam.priAdvertisingIntervalMax),
164         &advExParam.advIntervalMax,
165         sizeof(hciCmdParam.priAdvertisingIntervalMax));
166     hciCmdParam.priAdvertisingChannelMap = advExParam.advChannelMap;
167     hciCmdParam.ownAddressType = BTM_GetOwnAddressType();
168     hciCmdParam.peerAddressType = advExParam.peerAddr->type;
169     (void)memcpy_s(hciCmdParam.peerAddress, BT_ADDRESS_SIZE, advExParam.peerAddr->addr, BT_ADDRESS_SIZE);
170     hciCmdParam.advertisingFilterPolicy = advExParam.advFilterPolicy;
171     hciCmdParam.advertisingTxPower = txPower;
172     hciCmdParam.priAdvertisingPHY = advExParam.primaryAdvPhy;
173     hciCmdParam.secondaryAdvertisingMaxSkip = advExParam.secondaryAdvMaxSkip;
174     hciCmdParam.secondaryAdvertisingPHY = advExParam.secondaryAdvPhy;
175     hciCmdParam.advertisingSID = advExParam.advSid;
176     hciCmdParam.scanRequestNotificationEnable = advExParam.scanRequestNotifyEnable;
177     return HCI_LeSetExtendedAdvertisingParameters(&hciCmdParam);
178 }
179 
180 NO_SANITIZE("cfi")
GapLeSetExtendedAdvertisingParametersComplete(const HciLeSetExtendedAdvertisingParametersReturnParam * param)181 void GapLeSetExtendedAdvertisingParametersComplete(const HciLeSetExtendedAdvertisingParametersReturnParam *param)
182 {
183     if (g_leExAdvCallback.callback.exAdvSetParamResult) {
184         g_leExAdvCallback.callback.exAdvSetParamResult(
185             param->status, param->selectedTxPower, g_leExAdvCallback.context);
186     }
187 }
188 
GAP_LeExAdvSetParam(uint8_t advHandle,uint8_t properties,int8_t txPower,GapLeExAdvParam advExParam)189 int GAP_LeExAdvSetParam(uint8_t advHandle, uint8_t properties, int8_t txPower, GapLeExAdvParam advExParam)
190 {
191     int ret;
192     LOG_INFO("%{public}s:", __FUNCTION__);
193     if (GapIsLeEnable() == false) {
194         return GAP_ERR_NOT_ENABLE;
195     }
196 
197     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
198         ret = GAP_ERR_INVAL_STATE;
199     } else {
200         ret = GapLeSetExtendedAdvertisingParameters(advHandle, properties, txPower, advExParam);
201     }
202     return ret;
203 }
204 
GapLeSetExtendedAdvertisingData(uint8_t advHandle,uint8_t operation,uint8_t fragmentPreference,uint8_t advDataLength,const uint8_t * advData)205 static int GapLeSetExtendedAdvertisingData(
206     uint8_t advHandle, uint8_t operation, uint8_t fragmentPreference, uint8_t advDataLength, const uint8_t *advData)
207 {
208     HciLeSetExtendedAdvertisingDataParam hciCmdParam;
209     hciCmdParam.advertisingHandle = advHandle;
210     hciCmdParam.fragmentPreference = fragmentPreference;
211     hciCmdParam.operation = operation;
212     hciCmdParam.advertisingDataLength = advDataLength;
213     hciCmdParam.advertisingData = advData;
214 
215     return HCI_LeSetExtendedAdvertisingData(&hciCmdParam);
216 }
217 
GapLeSetExtendedAdvertisingDataComplete(const HciLeSetExtendedAdvertisingDataReturnParam * param)218 NO_SANITIZE("cfi") void GapLeSetExtendedAdvertisingDataComplete(const HciLeSetExtendedAdvertisingDataReturnParam *param)
219 {
220     if (g_leExAdvCallback.callback.exAdvSetDataResult) {
221         g_leExAdvCallback.callback.exAdvSetDataResult(param->status, g_leExAdvCallback.context);
222     }
223 }
224 
GAP_LeExAdvSetData(uint8_t advHandle,uint8_t operation,uint8_t fragmentPreference,uint8_t advDataLength,const uint8_t * advData)225 int GAP_LeExAdvSetData(
226     uint8_t advHandle, uint8_t operation, uint8_t fragmentPreference, uint8_t advDataLength, const uint8_t *advData)
227 {
228     int ret;
229     LOG_INFO("%{public}s:", __FUNCTION__);
230     if (GapIsLeEnable() == false) {
231         return GAP_ERR_NOT_ENABLE;
232     }
233 
234     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
235         ret = GAP_ERR_INVAL_STATE;
236     } else {
237         ret = GapLeSetExtendedAdvertisingData(advHandle, operation, fragmentPreference, advDataLength, advData);
238     }
239     return ret;
240 }
241 
GapLeSetExtendedScanResponseData(uint8_t advHandle,uint8_t operation,uint8_t fragmentPreference,uint8_t scanResponseDataLength,const uint8_t * scanResponseData)242 static int GapLeSetExtendedScanResponseData(uint8_t advHandle, uint8_t operation, uint8_t fragmentPreference,
243     uint8_t scanResponseDataLength, const uint8_t *scanResponseData)
244 {
245     HciLeSetExtendedScanResponseDataParam hciCmdParam;
246     hciCmdParam.advertisingHandle = advHandle;
247     hciCmdParam.fragmentPreference = fragmentPreference;
248     hciCmdParam.operation = operation;
249     hciCmdParam.scanResponseDataLength = scanResponseDataLength;
250     hciCmdParam.scanResponseData = scanResponseData;
251 
252     return HCI_LeSetExtendedScanResponseData(&hciCmdParam);
253 }
254 
255 NO_SANITIZE("cfi")
GapLeSetExtendedScanResponseDataComplete(const HciLeSetExtendedScanResponseDataReturnParam * param)256 void GapLeSetExtendedScanResponseDataComplete(const HciLeSetExtendedScanResponseDataReturnParam *param)
257 {
258     if (g_leExAdvCallback.callback.exAdvSetScanRspDataResult) {
259         g_leExAdvCallback.callback.exAdvSetScanRspDataResult(param->status, g_leExAdvCallback.context);
260     }
261 }
262 
GAP_LeExAdvSetScanRspData(uint8_t advHandle,uint8_t operation,uint8_t fragmentPreference,uint8_t scanResponseDataLen,const uint8_t * scanResponseData)263 int GAP_LeExAdvSetScanRspData(uint8_t advHandle, uint8_t operation, uint8_t fragmentPreference,
264     uint8_t scanResponseDataLen, const uint8_t *scanResponseData)
265 {
266     int ret;
267     LOG_INFO("%{public}s:", __FUNCTION__);
268     if (GapIsLeEnable() == false) {
269         return GAP_ERR_NOT_ENABLE;
270     }
271 
272     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
273         ret = GAP_ERR_INVAL_STATE;
274     } else {
275         ret = GapLeSetExtendedScanResponseData(
276             advHandle, operation, fragmentPreference, scanResponseDataLen, scanResponseData);
277     }
278     return ret;
279 }
280 
GapLeSetExtendedAdvertisingEnable(uint8_t enable,uint8_t numberOfSet,const GapExAdvSet * advSet)281 static int GapLeSetExtendedAdvertisingEnable(uint8_t enable, uint8_t numberOfSet, const GapExAdvSet *advSet)
282 {
283     int ret;
284     HciLeSetExtendedAdvertisingEnableParam hciCmdParam;
285 
286     hciCmdParam.enable = enable;
287     hciCmdParam.numberofSets = numberOfSet;
288     hciCmdParam.sets = MEM_MALLOC.alloc(numberOfSet * sizeof(HciLeExtendedAdvertisingParamSet));
289     if (hciCmdParam.sets) {
290         for (int i = 0; i < numberOfSet; i++) {
291             hciCmdParam.sets[i].adverHandle = advSet[i].advHandle;
292             hciCmdParam.sets[i].duration = advSet[i].duration;
293             hciCmdParam.sets[i].maxExtendAdvertisingEvents = advSet[i].maxExAdvEvt;
294         }
295 
296         ret = HCI_LeSetExtendedAdvertisingEnable(&hciCmdParam);
297         MEM_MALLOC.free(hciCmdParam.sets);
298     } else {
299         ret = GAP_ERR_OUT_OF_RES;
300     }
301 
302     return ret;
303 }
304 
305 NO_SANITIZE("cfi")
GapLeSetExtendedAdvertisingEnableComplete(const HciLeSetExtendedAdvertisingEnableReturnParam * param)306 void GapLeSetExtendedAdvertisingEnableComplete(const HciLeSetExtendedAdvertisingEnableReturnParam *param)
307 {
308     if (g_leExAdvCallback.callback.exAdvSetEnableResult) {
309         g_leExAdvCallback.callback.exAdvSetEnableResult(param->status, g_leExAdvCallback.context);
310     }
311 }
312 
GAP_LeExAdvSetEnable(uint8_t enable,uint8_t numberOfSet,const GapExAdvSet * advSet)313 int GAP_LeExAdvSetEnable(uint8_t enable, uint8_t numberOfSet, const GapExAdvSet *advSet)
314 {
315     int ret;
316     LOG_INFO("%{public}s:", __FUNCTION__);
317     if (GapIsLeEnable() == false) {
318         return GAP_ERR_NOT_ENABLE;
319     }
320 
321     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
322         ret = GAP_ERR_INVAL_STATE;
323     } else {
324         ret = GapLeSetExtendedAdvertisingEnable(enable, numberOfSet, advSet);
325     }
326     return ret;
327 }
328 
GapOnLeScanRequestReceivedEvent(const HciLeScanRequestReceivedEventParam * eventParam)329 void GapOnLeScanRequestReceivedEvent(const HciLeScanRequestReceivedEventParam *eventParam)
330 {
331     if (g_leExAdvCallback.callback.exAdvScanRequestReceived) {
332         BtAddr addr;
333         GapChangeHCIAddr(&addr, &eventParam->scannerAddress, eventParam->scannerAddressType);
334         g_leExAdvCallback.callback.exAdvScanRequestReceived(
335             eventParam->advertisingHandle, &addr, g_leExAdvCallback.context);
336     }
337 }
338 
GapLeRemoveAdvertisingSetComplete(const HciLeRemoveAdvertisingSetReturnParam * param)339 void GapLeRemoveAdvertisingSetComplete(const HciLeRemoveAdvertisingSetReturnParam *param)
340 {
341     if (g_leExAdvCallback.callback.exAdvRemoveHandleResult) {
342         g_leExAdvCallback.callback.exAdvRemoveHandleResult(param->status, g_leExAdvCallback.context);
343     }
344 }
345 
GapLeClearAdvertisingSets(void)346 static int GapLeClearAdvertisingSets(void)
347 {
348     ListClear(GapGetLeExAdvBlock()->exAdvInfoList);
349 
350     return HCI_LeClearAdvertisingSets();
351 }
352 
GapLeClearAdvertisingSetsComplete(const HciLeClearAdvertisingSetsReturnParam * param)353 NO_SANITIZE("cfi") void GapLeClearAdvertisingSetsComplete(const HciLeClearAdvertisingSetsReturnParam *param)
354 {
355     if (g_leExAdvCallback.callback.exAdvClearHandleResult) {
356         g_leExAdvCallback.callback.exAdvClearHandleResult(param->status, g_leExAdvCallback.context);
357     }
358 }
359 
GAP_LeExAdvClearHandle(void)360 int GAP_LeExAdvClearHandle(void)
361 {
362     LOG_INFO("%{public}s:", __FUNCTION__);
363     int ret;
364 
365     if (GapIsLeEnable() == false) {
366         return GAP_ERR_NOT_ENABLE;
367     }
368 
369     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
370         ret = GAP_ERR_INVAL_STATE;
371     } else {
372         ret = GapLeClearAdvertisingSets();
373     }
374     return ret;
375 }
376 
GapOnLeAdvertisingSetTerminated(const HciLeAdvertisingSetTerminatedEventParam * eventParam)377 void GapOnLeAdvertisingSetTerminated(const HciLeAdvertisingSetTerminatedEventParam *eventParam)
378 {
379     if (eventParam->status == HCI_SUCCESS) {
380         LeDeviceInfo *deviceInfo = ListForEachData(GapGetLeConnectionInfoBlock()->deviceList,
381             GapFindLeConnectionDeviceByHandle,
382             (void *)&eventParam->connectionHandle);
383         if (deviceInfo != NULL && deviceInfo->ownAddr.type == BT_RANDOM_DEVICE_ADDRESS) {
384             LeExAdvInfo *info = ListForEachData(GapGetLeExAdvBlock()->exAdvInfoList,
385                 GapFindExAdvInfoByAdvHandle,
386                 (void *)&eventParam->advertisingHandle);
387             if (info != NULL) {
388                 LOG_INFO("%{public}s: change own address " BT_ADDR_FMT " -> " BT_ADDR_FMT,
389                     __FUNCTION__,
390                     BT_ADDR_FMT_OUTPUT(deviceInfo->ownAddr.addr),
391                     BT_ADDR_FMT_OUTPUT(info->randomAddress));
392                 (void)memcpy_s(deviceInfo->ownAddr.addr, BT_ADDRESS_SIZE, info->randomAddress, BT_ADDRESS_SIZE);
393             }
394         }
395         if (deviceInfo != NULL && GapLeDeviceNeedBond(deviceInfo)) {
396             GapLeDoPair(&deviceInfo->addr);
397         }
398         if (eventParam->status == HCI_SUCCESS) {
399             if (deviceInfo != NULL) {
400                 deviceInfo->ownAddrUpdated = true;
401             }
402             if (deviceInfo != NULL && deviceInfo->securityReq != NULL) {
403                 GapLeRequestSecurityProcess(deviceInfo);
404             }
405         }
406     }
407 
408     if (g_leExAdvCallback.callback.exAdvTerminatedAdvSet) {
409         g_leExAdvCallback.callback.exAdvTerminatedAdvSet(eventParam->status,
410             eventParam->advertisingHandle,
411             eventParam->connectionHandle,
412             eventParam->numCompletedExtendedAdvertisingEvents,
413             g_leExAdvCallback.context);
414     }
415 }
416 
GAP_RegisterAdvCallback(const GapAdvCallback * callback,void * context)417 int GAP_RegisterAdvCallback(const GapAdvCallback *callback, void *context)
418 {
419     LOG_INFO("%{public}s:%{public}s", __FUNCTION__, callback ? "register" : "NULL");
420     if (callback == NULL) {
421         (void)memset_s(
422             &g_leAdvCallback.callback, sizeof(g_leAdvCallback.callback), 0x00, sizeof(g_leAdvCallback.callback));
423     } else {
424         g_leAdvCallback.callback = *callback;
425     }
426     g_leAdvCallback.context = context;
427     return GAP_SUCCESS;
428 }
429 
GAP_DeregisterAdvCallback(void)430 int GAP_DeregisterAdvCallback(void)
431 {
432     (void)memset_s(&g_leAdvCallback.callback, sizeof(g_leAdvCallback.callback), 0x00, sizeof(g_leAdvCallback.callback));
433     g_leAdvCallback.context = NULL;
434     return GAP_SUCCESS;
435 }
436 
GAP_LeAdvSetParam(uint8_t advType,GapLeAdvParam advParam)437 int GAP_LeAdvSetParam(uint8_t advType, GapLeAdvParam advParam)
438 {
439     LOG_INFO("%{public}s:", __FUNCTION__);
440     int ret;
441 
442     if (GapIsLeEnable() == false) {
443         return GAP_ERR_NOT_ENABLE;
444     }
445 
446     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
447         ret = GAP_ERR_INVAL_STATE;
448     } else if (GapLeRolesCheck(GAP_LE_ROLE_PREIPHERAL) == false && advType != GAP_ADV_TYPE_SCAN_UNDIR &&
449                advType != GAP_ADV_TYPE_NON_CONN_UNDIR) {
450         ret = GAP_ERR_INVAL_PARAM;
451     } else {
452         HciLeSetAdvertisingParametersParam hciCmdParam;
453 
454         hciCmdParam.advertisingType = advType;
455         hciCmdParam.advertisingIntervalMin = advParam.advIntervalMin;
456         hciCmdParam.advertisingIntervalMax = advParam.advIntervalMax;
457         hciCmdParam.ownAddressType = BTM_GetOwnAddressType();
458         hciCmdParam.peerAddressType = advParam.peerAddr->type;
459         (void)memcpy_s(hciCmdParam.peerAddress.raw, BT_ADDRESS_SIZE, advParam.peerAddr->addr, BT_ADDRESS_SIZE);
460         hciCmdParam.advertisingChannelMap = advParam.advChannelMap;
461         hciCmdParam.advertisingFilterPolicy = advParam.advFilterPolicy;
462 
463         ret = HCI_LeSetAdvertisingParameters(&hciCmdParam);
464         if (ret != BT_SUCCESS) {
465             LOG_ERROR("HCI Command Error ret = %{public}d.", ret);
466         }
467     }
468 
469     return ret;
470 }
471 
GapLeAdvSetParamComplete(const HciLeSetAdvertisingParametersReturnParam * param)472 void GapLeAdvSetParamComplete(const HciLeSetAdvertisingParametersReturnParam *param)
473 {
474     if (g_leAdvCallback.callback.advSetParamResult) {
475         g_leAdvCallback.callback.advSetParamResult(param->status, g_leAdvCallback.context);
476     }
477 }
478 
GAP_LeAdvReadTxPower(void)479 int GAP_LeAdvReadTxPower(void)
480 {
481     LOG_INFO("%{public}s:", __FUNCTION__);
482     int ret;
483 
484     if (GapIsLeEnable() == false) {
485         return GAP_ERR_NOT_ENABLE;
486     }
487 
488     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
489         ret = GAP_ERR_INVAL_STATE;
490     } else {
491         ret = HCI_LeReadAdvertisingChannelTxPower();
492     }
493 
494     return ret;
495 }
496 
GapLeAdvReadTxPowerComplete(const HciLeReadAdvertisingChannelTxPowerReturnParam * param)497 void GapLeAdvReadTxPowerComplete(const HciLeReadAdvertisingChannelTxPowerReturnParam *param)
498 {
499     if (g_leAdvCallback.callback.advReadTxPower) {
500         g_leAdvCallback.callback.advReadTxPower(param->status, param->transmitPowerLevel, g_leAdvCallback.context);
501     }
502 }
503 
GAP_LeAdvSetData(uint8_t advDataLength,const uint8_t * advData)504 int GAP_LeAdvSetData(uint8_t advDataLength, const uint8_t *advData)
505 {
506     LOG_INFO("%{public}s:", __FUNCTION__);
507     int ret;
508 
509     if (advDataLength > GAP_ADVERTISING_DATA_LENGTH_MAX) {
510         return GAP_ERR_INVAL_PARAM;
511     }
512 
513     if (GapIsLeEnable() == false) {
514         return GAP_ERR_NOT_ENABLE;
515     }
516 
517     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
518         ret = GAP_ERR_INVAL_STATE;
519     } else {
520         HciLeSetAdvertisingDataParam hciCmdParam = {
521             .advertisingDataLen = advDataLength,
522         };
523         (void)memcpy_s(hciCmdParam.advertisingData, sizeof(hciCmdParam.advertisingData), advData, advDataLength);
524 
525         ret = HCI_LeSetAdvertisingData(&hciCmdParam);
526     }
527 
528     return ret;
529 }
530 
GapLeAdvSetDataComplete(const HciLeSetAdvertisingDataReturnParam * param)531 void GapLeAdvSetDataComplete(const HciLeSetAdvertisingDataReturnParam *param)
532 {
533     if (g_leAdvCallback.callback.advSetDataResult) {
534         g_leAdvCallback.callback.advSetDataResult(param->status, g_leAdvCallback.context);
535     }
536 }
537 
GAP_LeAdvSetScanRspData(uint8_t advDataLength,const uint8_t * advData)538 int GAP_LeAdvSetScanRspData(uint8_t advDataLength, const uint8_t *advData)
539 {
540     LOG_INFO("%{public}s:", __FUNCTION__);
541     int ret;
542 
543     if (GapIsLeEnable() == false) {
544         return GAP_ERR_NOT_ENABLE;
545     }
546 
547     if (advDataLength > GAP_ADVERTISING_DATA_LENGTH_MAX) {
548         return GAP_ERR_INVAL_PARAM;
549     }
550 
551     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
552         ret = GAP_ERR_INVAL_STATE;
553     } else {
554         HciLeSetScanResponseDataParam hciCmdParam = {
555             .scanResponseDataLength = advDataLength,
556         };
557         (void)memcpy_s(hciCmdParam.scanResponseData, sizeof(hciCmdParam.scanResponseData), advData, advDataLength);
558 
559         ret = HCI_LeSetScanResponseData(&hciCmdParam);
560     }
561 
562     return ret;
563 }
564 
GapLeAdvSetScanRspDataComplete(const HciLeSetScanResponseDataReturnParam * param)565 void GapLeAdvSetScanRspDataComplete(const HciLeSetScanResponseDataReturnParam *param)
566 {
567     if (g_leAdvCallback.callback.advSetScanRspDataResult) {
568         g_leAdvCallback.callback.advSetScanRspDataResult(param->status, g_leAdvCallback.context);
569     }
570 }
571 
GAP_LeAdvSetEnable(uint8_t enable)572 int GAP_LeAdvSetEnable(uint8_t enable)
573 {
574     LOG_INFO("%{public}s:", __FUNCTION__);
575     int ret;
576 
577     if (GapIsLeEnable() == false) {
578         return GAP_ERR_NOT_ENABLE;
579     }
580 
581     if (GapLeRolesCheck(GAP_LE_ROLE_BROADCASTER | GAP_LE_ROLE_PREIPHERAL) == false) {
582         ret = GAP_ERR_INVAL_STATE;
583     } else {
584         HciLeSetAdvertisingEnableParam hciCmdParam = {
585             .advertisingEnable = enable,
586         };
587 
588         ret = HCI_LeSetAdvertisingEnable(&hciCmdParam);
589     }
590 
591     return ret;
592 }
593 
GapLeAdvSetEnableComplete(const HciLeSetAdvertisingEnableReturnParam * param)594 void GapLeAdvSetEnableComplete(const HciLeSetAdvertisingEnableReturnParam *param)
595 {
596     if (g_leAdvCallback.callback.advSetEnableResult) {
597         g_leAdvCallback.callback.advSetEnableResult(param->status, g_leAdvCallback.context);
598     }
599 }
600