1 /*
2  * Copyright (C) 2021-2022 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 "avdtp_impl.h"
17 #include "avdtp_ctrl.h"
18 #include "avdtp_message.h"
19 #include "btm.h"
20 #include "btm/btm_interop.h"
21 #include "l2cap_if.h"
22 #include "log.h"
23 #include "securec.h"
24 
25 /**
26  * Stream  action implement functions
27  */
28 
29 /**
30  *
31  * @brief         AvdtActDiscoverReq
32  *
33  * @details       Int send discover command
34  *
35  * @return        void
36  *
37  */
AvdtActDiscoverReq(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)38 uint16_t AvdtActDiscoverReq(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
39 {
40     LOG_DEBUG("[AVDT]%{public}s:", __func__);
41     if (sigCtrl == NULL || data == NULL) {
42         return AVDT_SUCCESS;
43     }
44     uint16_t Ret = AVDT_SUCCESS;
45     /* disable call discover seps API continually */
46     sigCtrl->isProcBusy = true;
47     sigCtrl->procParam = data->discover.numSeps;
48     AvdtMsgSendCmd(sigCtrl, NULL, AVDT_SIG_DISCOVER, NULL);
49     return Ret;
50 }
51 
52 /**
53  *
54  * @brief         AvdtActDiscoverRsp
55  *
56  * @details       Avp send discover respond
57  *
58  * @return        uint16_t
59  *
60  */
AvdtActDiscoverRsp(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)61 uint16_t AvdtActDiscoverRsp(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
62 {
63     LOG_DEBUG("[AVDT]%{public}s:", __func__);
64     if (sigCtrl == NULL || data == NULL) {
65         return AVDT_SUCCESS;
66     }
67     uint16_t Ret = AVDT_SUCCESS;
68     if (data->msg.discoverRsp.hdr.errCode == AVDT_SUCCESS) {
69         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_DISCOVER, &(data->msg));
70     } else {
71         AvdtMsgSendRej(sigCtrl, AVDT_SIG_DISCOVER, &(data->msg));
72     }
73     return Ret;
74 }
75 
76 /**
77  *
78  * @brief         AvdtActDiscoverInd
79  *
80  * @details       Acp receive the discover command and indicate to the upper application.
81  *                Get the seps information of local device.
82  *
83  * @return        uint16_t
84  *
85  */
AvdtActDiscoverInd(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)86 uint16_t AvdtActDiscoverInd(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
87 {
88     if (sigCtrl == NULL) {
89         return AVDT_SUCCESS;
90     }
91     LOG_DEBUG("[AVDT]%{public}s: sigCtrl->state(%hhu)", __func__, sigCtrl->state);
92     uint16_t Ret = AVDT_SUCCESS;
93     AvdtEventData event = {0};
94     event.msg.discoverRsp.numSeps = 0;
95     event.msg.discoverRsp.hdr.errCode = AVDT_SUCCESS;
96     for (int i = 0; i < AVDT_NUM_SEPS; i++) {
97         if (sigCtrl->streamCtrl[i].isAllocated) {
98             AvdtStreamConfig *streamConfig = AvdtGetSepConfigByCodecIndex(sigCtrl->streamCtrl[i].codecIndex);
99             if (streamConfig != NULL) {
100                 event.msg.discoverRsp.seps[event.msg.discoverRsp.numSeps].mediaType =
101                     streamConfig->cfg.mediaType; /* audio or video */
102                 event.msg.discoverRsp.seps[event.msg.discoverRsp.numSeps].sepType =
103                     streamConfig->sepType; /* Source or sink */
104                 event.msg.discoverRsp.seps[event.msg.discoverRsp.numSeps].isUsed = sigCtrl->streamCtrl[i].isUsed;
105                 event.msg.discoverRsp.seps[event.msg.discoverRsp.numSeps].seid =
106                     (uint8_t)(sigCtrl->streamCtrl[i].handle);
107                 event.msg.discoverRsp.numSeps++;
108             } else {
109                 LOG_DEBUG("[AVDT]%{public}s: Failed to get SEP: index(%hu)",
110                     __func__, sigCtrl->streamCtrl[i].codecIndex);
111             }
112         }
113     }
114     AvdtSigProcEvent(sigCtrl, AVDT_DISCOVER_CMD_RSP_EVENT, &event);
115     return Ret;
116 }
117 
118 /**
119  *
120  * @brief         AvdtActDiscoverCfm
121  *
122  * @details       Test suite only.
123  *
124  * @return        uint16_t
125  *
126  */
AvdtActDiscoverCfm(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)127 uint16_t AvdtActDiscoverCfm(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
128 {
129     LOG_DEBUG("[AVDT]%{public}s:", __func__);
130     if (sigCtrl == NULL || data == NULL) {
131         return AVDT_SUCCESS;
132     }
133     uint16_t Ret = AVDT_SUCCESS;
134     sigCtrl->isProcBusy = false;
135     AvdtCtrlEvtCallback(
136         sigCtrl, sigCtrl->handle, &(sigCtrl->peerAddress), AVDT_DISCOVER_CFM_EVT, &data->ctrlData, sigCtrl->role);
137     return Ret;
138 }
139 
140 /**
141  *
142  * @brief         AvdtActGetCapReq
143  *
144  * @details       Int send the GetCapability command to get the capability matched acpid.
145  *
146  * @return        uint16_t
147  *
148  */
AvdtActGetCapReq(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)149 uint16_t AvdtActGetCapReq(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
150 {
151     LOG_DEBUG("[AVDT]%{public}s:", __func__);
152     if (sigCtrl == NULL || data == NULL) {
153         return AVDT_SUCCESS;
154     }
155     uint16_t Ret = AVDT_SUCCESS;
156     AvdtMsg message = {0};
157     /* disable call discover seps API continually */
158     sigCtrl->isProcBusy = true;
159     message.single.seid = data->getcap.single.seid;
160     AvdtMsgSendCmd(sigCtrl, NULL, AVDT_SIG_GETCAP, &message);
161     return Ret;
162 }
163 
164 /**
165  *
166  * @brief         AvdtActGetCapRsp
167  *
168  * @details       Acp send the respond of GetCapability.
169  *
170  * @return        uint16_t
171  *
172  */
AvdtActGetCapRsp(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)173 uint16_t AvdtActGetCapRsp(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
174 {
175     LOG_DEBUG("[AVDT]%{public}s:", __func__);
176     if (sigCtrl == NULL || data == NULL) {
177         return AVDT_SUCCESS;
178     }
179     uint16_t Ret = AVDT_SUCCESS;
180     if (data->msg.getcap.single.errCode == AVDT_SUCCESS) {
181         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_GETCAP, &(data->msg));
182     } else {
183         AvdtMsgSendRej(sigCtrl, AVDT_SIG_GETCAP, &(data->msg));
184     }
185     return Ret;
186 }
187 
188 /**
189  *
190  * @brief         AvdtActGetCapInd
191  *
192  * @details       Acp receive the GetCapability command and indicate to the
193  *                upper application and get the capability of local device.
194  *
195  * @return        uint16_t
196  *
197  */
AvdtActGetCapInd(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)198 uint16_t AvdtActGetCapInd(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
199 {
200     LOG_DEBUG("[AVDT]%{public}s:", __func__);
201     if (sigCtrl == NULL || data == NULL) {
202         return AVDT_SUCCESS;
203     }
204     AvdtEventData event = {0};
205     AvdtSepConfig capability = {0};
206     if (AVDT_SEID_INVLID <= data->msg.single.seid || data->msg.single.seid <= AVDT_SEID_FORBID) {
207         event.getcap.single.errCode = AVDT_ERR_BAD_ACP_SEID;
208     } else {
209         capability = AvdtGetSepConfig(sigCtrl, (uint16_t)data->getcap.single.seid);
210         event.getcap.single.errCode = AVDT_SUCCESS;
211     }
212     event.getcap.cfg = &capability;
213     AvdtSigProcEvent(sigCtrl, AVDT_GETCAP_CMD_RSP_EVENT, &event);
214     return AVDT_SUCCESS;
215 }
216 
217 /**
218  *
219  * @brief         AvdtGetSepConfig
220  *
221  * @details       Get sep config by handle
222  *
223  * @return        AvdtSepConfig
224  *
225  */
AvdtGetSepConfig(AvdtSigCtrl * sigCtrl,uint16_t handle)226 AvdtSepConfig AvdtGetSepConfig(AvdtSigCtrl *sigCtrl, uint16_t handle)
227 {
228     AvdtSepConfig capability = {0};
229     if (sigCtrl == NULL) {
230         return capability;
231     }
232     for (int i = 0; i < AVDT_NUM_SEPS; i++) {
233         if (sigCtrl->streamCtrl[i].isAllocated && sigCtrl->streamCtrl[i].handle == handle) {
234             AvdtStreamConfig *streamConfig = AvdtGetSepConfigByCodecIndex(sigCtrl->streamCtrl[i].codecIndex);
235             if (streamConfig == NULL) {
236                 continue;
237             }
238             capability.pscMask = streamConfig->cfg.pscMask;
239             capability.mediaType = streamConfig->cfg.mediaType;
240             capability.numCodec = streamConfig->cfg.numCodec;
241             for (int j = 0; j < (capability.numCodec + 1); j++) {
242                 capability.codecInfo[j] = streamConfig->cfg.codecInfo[j];
243             }
244 
245             LOG_DEBUG("[AVDT]%{public}s: GetCapdata acpid(%hu),capability.pscMask(%hu),capability.numCodec(%hhu) ",
246                 __func__,
247                 sigCtrl->streamCtrl[i].handle,
248                 capability.pscMask,
249                 capability.numCodec);
250             break;
251         }
252     }
253     return capability;
254 }
255 /**
256  *
257  * @brief         AvdtActGetCapCfm
258  *
259  * @details       Test suite only.
260  *
261  * @return        uint16_t
262  *
263  */
AvdtActGetCapCfm(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)264 uint16_t AvdtActGetCapCfm(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
265 {
266     LOG_DEBUG("[AVDT]%{public}s:", __func__);
267     if (sigCtrl == NULL || data == NULL) {
268         return AVDT_SUCCESS;
269     }
270     uint16_t Ret = AVDT_SUCCESS;
271     sigCtrl->isProcBusy = false;
272     AvdtCtrlEvtCallback(
273         sigCtrl, sigCtrl->handle, &(sigCtrl->peerAddress), AVDT_GETCAP_CFM_EVT, &data->ctrlData, sigCtrl->role);
274     return Ret;
275 }
276 
277 /**
278  *
279  * @brief         AvdtActGetAllCapReq
280  *
281  * @details       Int send the GetAllCapability to get all capability matched acp seid.
282  *
283  * @return        uint16_t
284  *
285  */
AvdtActGetAllCapReq(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)286 uint16_t AvdtActGetAllCapReq(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
287 {
288     LOG_DEBUG("[AVDT]%{public}s:", __func__);
289     if (sigCtrl == NULL || data == NULL) {
290         return AVDT_SUCCESS;
291     }
292     uint16_t Ret = AVDT_SUCCESS;
293     AvdtMsg message = {0};
294     /* disable call discover seps API continually */
295     sigCtrl->isProcBusy = true;
296     message.single.seid = data->getcap.single.seid;
297     LOG_DEBUG("[AVDT]%{public}s: Reqacpid(%hhu) ", __func__, data->getcap.single.seid);
298     AvdtMsgSendCmd(sigCtrl, NULL, AVDT_SIG_GET_ALLCAP, &message);
299     return Ret;
300 }
301 
302 /**
303  *
304  * @brief         AvdtActGetAllCapRsp
305  *
306  * @details       Acl send the respond of get all capability
307  *
308  * @return        uint16_t
309  *
310  */
AvdtActGetAllCapRsp(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)311 uint16_t AvdtActGetAllCapRsp(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
312 {
313     LOG_DEBUG("[AVDT]%{public}s:", __func__);
314     if (sigCtrl == NULL || data == NULL) {
315         return AVDT_SUCCESS;
316     }
317     uint16_t Ret = AVDT_SUCCESS;
318     if (data->msg.getcap.single.errCode == AVDT_SUCCESS) {
319         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_GET_ALLCAP, &(data->msg));
320     } else {
321         AvdtMsgSendRej(sigCtrl, AVDT_SIG_GET_ALLCAP, &(data->msg));
322     }
323     return Ret;
324 }
325 
326 /**
327  *
328  * @brief         AvdtActGetAllCapInd
329  *
330  * @details       Acp receive the command of GetAllCapability and indicate to
331  *                the upper application and get all capability of local device.
332  *
333  * @return        uint16_t
334  *
335  ******************************************************************************/
AvdtActGetAllCapInd(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)336 uint16_t AvdtActGetAllCapInd(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
337 {
338     if (sigCtrl == NULL || data == NULL) {
339         return AVDT_SUCCESS;
340     }
341     LOG_DEBUG("[AVDT]%{public}s: seid(0x%x)", __func__, data->msg.single.seid);
342     AvdtSepConfig capability = {0};
343     AvdtEventData event = {0};
344     if (AVDT_SEID_INVLID <= data->msg.single.seid || data->msg.single.seid <= AVDT_SEID_FORBID) {
345         event.getcap.single.errCode = AVDT_ERR_BAD_ACP_SEID;
346     } else {
347         capability = AvdtGetSepConfig(sigCtrl, (uint16_t)data->getcap.single.seid);
348         event.getcap.single.errCode = AVDT_SUCCESS;
349     }
350     event.getcap.cfg = &capability;
351     AvdtSigProcEvent(sigCtrl, AVDT_GETALLCAP_CMD_RSP_EVENT, &event);
352     return AVDT_SUCCESS;
353 }
354 
355 /**
356  *
357  * @brief         AvdtActGetAllCapCfm
358  *
359  * @details       Test suite only.
360  *
361  * @return        uint16_t
362  *
363  */
AvdtActGetAllCapCfm(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)364 uint16_t AvdtActGetAllCapCfm(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
365 {
366     LOG_DEBUG("[AVDT]%{public}s:", __func__);
367     if (sigCtrl == NULL || data == NULL) {
368         return AVDT_SUCCESS;
369     }
370     uint16_t Ret = AVDT_SUCCESS;
371     sigCtrl->isProcBusy = false;
372     AvdtCtrlEvtCallback(
373         sigCtrl, sigCtrl->handle, &(sigCtrl->peerAddress), AVDT_GET_ALLCAP_CFM_EVT, &data->ctrlData, sigCtrl->role);
374     return Ret;
375 }
376 
377 /**
378  *
379  * @brief         AvdtActSetConfigReq
380  *
381  * @details       Int send the command of SetConfig to configure the stream.
382  *
383  * @return        uint16_t
384  *
385  */
AvdtActSetConfigReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)386 uint16_t AvdtActSetConfigReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
387 {
388     LOG_DEBUG("[AVDT]%{public}s:", __func__);
389     if (streamCtrl == NULL || data == NULL) {
390         return AVDT_SUCCESS;
391     }
392     uint16_t Ret = AVDT_SUCCESS;
393     /* disable call discover seps API continually */
394     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
395     AvdtTransChannel *transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_SIG, sigCtrl->handle);
396     if (transTbl == NULL) {
397         /* Trace no resources parameter */
398         LOG_ERROR("[AVDT]%{public}s: Not find the transTbl", __func__);
399         return Ret;
400     }
401     transTbl->streamHandle = data->msg.configureCmd.intSeid;
402     sigCtrl->streamHandle = data->msg.configureCmd.intSeid;
403     /* set init role */
404     LOG_DEBUG("[AVDT]%{public}s: transTbl->streamHandle(%hu)", __func__, transTbl->streamHandle);
405     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_SETCONFIG, &data->msg);
406     return Ret;
407 }
408 
409 /**
410  *
411  * @brief         AvdtActSetConfigRsp
412  *
413  * @details       Acceptor send respond of configure successfully.
414  *
415  * @return        uint16_t
416  *
417  */
AvdtActSetConfigRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)418 uint16_t AvdtActSetConfigRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
419 {
420     if (data == NULL || streamCtrl == NULL) {
421         return AVDT_SUCCESS;
422     }
423     LOG_DEBUG("[AVDT]%{public}s: errorcode(%hhu)", __func__, data->msg.configureCmd.hdr.errCode);
424     uint16_t Ret = AVDT_SUCCESS;
425     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
426     if (data->msg.configureCmd.hdr.errCode == AVDT_SUCCESS) {
427         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_SETCONFIG, NULL);
428         (void)memcpy_s(&streamCtrl->currCfg, sizeof(AvdtSepConfig), &streamCtrl->reqCfg, sizeof(AvdtSepConfig));
429         streamCtrl->isUsed = true;
430     } else {
431         AvdtMsgSendRej(sigCtrl, AVDT_SIG_SETCONFIG, &data->msg);
432     }
433     return Ret;
434 }
435 
436 /**
437  *
438  * @brief         AvdtActSetConfigInd
439  *
440  * @details       Acp receive the command ConfigInd from remote device
441  *                and indicate to the upper application.
442  *
443  * @return        uint16_t
444  *
445  */
AvdtActSetConfigInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)446 uint16_t AvdtActSetConfigInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
447 {
448     LOG_DEBUG("[AVDT]%{public}s:", __func__);
449     if (streamCtrl == NULL || data == NULL) {
450         return AVDT_SUCCESS;
451     }
452     uint16_t Ret = AVDT_SUCCESS;
453     AvdtCtrlData confirmData = {0};
454     AvdtTransChannel *transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_SIG, streamCtrl->sigHandle);
455     if (transTbl == NULL) {
456         /* Trace no resources parameter */
457         LOG_ERROR("[AVDT]%{public}s: Not fined the transTbl", __func__);
458         return Ret;
459     }
460     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
461     transTbl->streamHandle = streamCtrl->handle;
462     sigCtrl->streamHandle = streamCtrl->handle;
463     LOG_DEBUG("[AVDT]%{public}s: transTbl->streamHandle(%hu)", __func__, transTbl->streamHandle);
464     /* Acceptor set role */
465     if (!streamCtrl->isUsed) {
466         AvdtIsEdr2MbMode(&sigCtrl->peerAddress);
467         AvdtIsEdr3MbMode(&sigCtrl->peerAddress);
468         AvdtStreamConfig *streamConfig = AvdtGetSepConfigByCodecIndex(streamCtrl->codecIndex);
469         if (streamConfig != NULL) {
470             sigCtrl->role = streamConfig->sepType;
471         }
472         streamCtrl->peerSeid = data->msg.configureCmd.intSeid;
473         confirmData.configInd.acpSeid = data->msg.configureCmd.acpSeid;
474         confirmData.configInd.intSeid = data->msg.configureCmd.intSeid;
475         confirmData.configInd.hdr.mtu = transTbl->peerMtu;
476         (void)memcpy_s(&confirmData.configInd.cfg, sizeof(AvdtSepConfig), &(streamCtrl->reqCfg), sizeof(AvdtSepConfig));
477         AvdtCtrlEvtCallback(
478             sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_CONFIG_IND_EVT, &confirmData, sigCtrl->role);
479     } else {
480         AvdtIndReject(sigCtrl, AVDT_SIG_SETCONFIG, AVDT_ERR_SEP_IN_USE, 0);
481     }
482     return Ret;
483 }
484 
485 /**
486  *
487  * @brief         AvdtActSetConfigCfm
488  *
489  * @details       Test suite only.
490  *
491  * @return        uint16_t
492  *
493  */
AvdtActSetConfigCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)494 uint16_t AvdtActSetConfigCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
495 {
496     LOG_DEBUG("[AVDT]%{public}s:", __func__);
497     if (streamCtrl == NULL || data == NULL) {
498         return AVDT_SUCCESS;
499     }
500     uint16_t Ret = AVDT_SUCCESS;
501     streamCtrl->isUsed = true;
502     (void)memcpy_s(&streamCtrl->currCfg, sizeof(AvdtSepConfig), &streamCtrl->reqCfg, sizeof(AvdtSepConfig));
503     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
504     AvdtCtrlEvtCallback(
505         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_CONFIG_CFM_EVT, &data->ctrlData, sigCtrl->role);
506     return Ret;
507 }
508 
509 /**
510  *
511  * @brief         AvdtActGetConfigReq
512  *
513  * @details       Int sent the command of GetConfigReq to get current configure of stream.
514  *
515  * @return        uint16_t
516  *
517  */
AvdtActGetConfigReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)518 uint16_t AvdtActGetConfigReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
519 {
520     LOG_DEBUG("[AVDT]%{public}s:", __func__);
521     if (streamCtrl == NULL || data == NULL) {
522         return AVDT_SUCCESS;
523     }
524     uint16_t Ret = AVDT_SUCCESS;
525     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
526     AvdtMsg message = {0};
527     /* disable call discover seps API continually */
528     message.configureCmd.acpSeid = data->msg.single.seid;
529     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_GETCONFIG, &message);
530     return Ret;
531 }
532 
533 /**
534  *
535  * @brief         AvdtActGetConfigRsp
536  *
537  * @details       Acp send the repond of GetConfig.
538  *
539  * @return        uint16_t
540  *
541  */
AvdtActGetConfigRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)542 uint16_t AvdtActGetConfigRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
543 {
544     LOG_DEBUG("[AVDT]%{public}s:", __func__);
545     if (streamCtrl == NULL || data == NULL) {
546         return AVDT_SUCCESS;
547     }
548     uint16_t Ret = AVDT_SUCCESS;
549     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
550     if (data->msg.configureCmd.hdr.errCode == AVDT_SUCCESS) {
551         AvdtMsgSendRsp(sigCtrl, streamCtrl, AVDT_SIG_GETCONFIG, &(data->msg));
552     } else {
553         AvdtMsgSendRej(sigCtrl, AVDT_SIG_GETCONFIG, &data->msg);
554     }
555     return Ret;
556 }
557 
558 /**
559  *
560  * @brief         AvdtActGetConfigInd
561  *
562  * @details       Acp receive the command of GetConfig and indicate to the upper
563  *                application and get the configure information of stream.
564  *
565  * @return        uint16_t
566  *
567  */
AvdtActGetConfigInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)568 uint16_t AvdtActGetConfigInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
569 {
570     LOG_DEBUG("[AVDT]%{public}s:", __func__);
571     if (streamCtrl == NULL || data == NULL) {
572         return AVDT_SUCCESS;
573     }
574     uint16_t Ret = AVDT_SUCCESS;
575     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
576     AvdtSepConfig capability = {0};
577     AvdtEventData event = {0};
578     uint8_t seid = data->msg.single.seid;
579     if ((seid >= AVDT_SEID_INVLID) || (seid == AVDT_SEID_FORBID)) {
580         event.getcap.single.errCode = AVDT_ERR_BAD_ACP_SEID;
581         event.getcap.cfg = &capability;
582     } else {
583         event.getcap.single.errCode = AVDT_SUCCESS;
584         event.getcap.cfg = &capability;
585         capability = AvdtGetConfig(sigCtrl, (uint16_t)data->msg.single.seid);
586     }
587     AvdtStreamProcEvent(streamCtrl, AVDT_GETCONFIGURE_CMD_RSP_EVENT, &event);
588     return Ret;
589 }
AvdtGetConfig(AvdtSigCtrl * sigCtrl,uint16_t handle)590 AvdtSepConfig AvdtGetConfig(AvdtSigCtrl *sigCtrl, uint16_t handle)
591 {
592     AvdtSepConfig capability = {0};
593     if (sigCtrl == NULL) {
594         return capability;
595     }
596     for (int i = 0; i < AVDT_NUM_SEPS; i++) {
597         if (sigCtrl->streamCtrl[i].isAllocated && sigCtrl->streamCtrl[i].handle == handle) {
598             capability.pscMask = sigCtrl->streamCtrl[i].currCfg.cfg.pscMask;
599             capability.numCodec = sigCtrl->streamCtrl[i].currCfg.cfg.numCodec;
600             capability.mediaType = sigCtrl->streamCtrl[i].currCfg.cfg.mediaType;
601             for (int j = 0; j < capability.numCodec; j++) {
602                 capability.codecInfo[j] = sigCtrl->streamCtrl[i].currCfg.cfg.codecInfo[j];
603             }
604             LOG_DEBUG("[AVDT]%{public}s: sepNumber(%{public}d),seid(%hu),capability.pscMask(%hu),"
605                 "capability.numCodec(%hhu)",
606                 __func__,
607                 i,
608                 handle,
609                 capability.pscMask,
610                 capability.numCodec);
611             break;
612         }
613     }
614     return capability;
615 }
616 
617 /**
618  *
619  * @brief         AvdtActGetConfigCfm
620  *
621  * @details       Test suite only.
622  *
623  * @return        uint16_t
624  *
625  */
AvdtActGetConfigCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)626 uint16_t AvdtActGetConfigCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
627 {
628     LOG_DEBUG("[AVDT]%{public}s:", __func__);
629     if (streamCtrl == NULL || data == NULL) {
630         return AVDT_SUCCESS;
631     }
632     uint16_t Ret = AVDT_SUCCESS;
633     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
634     AvdtCtrlEvtCallback(
635         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_GETCONFIG_CFM_EVT, &data->ctrlData, sigCtrl->role);
636     return Ret;
637 }
638 
639 /**
640  *
641  * @brief         AvdtActReconfigReq
642  *
643  * @details       Int send the command of Reconfigure to change the codec parameters
644  *                of stream.
645  *
646  * @return        uint16_t
647  *
648  */
AvdtActReconfigReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)649 uint16_t AvdtActReconfigReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
650 {
651     LOG_DEBUG("[AVDT]%{public}s:", __func__);
652     if (streamCtrl == NULL || data == NULL) {
653         return AVDT_SUCCESS;
654     }
655     uint16_t Ret = AVDT_SUCCESS;
656     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
657     /* disable call discover seps API continually */
658     (void)memcpy_s(&streamCtrl->currCfg, sizeof(AvdtSepConfig), &data->msg.reconfigureCmd.cfg, sizeof(AvdtSepConfig));
659     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_RECONFIG, &data->msg);
660     return Ret;
661 }
662 
663 /**
664  *
665  * @brief         AvdtActReconfigRsp
666  *
667  * @details       Acp send respond of Reconfigure.
668  *
669  * @return        uint16_t
670  *
671  */
AvdtActReconfigRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)672 uint16_t AvdtActReconfigRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
673 {
674     LOG_DEBUG("[AVDT]%{public}s:", __func__);
675     if (streamCtrl == NULL || data == NULL) {
676         return AVDT_SUCCESS;
677     }
678     uint16_t Ret = AVDT_SUCCESS;
679     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
680     if (data->msg.configureCmd.hdr.errCode == AVDT_SUCCESS) {
681         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_RECONFIG, NULL);
682     } else {
683         AvdtMsgSendRej(sigCtrl, AVDT_SIG_RECONFIG, &data->msg);
684     }
685     return Ret;
686 }
687 
688 /**
689  *
690  * @brief         AvdtActReconfigInd
691  *
692  * @details       Acp receive the command of Reconfigure and indicate to the
693  *                upper application.
694  *
695  * @return        uint16_t
696  *
697  */
AvdtActReconfigInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)698 uint16_t AvdtActReconfigInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
699 {
700     LOG_DEBUG("[AVDT]%{public}s:", __func__);
701     if (streamCtrl == NULL || data == NULL) {
702         return AVDT_SUCCESS;
703     }
704     uint16_t Ret = AVDT_SUCCESS;
705     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
706     AvdtCtrlData confirmData = {0};
707     confirmData.reconfigInd.hdr.seid = data->msg.reconfigureCmd.hdr.seid;
708     (void)memcpy_s(&confirmData.reconfigInd.cfg, sizeof(AvdtSepConfig), &(streamCtrl->reqCfg), sizeof(AvdtSepConfig));
709     AvdtCtrlEvtCallback(
710         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_RECONFIG_IND_EVT, &confirmData, sigCtrl->role);
711     return Ret;
712 }
713 
714 /**
715  *
716  * @brief         AvdtActReconfigCfm
717  *
718  * @details       Test suit only.
719  *
720  * @return        uint16_t
721  *
722  */
AvdtActReconfigCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)723 uint16_t AvdtActReconfigCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
724 {
725     LOG_DEBUG("[AVDT]%{public}s:", __func__);
726     if (streamCtrl == NULL || data == NULL) {
727         return AVDT_SUCCESS;
728     }
729     uint16_t Ret = AVDT_SUCCESS;
730     (void)memcpy_s(&streamCtrl->currCfg, sizeof(AvdtSepConfig), &streamCtrl->reqCfg, sizeof(AvdtSepConfig));
731     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
732     AvdtCtrlEvtCallback(
733         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_RECONFIG_CFM_EVT, &data->ctrlData, sigCtrl->role);
734     return Ret;
735 }
736 
737 /**
738  *
739  * @brief        AvdtActOpenReq
740  *
741  * @details      Initator send open command.
742  *
743  * @return       uint16_t
744  *
745  */
AvdtActOpenReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)746 uint16_t AvdtActOpenReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
747 {
748     LOG_DEBUG("[AVDT]%{public}s:", __func__);
749     if (streamCtrl == NULL || data == NULL) {
750         return AVDT_SUCCESS;
751     }
752     uint16_t Ret = AVDT_SUCCESS;
753     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
754     AvdtMsg message = {0};
755     sigCtrl->ia = AVDT_INT;
756     message.single.seid = data->msg.single.seid;
757     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_OPEN, &message);
758     return Ret;
759 }
760 
761 /**
762  *
763  * @brief         AvdtActOpenRsp
764  *
765  * @details       Acceptor send respond of open requirement .
766  *
767  * @return        uint16_t
768  *
769  */
AvdtActOpenRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)770 uint16_t AvdtActOpenRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
771 {
772     LOG_DEBUG("[AVDT]%{public}s:", __func__);
773     if (streamCtrl == NULL || data == NULL) {
774         return AVDT_SUCCESS;
775     }
776     uint16_t Ret = AVDT_SUCCESS;
777     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
778     if (data->msg.single.errCode == AVDT_SUCCESS) {
779         AvdtMsgSendRsp(sigCtrl, streamCtrl, AVDT_SIG_OPEN, &data->msg);
780     } else {
781         AvdtMsgSendRej(sigCtrl, AVDT_SIG_OPEN, &data->msg);
782     }
783     return Ret;
784 }
785 
786 /**
787  *
788  * @brief         AvdtActOpenInd
789  *
790  * @details       Acp receive the open requirement from remote peer and
791  *                check and send the respnd.
792  *
793  * @return        uint16_t
794  *
795  */
AvdtActOpenInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)796 uint16_t AvdtActOpenInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
797 {
798     LOG_DEBUG("[AVDT]%{public}s:", __func__);
799     if (streamCtrl == NULL || data == NULL) {
800         return AVDT_SUCCESS;
801     }
802     uint16_t Ret = AVDT_SUCCESS;
803     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
804     uint8_t seid = data->msg.single.seid;
805     if (AVDT_SEID_INVLID <= seid || seid == AVDT_SEID_FORBID) {
806         data->msg.single.errCode = AVDT_ERR_BAD_ACP_SEID;
807     } else {
808         sigCtrl->ia = AVDT_ACP;
809         data->msg.single.errCode = AVDT_SUCCESS;
810         sigCtrl->streamHandle = streamCtrl->handle;
811     }
812     AvdtStreamProcEvent(streamCtrl, AVDT_OPEN_CMD_RSP_EVENT, data);
813     return Ret;
814 }
815 
816 /**
817  *
818  * @brief         AvdtActOpenCfm
819  *
820  * @details       Test suite only.
821  *
822  * @return        uint16_t
823  *
824  */
AvdtActOpenCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)825 uint16_t AvdtActOpenCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
826 {
827     LOG_DEBUG("[AVDT]%{public}s:", __func__);
828     uint16_t Ret = AVDT_SUCCESS;
829     if (streamCtrl == NULL) {
830         return AVDT_SUCCESS;
831     }
832     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
833     AvdtStreamProcEvent(streamCtrl, AVDT_STREAM_OPEN_CMD_REQ_EVENT, data);
834     sigCtrl->streamHandle = streamCtrl->handle;
835     return Ret;
836 }
837 
838 /**
839  *
840  * @brief        AvdtActSuspendReq
841  *
842  * @details      Initator send suspend command.
843  *
844  * @return       uint16_t
845  *
846  */
AvdtActSuspendReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)847 uint16_t AvdtActSuspendReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
848 {
849     LOG_DEBUG("[AVDT]%{public}s:", __func__);
850     if (streamCtrl == NULL || data == NULL) {
851         return AVDT_SUCCESS;
852     }
853     uint16_t Ret = AVDT_SUCCESS;
854     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
855     AvdtMsg message = {0};
856     message.single.seid = data->msg.single.seid;
857     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_SUSPEND, &message);
858     return Ret;
859 }
860 
861 /**
862  *
863  * @brief        AvdtActSuspendRsp
864  *
865  * @details      Acp send  the respond of suspend command.
866  *
867  * @return       uint16_t
868  *
869  */
AvdtActSuspendRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)870 uint16_t AvdtActSuspendRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
871 {
872     LOG_DEBUG("[AVDT]%{public}s:", __func__);
873     if (streamCtrl == NULL || data == NULL) {
874         return AVDT_SUCCESS;
875     }
876     uint16_t Ret = AVDT_SUCCESS;
877     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
878     if (data->msg.single.errCode == AVDT_SUCCESS) {
879         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_SUSPEND, NULL);
880     } else {
881         AvdtMsgSendRej(sigCtrl, AVDT_SIG_SUSPEND, &data->msg);
882     }
883     return Ret;
884 }
885 
886 /**
887  *
888  * @brief        AvdtActSuspendInd
889  *
890  * @details      Acp receive the command of suspend command and indicate to
891  *               the upper application.
892  *
893  * @return       uint16_t
894  *
895  */
AvdtActSuspendInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)896 uint16_t AvdtActSuspendInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
897 {
898     LOG_DEBUG("[AVDT]%{public}s:", __func__);
899     if (streamCtrl == NULL || data == NULL) {
900         return AVDT_SUCCESS;
901     }
902     uint16_t Ret = AVDT_SUCCESS;
903     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
904     AvdtCtrlData confirmData = {0};
905     uint8_t seid = data->msg.single.seid;
906     if (AVDT_SEID_INVLID <= seid || seid == AVDT_SEID_FORBID) {
907         AvdtMsg msg = {0};
908         msg.single.errCode = AVDT_ERR_BAD_ACP_SEID;
909         AvdtMsgSendRej(sigCtrl, AVDT_SIG_SUSPEND, &msg);
910         return Ret;
911     }
912     confirmData.suspendInd.seid = (uint16_t)data->msg.single.seid;
913     confirmData.suspendInd.label = data->msg.single.label;
914     AvdtCtrlEvtCallback(
915         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_SUSPEND_IND_EVT, &confirmData, sigCtrl->role);
916     return Ret;
917 }
918 
919 /**
920  *
921  * @brief        AvdtActSuspendCfm
922  *
923  * @details      Test suite only.
924  *
925  * @return       uint16_t
926  *
927  */
AvdtActSuspendCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)928 uint16_t AvdtActSuspendCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
929 {
930     LOG_DEBUG("[AVDT]%{public}s:", __func__);
931     if (streamCtrl == NULL || data == NULL) {
932         return AVDT_SUCCESS;
933     }
934     uint16_t Ret = AVDT_SUCCESS;
935     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
936     AvdtCtrlEvtCallback(
937         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_SUSPEND_CFM_EVT, &data->ctrlData, sigCtrl->role);
938     return Ret;
939 }
940 
941 /**
942  *
943  * @brief        AvdtActStartReq
944  *
945  * @details      Initator send suspend command.
946  *
947  * @return       uint16_t
948  *
949  */
AvdtActStartReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)950 uint16_t AvdtActStartReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
951 {
952     LOG_DEBUG("[AVDT]%{public}s:", __func__);
953     if (streamCtrl == NULL || data == NULL) {
954         return AVDT_SUCCESS;
955     }
956     uint16_t Ret = AVDT_SUCCESS;
957     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
958     AvdtMsg message = {0};
959     message.single.seid = data->msg.single.seid;
960     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_START, &message);
961     return Ret;
962 }
963 
964 /**
965  *
966  * @brief        AvdtActStartRsp
967  *
968  * @details      Acp send  the respond of start command.
969  *
970  * @return       uint16_t
971  *
972  */
AvdtActStartRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)973 uint16_t AvdtActStartRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
974 {
975     LOG_DEBUG("[AVDT]%{public}s:", __func__);
976     if (streamCtrl == NULL || data == NULL) {
977         return AVDT_SUCCESS;
978     }
979     uint16_t Ret = AVDT_SUCCESS;
980     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
981     if (data->msg.single.errCode == AVDT_SUCCESS) {
982         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_START, NULL);
983     } else {
984         AvdtMsgSendRej(sigCtrl, AVDT_SIG_START, &data->msg);
985     }
986     return Ret;
987 }
988 
989 /**
990  *
991  * @brief        AvdtActStartInd
992  *
993  * @details      Acp receive the command of start command and indicate to
994  *               the upper application.
995  *
996  * @return       uint16_t
997  *
998  */
AvdtActStartInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)999 uint16_t AvdtActStartInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1000 {
1001     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1002     if (streamCtrl == NULL || data == NULL) {
1003         return AVDT_SUCCESS;
1004     }
1005     uint16_t Ret = AVDT_SUCCESS;
1006     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1007     AvdtCtrlData confirmData = {0};
1008     confirmData.startInd.seid = (uint16_t)data->msg.single.seid;
1009     confirmData.startInd.label = data->msg.single.label;
1010     confirmData.startInd.mtu = sigCtrl->edr;
1011     AvdtCtrlEvtCallback(
1012         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_START_IND_EVT, &confirmData, sigCtrl->role);
1013     return Ret;
1014 }
1015 
1016 /**
1017  *
1018  * @brief        AvdtActStartCfm
1019  *
1020  * @details      Test suite only.
1021  *
1022  * @return       uint16_t
1023  *
1024  */
AvdtActStartCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1025 uint16_t AvdtActStartCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1026 {
1027     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1028     if (streamCtrl == NULL || data == NULL) {
1029         return AVDT_SUCCESS;
1030     }
1031     uint16_t Ret = AVDT_SUCCESS;
1032     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1033     data->ctrlData.startCfm.mtu = sigCtrl->edr;
1034     AvdtCtrlEvtCallback(
1035         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_START_CFM_EVT, &data->ctrlData, sigCtrl->role);
1036     return Ret;
1037 }
1038 
1039 /**
1040  *
1041  * @brief        AvdtActCloseReq
1042  *
1043  * @details      Initator send close stream command.
1044  *
1045  * @return       uint16_t
1046  *
1047  */
AvdtActCloseReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1048 uint16_t AvdtActCloseReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1049 {
1050     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1051     if (streamCtrl == NULL || data == NULL) {
1052         return AVDT_SUCCESS;
1053     }
1054     uint16_t Ret = AVDT_SUCCESS;
1055     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1056     AvdtMsg message = {0};
1057     message.single.seid = data->msg.single.seid;
1058     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_CLOSE, &message);
1059     return Ret;
1060 }
1061 
1062 /**
1063  *
1064  * @brief        AvdtActCloseRsp
1065  *
1066  * @details      Acp send  the respond of close stream command.
1067  *
1068  * @return       uint16_t
1069  *
1070  */
AvdtActCloseRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1071 uint16_t AvdtActCloseRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1072 {
1073     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1074     if (streamCtrl == NULL || data == NULL) {
1075         return AVDT_SUCCESS;
1076     }
1077     uint16_t Ret = AVDT_SUCCESS;
1078     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1079     if (data->msg.single.errCode == AVDT_SUCCESS) {
1080         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_CLOSE, NULL);
1081     } else {
1082         AvdtMsgSendRej(sigCtrl, AVDT_SIG_CLOSE, &data->msg);
1083     }
1084     return Ret;
1085 }
1086 
1087 /**
1088  *
1089  * @brief        AvdtActCloseInd
1090  *
1091  * @details      Acp receive the command of close command and indicate to
1092  *               the upper application.
1093  *
1094  * @return       uint16_t
1095  *
1096  */
AvdtActCloseInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1097 uint16_t AvdtActCloseInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1098 {
1099     if (streamCtrl == NULL || data == NULL) {
1100         return AVDT_SUCCESS;
1101     }
1102     LOG_DEBUG("[AVDT]%{public}s: streamCtrl->state(%hhu)", __func__, streamCtrl->state);
1103     uint16_t Ret = AVDT_SUCCESS;
1104     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1105     AvdtCtrlData confirmData = {0};
1106     confirmData.closeInd.seid = (uint16_t)data->msg.single.seid;
1107     AvdtCtrlEvtCallback(
1108         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_CLOSE_IND_EVT, &confirmData, sigCtrl->role);
1109     return Ret;
1110 }
1111 
1112 /**
1113  *
1114  * @brief        AvdtActCloseCfm
1115  *
1116  * @details      Test suite only.
1117  *
1118  * @return       uint16_t
1119  *
1120  */
AvdtActCloseCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1121 uint16_t AvdtActCloseCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1122 {
1123     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1124     if (streamCtrl == NULL) {
1125         return AVDT_SUCCESS;
1126     }
1127     uint16_t Ret = AVDT_SUCCESS;
1128     AvdtTransChannel *transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_STREAM, streamCtrl->handle);
1129     if (transTbl != NULL) {
1130         L2CIF_DisconnectionReq(transTbl->lcid, NULL);
1131         LOG_DEBUG("[AVDT]%{public}s: mediachannel lcid(0x%x) ", __func__, transTbl->lcid);
1132     } else {
1133         LOG_ERROR("[AVDT]%{public}s: Not fine the transTbl", __func__);
1134     }
1135     return Ret;
1136 }
1137 
1138 /**
1139  *
1140  * @brief        AvdtActDelayRptReq
1141  *
1142  * @details      Initator send delay command.
1143  *
1144  * @return       uint16_t
1145  *
1146  */
AvdtActDelayRptReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1147 uint16_t AvdtActDelayRptReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1148 {
1149     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1150     if (streamCtrl == NULL || data == NULL) {
1151         return AVDT_SUCCESS;
1152     }
1153     uint16_t Ret = AVDT_SUCCESS;
1154     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1155     AvdtMsg message = {0};
1156     message.delayRptCmd.delay = data->apiDelay.delay;
1157     message.delayRptCmd.hdr.seid = data->apiDelay.hdr.seid;
1158     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_DELAY_RPT, &message);
1159     return Ret;
1160 }
1161 
1162 /**
1163  *
1164  * @brief        AvdtActDelayRptRsp
1165  *
1166  * @details      Acp send  the respond of delay command.
1167  *
1168  * @return       uint16_t
1169  *
1170  */
AvdtActDelayRptRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1171 uint16_t AvdtActDelayRptRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1172 {
1173     LOG_INFO("[AVDT]%{public}s:", __func__);
1174     uint16_t Ret = AVDT_SUCCESS;
1175     if (streamCtrl == NULL || data == NULL) {
1176         LOG_ERROR("[AVDT]%{public}s: streamCtrl or data is null", __func__);
1177         return AVDT_SUCCESS;
1178     }
1179     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1180     if (data->msg.single.errCode == AVDT_SUCCESS) {
1181         AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_DELAY_RPT, &data->msg);
1182     } else {
1183         AvdtMsgSendRej(sigCtrl, AVDT_SIG_DELAY_RPT, &data->msg);
1184     }
1185     return Ret;
1186 }
1187 
1188 /**
1189  *
1190  * @brief        AvdtActDelayRptInd
1191  *
1192  * @details      Acp receive the command of delay command and indicate to
1193  *               the upper application.
1194  *
1195  * @return       uint16_t
1196  *
1197  */
AvdtActDelayRptInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1198 uint16_t AvdtActDelayRptInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1199 {
1200     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1201     if (streamCtrl == NULL || data == NULL) {
1202         return AVDT_SUCCESS;
1203     }
1204     LOG_INFO("[AVDT]%{public}s: delay value is %{public}d ", __func__, data->msg.delayRptCmd.delay);
1205     uint16_t Ret = AVDT_SUCCESS;
1206     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1207     AvdtCtrlData confirmData = {0};
1208     confirmData.delayRptInd.delay = data->msg.delayRptCmd.delay;
1209     confirmData.delayRptInd.hdr.seid = data->msg.delayRptCmd.hdr.seid;
1210     AvdtCtrlEvtCallback(
1211         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_DELAY_REPORT_IND_EVT, &confirmData, sigCtrl->role);
1212     AvdtStreamProcEvent(streamCtrl, AVDT_DELAY_CMD_RSP_EVENT, data);
1213     return Ret;
1214 }
1215 
1216 /**
1217  *
1218  * @brief        AvdtActDelayRptCfm
1219  *
1220  * @details      Test suite only.
1221  *
1222  * @return       uint16_t
1223  *
1224  */
AvdtActDelayRptCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1225 uint16_t AvdtActDelayRptCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1226 {
1227     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1228     if (streamCtrl == NULL || data == NULL) {
1229         return AVDT_SUCCESS;
1230     }
1231     uint16_t Ret = AVDT_SUCCESS;
1232     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1233     AvdtCtrlEvtCallback(sigCtrl,
1234         streamCtrl->handle,
1235         &(sigCtrl->peerAddress),
1236         AVDT_DELAY_REPORT_CFM_EVT,
1237         &data->ctrlData,
1238         sigCtrl->role);
1239     return Ret;
1240 }
1241 
1242 /**
1243  *
1244  * @brief        AvdtActAbortReq
1245  *
1246  * @details      Initator send the command of abort.
1247  *
1248  * @return       uint16_t
1249  *
1250  */
AvdtActAbortReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1251 uint16_t AvdtActAbortReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1252 {
1253     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1254     if (streamCtrl == NULL || data == NULL) {
1255         return AVDT_SUCCESS;
1256     }
1257     uint16_t Ret = AVDT_SUCCESS;
1258     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1259     AvdtMsg message = {0};
1260     message.single.seid = data->msg.single.seid;
1261     AvdtMsgSendCmd(sigCtrl, streamCtrl, AVDT_SIG_ABORT, &message);
1262     return Ret;
1263 }
1264 
1265 /**
1266  *
1267  * @brief        AvdtActAbortRsp
1268  *
1269  * @details      Acp send the respond of abort command.
1270  *
1271  * @return       uint16_t
1272  *
1273  */
AvdtActAbortRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1274 uint16_t AvdtActAbortRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1275 {
1276     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1277     if (streamCtrl == NULL) {
1278         return AVDT_SUCCESS;
1279     }
1280     uint16_t Ret = AVDT_SUCCESS;
1281     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1282     AvdtMsgSendRsp(sigCtrl, NULL, AVDT_SIG_ABORT, NULL);
1283     return Ret;
1284 }
1285 
1286 /**
1287  *
1288  * @brief        AvdtActAbortInd
1289  *
1290  * @details      Acp receive the command of abort command and indicate to
1291  *               the upper application.
1292  *
1293  * @return       uint16_t
1294  *
1295  */
AvdtActAbortInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1296 uint16_t AvdtActAbortInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1297 {
1298     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1299     if (streamCtrl == NULL) {
1300         return AVDT_SUCCESS;
1301     }
1302     uint16_t Ret = AVDT_SUCCESS;
1303     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1304     /* notify the application indication */
1305     AvdtCtrlEvtCallback(sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_ABORT_IND_EVT, NULL, sigCtrl->role);
1306     AvdtStreamProcEvent(streamCtrl, AVDT_ABORT_CMD_RSP_EVENT, NULL);
1307     return Ret;
1308 }
1309 
1310 /**
1311  *
1312  * @brief        AvdtActAbortCfm
1313  *
1314  * @details      Test suite only.
1315  *
1316  * @return       uint16_t
1317  *
1318  */
AvdtActAbortCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1319 uint16_t AvdtActAbortCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1320 {
1321     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1322     if (streamCtrl == NULL || data == NULL) {
1323         return AVDT_SUCCESS;
1324     }
1325     uint16_t Ret = AVDT_SUCCESS;
1326     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1327     AvdtCtrlEvtCallback(
1328         sigCtrl, streamCtrl->handle, &(sigCtrl->peerAddress), AVDT_ABORT_CFM_EVT, &data->ctrlData, sigCtrl->role);
1329     return Ret;
1330 }
1331 
1332 /**
1333  *
1334  * @brief        AvdtActWriteReq
1335  *
1336  * @details      Source send mediapacket.
1337  *
1338  * @return       uint16_t
1339  *
1340  */
AvdtActWriteReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1341 uint16_t AvdtActWriteReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1342 {
1343     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1344     if (streamCtrl == NULL || data == NULL) {
1345         return AVDT_SUCCESS;
1346     }
1347     uint16_t Ret = AVDT_SUCCESS;
1348     uint32_t ssrc = 0;
1349     AvdtStreamConfig *streamConfig = AvdtGetSepConfigByCodecIndex(streamCtrl->codecIndex);
1350     if (streamConfig != NULL) {
1351         ssrc = (uint32_t)(streamConfig->cfg.codecInfo[AVDT_CODEC_OFFSET_MEDIA_TYPE] |
1352                           streamConfig->cfg.codecInfo[AVDT_CODEC_OFFSET_CODEC_TYPE]);
1353         LOG_DEBUG("[AVDT]%{public}s: ssrc(%u), mediatype(%hhu), codectype(%hhu)",
1354             __func__,
1355             ssrc,
1356             streamConfig->cfg.codecInfo[AVDT_CODEC_OFFSET_MEDIA_TYPE],
1357             streamConfig->cfg.codecInfo[AVDT_CODEC_OFFSET_CODEC_TYPE]);
1358     }
1359     Packet *mediaPacket = PacketInheritMalloc(data->apiWrite.pkt, AVDT_BUFFER_MEDIA_HEADER, 0);
1360     Buffer *header = PacketHead(mediaPacket);
1361     uint8_t *p = BufferPtr(header);
1362     *p++ = AVDT_MEDIA_OCTET1;
1363     *p++ = data->apiWrite.payloadType;
1364     uint16_t Sequence = AvdtCreateSequenceNo(streamCtrl);
1365     AVDT_MAKE_SEQUENCE_NO(p, Sequence);
1366     AVDT_MAKE_TIME_STAMP(p, data->apiWrite.timeStamp);
1367     /* ssrc */
1368     AVDT_MAKE_SSRC(p, ssrc);
1369 
1370     AvdtTransChannel *transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_STREAM, streamCtrl->handle);
1371     if (transTbl == NULL) {
1372         LOG_ERROR("[AVDT]%{public}s: Not fine the transTbl", __func__);
1373         return Ret;
1374     }
1375     /* pkt data debug print */
1376     AvdtPktDataPrint(mediaPacket);
1377     L2CIF_SendData(transTbl->lcid, mediaPacket, AvdtStreamSendDataCallback);
1378     PacketFree(mediaPacket);
1379     return Ret;
1380 }
1381 
1382 /**
1383  *
1384  * @brief        AvdtActWriteCfm
1385  *
1386  * @details      Test suite only.
1387  *
1388  * @return       uint16_t
1389  *
1390  */
AvdtActWriteCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1391 uint16_t AvdtActWriteCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1392 {
1393     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1394     uint16_t Ret = AVDT_SUCCESS;
1395     return Ret;
1396 }
1397 
1398 /**
1399  *
1400  * @brief        AvdtActReadInd
1401  *
1402  * @details      Test suite only.
1403  *
1404  * @return       uint16_t
1405  *
1406  */
AvdtActReadInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1407 uint16_t AvdtActReadInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1408 {
1409     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1410     uint16_t Ret = AVDT_SUCCESS;
1411     return Ret;
1412 }
1413 
1414 /**
1415  *
1416  * @brief         AvdtActStreamOpenReq
1417  *
1418  * @details       Open the Media channel
1419  *
1420  * @return        uint16_t
1421  *
1422  */
AvdtActStreamOpenReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1423 uint16_t AvdtActStreamOpenReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1424 {
1425     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1426     if (streamCtrl == NULL) {
1427         return AVDT_SUCCESS;
1428     }
1429     uint16_t Ret = AVDT_SUCCESS;
1430     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1431     AvdtTransChannel *transTbl = AvdtTransChTabAllocate(AVDT_CH_TYPE_STREAM, sigCtrl, streamCtrl);
1432     if (transTbl == NULL) {
1433         /* Trace no resources parameter */
1434         LOG_ERROR("[AVDT]%{public}s: AvdtTransChTabAllocate failed!", __func__);
1435         return Ret;
1436     }
1437     transTbl->state = AVDT_TRANS_ST_CONNECTION;
1438     /* L2CAP connect req */
1439     L2CIF_ConnectReq(&sigCtrl->peerAddress, AVDT_PSM, AVDT_PSM, NULL, AvdtStreamConnectReqCallback);
1440     return Ret;
1441 }
1442 
1443 /**
1444  *
1445  * @brief         AvdtActStreamOpenRsp
1446  *
1447  * @details       retain
1448  *
1449  * @return        uint16_t
1450  *
1451  */
AvdtActStreamOpenRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1452 uint16_t AvdtActStreamOpenRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1453 {
1454     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1455     uint16_t Ret = AVDT_SUCCESS;
1456     return Ret;
1457 }
1458 
1459 /**
1460  *
1461  * @brief         AvdtActStreamOpenInd
1462  *
1463  * @details       retain
1464  *
1465  * @return        uint16_t
1466  *
1467  */
AvdtActStreamOpenInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1468 uint16_t AvdtActStreamOpenInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1469 {
1470     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1471     uint16_t Ret = AVDT_SUCCESS;
1472     return Ret;
1473 }
1474 
1475 /**
1476  *
1477  * @brief         AvdtActStreamOpenCfm
1478  *
1479  * @details       retain
1480  *
1481  * @return        uint16_t
1482  *
1483  */
AvdtActStreamOpenCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1484 uint16_t AvdtActStreamOpenCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1485 {
1486     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1487     uint16_t Ret = AVDT_SUCCESS;
1488     return Ret;
1489 }
1490 
1491 /**
1492  *
1493  * @brief         AvdtActStreamCloseReq
1494  *
1495  * @details       Retain.
1496  *
1497  * @return        uint16_t
1498  *
1499  */
AvdtActStreamCloseReq(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1500 uint16_t AvdtActStreamCloseReq(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1501 {
1502     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1503     if (streamCtrl == NULL) {
1504         return AVDT_SUCCESS;
1505     }
1506     uint16_t Ret = AVDT_SUCCESS;
1507     AvdtTransChannel *transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_STREAM, streamCtrl->handle);
1508     if (transTbl == NULL) {
1509         /* Trace no resources parameter */
1510         LOG_ERROR("[AVDT]%{public}s: AvdtGetTransChTabByHandle(%hu) Failed!", __func__, streamCtrl->handle);
1511         return Ret;
1512     }
1513     /* L2CAP disconnect req */
1514     L2CIF_DisconnectionReq(transTbl->lcid, NULL);
1515     return Ret;
1516 }
1517 
1518 /**
1519  *
1520  * @brief         AvdtActStreamCloseRsp
1521  *
1522  * @details       Retain.
1523  *
1524  * @return        uint16_t
1525  *
1526  */
AvdtActStreamCloseRsp(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1527 uint16_t AvdtActStreamCloseRsp(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1528 {
1529     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1530     uint16_t Ret = AVDT_SUCCESS;
1531     return Ret;
1532 }
1533 
1534 /**
1535  *
1536  * @brief         AvdtActStreamCloseInd
1537  *
1538  * @details       Free stream resources.
1539  *
1540  * @return        uint16_t
1541  *
1542  */
AvdtActStreamCloseInd(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1543 uint16_t AvdtActStreamCloseInd(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1544 {
1545     if (streamCtrl == NULL) {
1546         return AVDT_SUCCESS;
1547     }
1548     LOG_DEBUG("[AVDT]%{public}s:Current state(%hhu)", __func__, streamCtrl->state);
1549     uint16_t Ret = AVDT_SUCCESS;
1550     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1551     AvdtCtrlData confirmData = {0};
1552     confirmData.hdr.errCode = AVDT_SUCCESS;
1553     AvdtCtrlEvtCallback(
1554         sigCtrl, streamCtrl->handle, &sigCtrl->peerAddress, AVDT_CLOSE_TRANS_IND_EVT, &confirmData, sigCtrl->role);
1555     AvdtStreamCtrlDeallocByHandle(sigCtrl, streamCtrl->handle);
1556     sigCtrl->streamHandle = 0;
1557     return Ret;
1558 }
1559 
1560 /**
1561  *
1562  * @brief         AvdtActStreamCloseCfm
1563  *
1564  * @details       Free the resources of stream.
1565  *
1566  * @return        uint16_t
1567  *
1568  */
AvdtActStreamCloseCfm(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1569 uint16_t AvdtActStreamCloseCfm(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1570 {
1571     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1572     if (streamCtrl == NULL) {
1573         return AVDT_SUCCESS;
1574     }
1575     uint16_t Ret = AVDT_SUCCESS;
1576     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1577     AvdtCtrlData confirmData = {0};
1578     confirmData.hdr.errCode = AVDT_SUCCESS;
1579     AvdtCtrlEvtCallback(
1580         sigCtrl, streamCtrl->handle, &sigCtrl->peerAddress, AVDT_CLOSE_CFM_EVT, &confirmData, sigCtrl->role);
1581     /* release the stream */
1582     AvdtStreamCtrlDeallocByHandle(sigCtrl, streamCtrl->handle);
1583     sigCtrl->streamHandle = 0;
1584     return Ret;
1585 }
1586 
AvdtActSndMsg(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1587 uint16_t AvdtActSndMsg(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1588 {
1589     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1590     uint16_t Ret = AVDT_SUCCESS;
1591     AvdtSendSig(sigCtrl);
1592     return Ret;
1593 }
1594 
1595 /**
1596  *
1597  * @brief         AvdtActConnReq
1598  *
1599  * @details       INT send connect command
1600  *
1601  * @return        uint16_t
1602  *
1603  */
AvdtActConnReq(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1604 uint16_t AvdtActConnReq(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1605 {
1606     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1607     if (sigCtrl == NULL) {
1608         return AVDT_SUCCESS;
1609     }
1610     uint16_t Ret = AVDT_SUCCESS;
1611     /* Interop check */
1612     if (BtmInteropIsMatchedAddr(INTEROP_2MBPS_LINK_ONLY, (const BtAddr *)&(sigCtrl->peerAddress))) {
1613         BTM_ChangeConnectionPacketType((const BtAddr *)&(sigCtrl->peerAddress),
1614             BTM_ACL_PACKET_TYPE_DEFAULT | BTM_ACL_PACKET_TYPE_NO_3_DH1 | BTM_ACL_PACKET_TYPE_NO_3_DH3 |
1615                 BTM_ACL_PACKET_TYPE_NO_3_DH5);
1616     }
1617     GapSecChannel chlId = {0};
1618     GapRequestSecurityParam param = {0};
1619     chlId.l2capPsm = AVDT_PSM;
1620     /* set security */
1621     param.callback = AvdtSecurityCheckCallback;
1622     param.info.channelId = chlId;
1623     param.info.protocolId = SEC_PROTOCOL_L2CAP;
1624     param.context = &sigCtrl->peerAddress;
1625     param.info.direction = OUTGOING;
1626     param.info.serviceId = GAVDP_INT;
1627     if (GAPIF_RequestSecurityAsync((const BtAddr *)&sigCtrl->peerAddress, &param)) {
1628         LOG_ERROR("[AVCT] %{public}s:GAP_RequestSecurity failed!", __func__);
1629         Ret = AVDT_FAILED;
1630     }
1631     return Ret;
1632 }
1633 
1634 /**
1635  *
1636  * @brief         AvdtActConnRsp
1637  *
1638  * @details       Test suite only.
1639  *
1640  * @return        uint16_t
1641  *
1642  */
AvdtActConnRsp(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1643 uint16_t AvdtActConnRsp(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1644 {
1645     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1646     uint16_t Ret = AVDT_SUCCESS;
1647     return Ret;
1648 }
1649 
1650 /**
1651  *
1652  * @brief         AvdtActConnInd
1653  *
1654  * @details       Test suite only.
1655  *
1656  * @return        uint16_t
1657  *
1658  */
AvdtActConnInd(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1659 uint16_t AvdtActConnInd(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1660 {
1661     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1662     uint16_t Ret = AVDT_SUCCESS;
1663     return Ret;
1664 }
1665 
1666 /**
1667  *
1668  * @brief         AvdtActConnCfm
1669  *
1670  * @details       Test suite only.
1671  *
1672  * @return        uint16_t
1673  *
1674  */
AvdtActConnCfm(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1675 uint16_t AvdtActConnCfm(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1676 {
1677     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1678     uint16_t Ret = AVDT_SUCCESS;
1679     return Ret;
1680 }
1681 
1682 /**
1683  *
1684  * @brief         AvdtActDisconnReq
1685  *
1686  * @details       INT send disconnect command
1687  *
1688  * @return        uint16_t
1689  *
1690  */
AvdtActDisconnReq(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1691 uint16_t AvdtActDisconnReq(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1692 {
1693     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1694     if (sigCtrl == NULL) {
1695         return AVDT_SUCCESS;
1696     }
1697     uint16_t Ret = AVDT_SUCCESS;
1698     AvdtTransChannel *transTbl = NULL;
1699     for (int i = 0; i < AVDT_NUM_SEPS; i++) {
1700         if ((sigCtrl->streamCtrl[i].isAllocated) && (sigCtrl->streamCtrl[i].isUsed)) {
1701             transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_STREAM, sigCtrl->streamCtrl[i].handle);
1702             if (transTbl != NULL) {
1703                 L2CIF_DisconnectionReq(transTbl->lcid, NULL);
1704                 LOG_DEBUG("[AVDT]%{public}s: mediachannel lcid(0x%x)", __func__, transTbl->lcid);
1705             } else {
1706                 LOG_ERROR("[AVDT]%{public}s: Not fine the transTbl", __func__);
1707             }
1708         }
1709     }
1710     transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_SIG, sigCtrl->handle);
1711     if (transTbl == NULL) {
1712         /* Trace no resources parameter */
1713         LOG_ERROR("[AVDT]%{public}s: AvdtGetTransChTabByHandle(%hu) Failed!", __func__, sigCtrl->handle);
1714         return Ret;
1715     }
1716     L2CIF_DisconnectionReq(transTbl->lcid, NULL);
1717     LOG_DEBUG("[AVDT]%{public}s: signaling lcid(0x%x) ", __func__, transTbl->lcid);
1718     return Ret;
1719 }
1720 
1721 /**
1722  *
1723  * @brief         AvdtActDisconnRsp
1724  *
1725  * @details       Test suite only.
1726  *
1727  * @return        uint16_t
1728  *
1729  */
AvdtActDisconnRsp(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1730 uint16_t AvdtActDisconnRsp(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1731 {
1732     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1733     uint16_t Ret = AVDT_SUCCESS;
1734     return Ret;
1735 }
1736 
1737 /**
1738  *
1739  * @brief         AvdtActDisconnInd
1740  *
1741  * @details       Test suite only.
1742  *
1743  * @return        uint16_t
1744  *
1745  */
AvdtActDisconnInd(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1746 uint16_t AvdtActDisconnInd(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1747 {
1748     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1749     if (sigCtrl == NULL) {
1750         return AVDT_SUCCESS;
1751     }
1752     uint16_t Ret = AVDT_SUCCESS;
1753     AvdtCtrlData confirmData = {0};
1754     AvdtStreamCtrlDeallocAll(sigCtrl);
1755     confirmData.hdr.errCode = AVDT_SUCCESS;
1756     if (sigCtrl->state != AVDT_SIG_IDLE_ST) {
1757         AvdtCtrlEvtCallback(
1758             sigCtrl, sigCtrl->handle, &sigCtrl->peerAddress, AVDT_DISCONNECT_IND_EVT, &confirmData, sigCtrl->role);
1759     }
1760     AvdtFreeSigCtrlByHandle(sigCtrl->handle);
1761     return Ret;
1762 }
1763 
1764 /**
1765  *
1766  * @brief         AvdtActDisconnCfm
1767  *
1768  * @details       Test suite only.
1769  *
1770  * @return        uint16_t
1771  *
1772  */
AvdtActDisconnCfm(AvdtSigCtrl * sigCtrl,const AvdtEventData * data)1773 uint16_t AvdtActDisconnCfm(AvdtSigCtrl *sigCtrl, const AvdtEventData *data)
1774 {
1775     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1776     if (sigCtrl == NULL) {
1777         return AVDT_SUCCESS;
1778     }
1779     uint16_t Ret = AVDT_SUCCESS;
1780     AvdtCtrlData confirmData = {0};
1781     AvdtStreamCtrlDeallocAll(sigCtrl);
1782     confirmData.hdr.errCode = AVDT_SUCCESS;
1783     AvdtCtrlEvtCallback(
1784         sigCtrl, sigCtrl->handle, &sigCtrl->peerAddress, AVDT_DISCONNECT_CFM_EVT, &confirmData, sigCtrl->role);
1785     AvdtFreeSigCtrlByHandle(sigCtrl->handle);
1786     return Ret;
1787 }
1788 
1789 /**
1790  *
1791  * @brief         AvdtActBadStateRej
1792  *
1793  * @details       Current State not surport this command, Send Reject signal cmd.
1794  *
1795  * @return        uint16_t
1796  *
1797  */
AvdtActBadStateRej(AvdtStreamCtrl * streamCtrl,AvdtEventData * data)1798 uint16_t AvdtActBadStateRej(AvdtStreamCtrl *streamCtrl, AvdtEventData *data)
1799 {
1800     uint16_t Ret = AVDT_SUCCESS;
1801     if (streamCtrl == NULL) {
1802         return AVDT_SUCCESS;
1803     }
1804     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(streamCtrl->sigHandle);
1805     LOG_DEBUG("[AVDT]%{public}s:singalId(0x%x)", __func__, sigCtrl->rcvSignal);
1806     AvdtIndReject(sigCtrl, sigCtrl->rcvSignal, AVDT_ERR_BAD_STATE, 0);
1807     return Ret;
1808 }
1809 
1810 /**
1811  * inner functions
1812  */
1813 
1814 /**
1815  *
1816  * @brief         AvdtSecurityCheckCallback
1817  *
1818  * @details       INT receive the security check result
1819  *
1820  * @return        uint16_t
1821  *
1822  */
AvdtSecurityCheckCallback(uint16_t result,GapServiceSecurityInfo security,void * context)1823 void AvdtSecurityCheckCallback(uint16_t result, GapServiceSecurityInfo security, void *context)
1824 {
1825     LOG_INFO("[AVDT]%{public}s:result(%hu), l2capPsm(0x%x)", __func__, result, security.channelId.l2capPsm);
1826     AvdtSecurityCheckTskParam *param = malloc(sizeof(AvdtSecurityCheckTskParam));
1827     if (param == NULL) {
1828         LOG_ERROR("[AVDT] %{public}s: memory malloc failed", __func__);
1829         return;
1830     }
1831     (void)memset_s(param, sizeof(AvdtSecurityCheckTskParam), 0, sizeof(AvdtSecurityCheckTskParam));
1832     param->result = result;
1833     (void)memcpy_s(&param->security, sizeof(GapServiceSecurityInfo), &security, sizeof(GapServiceSecurityInfo));
1834     param->context = context;
1835     if (AvdtAsyncProcess(AvdtSecurityCheckTsk, param)) {
1836         free(param);
1837     }
1838     return;
1839 }
1840 
AvdtSecurityCheckTsk(void * context)1841 void AvdtSecurityCheckTsk(void *context)
1842 {
1843     AvdtSecurityCheckTskParam *param = (AvdtSecurityCheckTskParam *)context;
1844     AvdtSecurityCheck(param->result, param->security, param->context);
1845     free(context);
1846     return;
1847 }
1848 
AvdtSecurityCheck(uint16_t result,GapServiceSecurityInfo security,void * context)1849 void AvdtSecurityCheck(uint16_t result, GapServiceSecurityInfo security, void *context)
1850 {
1851     LOG_DEBUG("[AVDT]%{public}s:result(%hu), l2capPsm(0x%x)", __func__, result, security.channelId.l2capPsm);
1852     AvdtTransChannel *transTbl = NULL;
1853     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByAddr((BtAddr *)context);
1854     if (sigCtrl == NULL) {
1855         LOG_DEBUG("[AVDT]%{public}s:AvdtGetSigCtrlByAddr failed!", __func__);
1856         return;
1857     }
1858     if (result == AVDT_SUCCESS) {
1859         sigCtrl->isFailReport = false;
1860         /* open the signaling channel req */
1861         transTbl = AvdtTransChTabAllocate(AVDT_CH_TYPE_SIG, sigCtrl, NULL);
1862         if (transTbl == NULL) {
1863             /* Trace no resources parameter */
1864             LOG_ERROR("[AVDT]%{public}s: AvdtTransChTabAllocate failed!", __func__);
1865             return;
1866         }
1867         transTbl->state = AVDT_TRANS_ST_CONNECTION;
1868         transTbl->sigHandle = sigCtrl->handle;
1869         /* L2CAP connect req */
1870         LOG_DEBUG("[AVDT]%{public}s: [psm: 0x%x] Addr(%02x:%02x:%02x:%02x:%2x:%02x)",
1871             __func__,
1872             AVDT_PSM,
1873             BT_ADDR_FMT_DSC(sigCtrl->peerAddress.addr));
1874         if (L2CIF_ConnectReq(&sigCtrl->peerAddress, AVDT_PSM, AVDT_PSM, NULL, AvdtSignalConnectReqCallback)) {
1875             LOG_DEBUG("[AVDT]%{public}s:L2CIF_ConnectReq failed)", __func__);
1876         }
1877     } else {
1878         if (!sigCtrl->isFailReport) {
1879             AvdtCtrlData confirmData = {0};
1880             confirmData.connectCfm.errCode = AVDT_FAILED;
1881             sigCtrl->isFailReport = true;
1882             AvdtCtrlEvtCallback(
1883                 sigCtrl, sigCtrl->handle, &(sigCtrl->peerAddress), AVDT_CONNECT_CFM_EVT, &confirmData, sigCtrl->role);
1884         }
1885     }
1886     return;
1887 }
1888 
AvdtSignalConnectReqCallback(const BtAddr * addr,uint16_t lcid,int result,void * context)1889 void AvdtSignalConnectReqCallback(const BtAddr *addr, uint16_t lcid, int result, void *context)
1890 {
1891     LOG_INFO("[AVDT]%{public}s:result(%{public}d), lcid(0x%x)", __func__, result, lcid);
1892     AvdtSignalConnectReqTskParam *param = malloc(sizeof(AvdtSignalConnectReqTskParam));
1893     if (param == NULL) {
1894         LOG_ERROR("[AVDT] %{public}s: memory malloc failed", __func__);
1895         return;
1896     }
1897     (void)memset_s(param, sizeof(AvdtSignalConnectReqTskParam), 0, sizeof(AvdtSignalConnectReqTskParam));
1898     (void)memcpy_s(&param->addr, sizeof(BtAddr), addr, sizeof(BtAddr));
1899     param->lcid = lcid;
1900     param->result = result;
1901     param->context = context;
1902     if (AvdtAsyncProcess(AvdtSignalConnectReqTsk, param)) {
1903         free(param);
1904     }
1905     return;
1906 }
1907 
AvdtSignalConnectReqTsk(void * context)1908 void AvdtSignalConnectReqTsk(void *context)
1909 {
1910     AvdtSignalConnectReqTskParam *param = (AvdtSignalConnectReqTskParam *)context;
1911     AvdtSignalConnectReq(&param->addr, param->lcid, param->result, param->context);
1912     free(context);
1913     return;
1914 }
1915 
AvdtSignalConnectReq(const BtAddr * addr,uint16_t lcid,int result,void * context)1916 void AvdtSignalConnectReq(const BtAddr *addr, uint16_t lcid, int result, void *context)
1917 {
1918     LOG_DEBUG("[AVDT]%{public}s:result(%{public}d), lcid(0x%x)", __func__, result, lcid);
1919     AvdtSigCtrl *sigCtrl = NULL;
1920     AvdtTransChannel *transTbl = AvdtGetTransChTabByAddr(addr, AVDT_CH_TYPE_SIG);
1921     if (transTbl != NULL) {
1922         transTbl->lcid = lcid;
1923     } else {
1924         LOG_ERROR("[AVDT]%{public}s:Can't find transport channel by bdAddr((%02x:%02x:%02x:%02x:%02x:%02x)",
1925             __func__,
1926             BT_ADDR_FMT_DSC(addr->addr));
1927     }
1928     sigCtrl = AvdtGetSigCtrlByAddr(addr);
1929     if (sigCtrl != NULL) {
1930         sigCtrl->lcid = lcid;
1931     } else {
1932         LOG_ERROR("[AVDT]%{public}s:Can't find control block by bdAddr((%02x:%02x:%02x:%02x:%02x:%02x)",
1933             __func__,
1934             BT_ADDR_FMT_DSC(addr->addr));
1935     }
1936     return;
1937 }
1938 
AvdtStreamConnectReqCallback(const BtAddr * addr,uint16_t lcid,int result,void * context)1939 void AvdtStreamConnectReqCallback(const BtAddr *addr, uint16_t lcid, int result, void *context)
1940 {
1941     LOG_INFO("[AVDT]%{public}s:result(%{public}d), lcid(0x%x)", __func__, result, lcid);
1942     AvdtStreamConnectReqTskParam *param = malloc(sizeof(AvdtStreamConnectReqTskParam));
1943     if (param == NULL) {
1944         LOG_ERROR("[AVDT] %{public}s: memory malloc failed", __func__);
1945         return;
1946     }
1947     (void)memset_s(param, sizeof(AvdtStreamConnectReqTskParam), 0, sizeof(AvdtStreamConnectReqTskParam));
1948     (void)memcpy_s(&param->addr, sizeof(BtAddr), addr, sizeof(BtAddr));
1949     param->lcid = lcid;
1950     param->result = result;
1951     param->context = context;
1952     if (AvdtAsyncProcess(AvdtStreamConnectReqTsk, param)) {
1953         free(param);
1954     }
1955     return;
1956 }
1957 
AvdtStreamConnectReqTsk(void * context)1958 void AvdtStreamConnectReqTsk(void *context)
1959 {
1960     AvdtStreamConnectReqTskParam *param = (AvdtStreamConnectReqTskParam *)context;
1961     AvdtStreamConnectReq(&param->addr, param->lcid, param->result, param->context);
1962     free(context);
1963     return;
1964 }
1965 
AvdtStreamConnectReq(const BtAddr * addr,uint16_t lcid,int result,void * context)1966 void AvdtStreamConnectReq(const BtAddr *addr, uint16_t lcid, int result, void *context)
1967 {
1968     LOG_DEBUG("[AVDT]%{public}s:result(%{public}d), lcid(0x%x)", __func__, result, lcid);
1969     AvdtSigCtrl *sigCtrl = NULL;
1970     AvdtTransChannel *transTbl = AvdtGetTransChTabByAddr(addr, AVDT_CH_TYPE_STREAM);
1971     if (transTbl != NULL) {
1972         transTbl->lcid = lcid;
1973     } else {
1974         LOG_ERROR("[AVDT]%{public}s:Can't find transport channel by bdAddr((%02x:%02x:%02x:%02x:%02x:%02x)",
1975             __func__,
1976             BT_ADDR_FMT_DSC(addr->addr));
1977     }
1978     sigCtrl = AvdtGetSigCtrlByAddr(addr);
1979     if (sigCtrl != NULL) {
1980         sigCtrl->lcid = lcid;
1981     } else {
1982         LOG_ERROR("[AVDT]%{public}s:Can't find control block by bdAddr((%02x:%02x:%02x:%02x:%02x:%02x)",
1983             __func__,
1984             BT_ADDR_FMT_DSC(addr->addr));
1985     }
1986     return;
1987 }
1988 
AvdtPktDataPrint(const Packet * pkt)1989 void AvdtPktDataPrint(const Packet *pkt)
1990 {
1991     int len = PacketSize(pkt);
1992     uint8_t buf[AVDT_32BYTE] = {0};
1993     if (len > AVDT_32BYTE) {
1994         len = AVDT_32BYTE;
1995     }
1996     PacketRead(pkt, buf, 0, len);
1997     for (int i = 0; i < len; i++) {
1998         LOG_DEBUG("%02X ", buf[i]);
1999     }
2000     return;
2001 }
2002 
AvdtStreamSendDataCallback(uint16_t lcid,int result)2003 void AvdtStreamSendDataCallback(uint16_t lcid, int result)
2004 {
2005     LOG_INFO("[AVDT]%{public}s:result(%{public}d), lcid(0x%x)", __func__, result, lcid);
2006     AvdtStreamSendDataTskParam *param = malloc(sizeof(AvdtStreamSendDataTskParam));
2007     if (param == NULL) {
2008         LOG_ERROR("[AVDT] %{public}s: memory malloc failed", __func__);
2009         return;
2010     }
2011     (void)memset_s(param, sizeof(AvdtStreamSendDataTskParam), 0, sizeof(AvdtStreamSendDataTskParam));
2012     param->lcid = lcid;
2013     param->result = result;
2014     if (AvdtAsyncProcess(AvdtStreamSendDataTsk, param)) {
2015         free(param);
2016     }
2017     return;
2018 }
2019 
AvdtStreamSendDataTsk(void * context)2020 void AvdtStreamSendDataTsk(void *context)
2021 {
2022     LOG_INFO("[AVDT]%{public}s", __func__);
2023 
2024     AvdtStreamSendDataTskParam *param = (AvdtStreamSendDataTskParam *)context;
2025     AvdtStreamSendData(param->lcid, param->result);
2026     free(context);
2027     return;
2028 }
2029 
AvdtStreamSendData(uint16_t lcid,int result)2030 void AvdtStreamSendData(uint16_t lcid, int result)
2031 {
2032     LOG_INFO("[AVDT]%{public}s:result(%{public}d), lcid(0x%x)", __func__, result, lcid);
2033 
2034     AvdtTransChannel *transTable = AvdtGetTransChTabByLcid(lcid);
2035     if (transTable == NULL) {
2036         LOG_ERROR("[AVDT]%{public}s:AvdtGetTransChTabByLcid(0x%x) Failed!!", __func__, lcid);
2037         return;
2038     }
2039 
2040     LOG_DEBUG("[AVDT]%{public}s:transTable->type(%hhu), transTable->streamHandle(%hu),transTable->sigHandle(%hu) ",
2041         __func__,
2042         transTable->type,
2043         transTable->streamHandle,
2044         transTable->sigHandle);
2045 
2046     AvdtSigCtrl *sigCtrl = AvdtGetSigCtrlByHandle(transTable->sigHandle);
2047     if (sigCtrl == NULL) {
2048         LOG_ERROR("[AVDT]%{public}s:AvdtGetSigCtrlByHandle(%hu) Failed", __func__, transTable->sigHandle);
2049         return;
2050     }
2051 
2052     AvdtCtrlData confirmData = {0};
2053     if (result != BT_SUCCESS) {
2054         confirmData.hdr.errCode = AVDT_FAILED;
2055     }
2056 
2057     AvdtCtrlEvtCallback(
2058         sigCtrl, sigCtrl->streamHandle, &(sigCtrl->peerAddress), AVDT_WRITE_CFM_EVT, &confirmData, sigCtrl->role);
2059 }