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 "a2dp_state_machine.h"
17 #include "a2dp_codec_thread.h"
18 #include "a2dp_service.h"
19 #include "a2dp_sink.h"
20 #include "compat.h"
21 #include "log.h"
22 #include "power_manager.h"
23 #include "securec.h"
24
25 namespace OHOS {
26 namespace bluetooth {
27 std::recursive_mutex g_stateMutex {};
Entry()28 void A2dpStateIdle::Entry()
29 {
30 A2dpCodecThread *codecThread = A2dpCodecThread::GetInstance();
31 if (codecThread->GetInitStatus()) {
32 codecThread->StopA2dpCodecThread();
33 delete codecThread;
34 }
35 }
36
Dispatch(const utility::Message & msg)37 bool A2dpStateIdle::Dispatch(const utility::Message &msg)
38 {
39 if (msg.arg2_ == nullptr) {
40 LOG_ERROR("[A2dpStateIdle]%{public}s input error parameter\n", __func__);
41 return false;
42 }
43 uint8_t label = 0;
44 A2dpAvdtMsgData msgData = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->a2dpMsg;
45 uint8_t role = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->role;
46 A2dpAvdtp avdtp(role);
47 switch (msg.what_) {
48 case EVT_CONNECT_REQ:
49 avdtp.ConnectReq(msgData.connectInfo.addr);
50 break;
51 case EVT_DISCOVER_REQ:
52 ProcessDiscoverReq(msgData.connectInfo.addr, role, msgData.connectInfo.errCode);
53 break;
54 case EVT_GET_ALLCAP_REQ:
55 avdtp.GetAllCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
56 break;
57 case EVT_GET_CAP_REQ:
58 avdtp.GetCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
59 break;
60 case EVT_SETCONFIG_REQ:
61 ProcessSetConfigReq(msgData, role);
62 break;
63 case EVT_DISCONNECT_REQ:
64 ProcessDisconnectReq(msgData.connectInfo.addr, role);
65 break;
66 case EVT_SDP_CFM:
67 ProcessSDPFailure(msgData.stream.addr, role);
68 break;
69 case EVT_SETCONFIG_IND:
70 ProcessSetConfigInd(msgData, role);
71 break;
72 case EVT_DISCONNECT_IND:
73 ProcessDisconnectInd(msgData.stream.addr, msgData.stream.handle, role);
74 break;
75 case EVT_DISCONNECT_CFM:
76 ProcessDisconnectCfm(msgData.stream.addr, msgData.stream.handle, role);
77 break;
78 case EVT_TIME_OUT:
79 ProcessTimeout(msgData.stream.addr, role);
80 break;
81 default:
82 break;
83 }
84 return true;
85 }
86
ProcessDisconnectCfm(BtAddr addr,uint16_t handle,uint8_t role) const87 void A2dpStateIdle::ProcessDisconnectCfm(BtAddr addr, uint16_t handle, uint8_t role) const
88 {
89 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
90
91 CallbackParameter param = {A2DP_ROLE_INT, true, handle};
92 A2dpProfile *profile = GetProfileInstance(role);
93 if (profile == nullptr) {
94 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
95 return;
96 }
97
98 if (role == A2DP_ROLE_SOURCE) {
99 IPowerManager::GetInstance().StatusUpdate(
100 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
101 }
102
103 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
104 }
105
SetStateName(std::string state)106 void A2dpStateIdle::SetStateName(std::string state)
107 {
108 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
109 Transition(state);
110 }
111
ProcessDisconnectReq(BtAddr addr,uint8_t role)112 void A2dpStateIdle::ProcessDisconnectReq(BtAddr addr, uint8_t role)
113 {
114 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
115
116 A2dpAvdtp avdtp(role);
117
118 SetStateName(A2DP_PROFILE_CLOSING);
119 avdtp.DisconnectReq(addr);
120 }
121
ProcessTimeout(BtAddr addr,uint8_t role)122 void A2dpStateIdle::ProcessTimeout(BtAddr addr, uint8_t role)
123 {
124 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
125
126 A2dpAvdtp avdtp(role);
127
128 SetStateName(A2DP_PROFILE_CLOSING);
129 avdtp.DisconnectReq(addr);
130 }
131
ProcessDisconnectInd(BtAddr addr,uint16_t handle,uint8_t role)132 void A2dpStateIdle::ProcessDisconnectInd(BtAddr addr, uint16_t handle, uint8_t role)
133 {
134 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
135
136 CallbackParameter param = {A2DP_ROLE_ACP, false, handle};
137 A2dpProfile *profile = GetProfileInstance(role);
138 if (profile == nullptr) {
139 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
140 return;
141 }
142
143 if (role == A2DP_ROLE_SOURCE) {
144 IPowerManager::GetInstance().StatusUpdate(
145 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
146 }
147 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
148 }
149
ProcessSetConfigReq(A2dpAvdtMsgData msgData,uint8_t role)150 void A2dpStateIdle::ProcessSetConfigReq(A2dpAvdtMsgData msgData, uint8_t role)
151 {
152 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
153
154 A2dpAvdtp avdtp(role);
155 uint8_t label = 0;
156
157 SetStateName(A2DP_PROFILE_CONFIG);
158 avdtp.SetConfigureReq(msgData.configStream.addr,
159 msgData.configStream.intSeid,
160 msgData.configStream.acpSeid,
161 msgData.configStream.cfg,
162 label);
163 }
164
ProcessSetConfigInd(A2dpAvdtMsgData msgData,uint8_t role)165 void A2dpStateIdle::ProcessSetConfigInd(A2dpAvdtMsgData msgData, uint8_t role)
166 {
167 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
168 A2dpProfile *profile = GetProfileInstance(role);
169 CallbackParameter param = {A2DP_ROLE_ACP, false, 0};
170 A2dpAvdtp avdtp(role);
171 A2dpProfilePeer *profilePeer = nullptr;
172 uint8_t resultConfig[A2DP_CODEC_SIZE];
173 (void)memset_s(resultConfig, A2DP_CODEC_SIZE, 0, A2DP_CODEC_SIZE);
174 uint8_t *pResultConfig = &resultConfig[0];
175 A2dpCodecCapability userConfig = {};
176 bool reconfig = false;
177 bool ret = false;
178 if (profile == nullptr) {
179 return;
180 }
181 profilePeer = profile->FindPeerByAddress(msgData.configRsp.addr);
182 if (profilePeer == nullptr) {
183 return;
184 }
185 A2dpCodecFactory *codecFactory = profilePeer->GetCodecConfigure();
186 if (codecFactory == nullptr) {
187 return;
188 }
189 uint8_t *pCodecInfo = msgData.configRsp.codecInfo;
190 SetStateName(A2DP_PROFILE_CONFIG);
191 avdtp.SetConfigureRsp(msgData.configRsp.handle, msgData.configRsp.label, msgData.configRsp.category);
192 profile->ConnectStateChangedNotify(msgData.configRsp.addr, STREAM_CONNECTING, static_cast<void *>(¶m));
193 if (role == A2DP_ROLE_SOURCE) {
194 ret = codecFactory->SetCodecConfig(pCodecInfo, pResultConfig);
195 LOG_INFO("[A2dpStateIdle]%{public}s SetConfig result(%{public}d)\n", __func__, ret);
196 } else {
197 if (codecFactory->FindSourceCodec(pCodecInfo) == nullptr ||
198 codecFactory->GetIndexedSinkCodecs().front() == nullptr) {
199 return;
200 }
201 if (codecFactory->GetIndexedSinkCodecs().front()->GetCodecIndex() ==
202 (codecFactory->FindSourceCodec(pCodecInfo)->GetCodecIndex() + A2DP_SINK_CODEC_INDEX_MIN -
203 A2DP_SOURCE_CODEC_INDEX_SBC)) {
204 ret = codecFactory->SetSinkCodecConfig(pCodecInfo, pResultConfig);
205 LOG_INFO("[A2dpStateIdle]%{public}s SetSinkCodecConfig result(%{public}d)\n", __func__, ret);
206 } else {
207 userConfig.codecIndex_ = codecFactory->FindSourceCodec(pCodecInfo)->GetCodecIndex();
208 userConfig.codecPriority_ = A2DP_CODEC_PRIORITY_HIGHEST;
209 ret = codecFactory->SetCodecUserConfig(userConfig, pCodecInfo, pResultConfig, &reconfig);
210 LOG_INFO("[A2dpStateIdle]%{public}s SetuserConfig result(%{public}d)\n", __func__, ret);
211 }
212 }
213 }
214
ProcessDiscoverReq(BtAddr addr,uint8_t role,uint8_t errCode)215 void A2dpStateIdle::ProcessDiscoverReq(BtAddr addr, uint8_t role, uint8_t errCode)
216 {
217 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
218
219 A2dpProfile *profile = GetProfileInstance(role);
220 CallbackParameter param = {A2DP_ROLE_INT, true, 0};
221 A2dpAvdtp avdtp(role);
222 uint8_t label = 0;
223 if (profile == nullptr) {
224 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
225 return;
226 }
227
228 A2dpProfilePeer *peer = profile->FindPeerByAddress(addr);
229 if (peer == nullptr) {
230 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profilePeer instance\n", __func__);
231 return;
232 }
233 if (errCode != AVDT_SUCCESS) {
234 profile->ConnectStateChangedNotify(addr, STREAM_CONNECT_FAILED, (void *)¶m);
235 } else if (peer->GetDisconnectIndication()) {
236 ProcessDisconnectReq(addr, role);
237 peer->SetDisconnectIndication(false);
238 } else {
239 avdtp.DiscoverReq(addr, AVDT_NUM_SEPS, label);
240 }
241 }
242
ProcessSDPFailure(BtAddr addr,uint8_t role) const243 void A2dpStateIdle::ProcessSDPFailure(BtAddr addr, uint8_t role) const
244 {
245 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
246
247 A2dpProfile *profile = GetProfileInstance(role);
248 CallbackParameter param = {A2DP_ROLE_INT, true, 0};
249 if (profile == nullptr) {
250 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
251 return;
252 }
253
254 profile->DeletePeer(addr);
255 profile->ConnectStateChangedNotify(addr, STREAM_CONNECT_FAILED, (void *)¶m);
256 }
257
Dispatch(const utility::Message & msg)258 bool A2dpStateConfigure::Dispatch(const utility::Message &msg)
259 {
260 LOG_INFO("[A2dpStateConfigure]%{public}s\n", __func__);
261 if (msg.arg2_ == nullptr) {
262 LOG_ERROR("[A2dpStateConfigure]%{public}s input error parameter\n", __func__);
263 return false;
264 }
265
266 uint8_t label = 0;
267 A2dpAvdtMsgData msgData = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->a2dpMsg;
268 uint8_t role = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->role;
269 A2dpAvdtp avdtp(role);
270
271 switch (msg.what_) {
272 case EVT_GET_ALLCAP_REQ:
273 avdtp.GetAllCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
274 break;
275 case EVT_GET_CAP_REQ:
276 avdtp.GetCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
277 break;
278 case EVT_OPEN_REQ:
279 ProcessOpenReq(msgData.stream.addr, msgData.stream.handle, role);
280 break;
281 case EVT_DISCONNECT_REQ:
282 ProcessDisconnectReq(msgData.connectInfo.addr, role);
283 break;
284 case EVT_SETCONFIG_IND:
285 ProcessSetConfigInd(msgData, role);
286 break;
287 case EVT_OPEN_IND:
288 ProcessOpenInd(msgData, role);
289 break;
290 case EVT_DISCONNECT_IND:
291 ProcessDisconnectInd(msgData.stream.addr, msgData.stream.handle, role);
292 break;
293 case EVT_TIME_OUT:
294 avdtp.DisconnectReq(msgData.stream.addr);
295 SetStateName(A2DP_PROFILE_CLOSING);
296 break;
297 case EVT_DELAY_IND:
298 ProcessDelayReportInd(msgData, role);
299 break;
300 default:
301 break;
302 }
303 return true;
304 }
305
SetStateName(std::string state)306 void A2dpStateConfigure::SetStateName(std::string state)
307 {
308 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
309 Transition(state);
310 }
311
ProcessOpenReq(BtAddr addr,uint16_t handle,uint8_t role)312 void A2dpStateConfigure::ProcessOpenReq(BtAddr addr, uint16_t handle, uint8_t role)
313 {
314 LOG_INFO("[A2dpStateConfigure]%{public}s\n", __func__);
315
316 A2dpAvdtp avdtp(role);
317 uint8_t label = 0;
318
319 SetStateName(A2DP_PROFILE_OPENING);
320 avdtp.OpenReq(handle, label);
321 }
322
ProcessDisconnectReq(BtAddr addr,uint8_t role)323 void A2dpStateConfigure::ProcessDisconnectReq(BtAddr addr, uint8_t role)
324 {
325 LOG_INFO("[A2dpStateConfigure]%{public}s\n", __func__);
326
327 A2dpAvdtp avdtp(role);
328
329 SetStateName(A2DP_PROFILE_CLOSING);
330 avdtp.DisconnectReq(addr);
331 }
332
ProcessDisconnectInd(BtAddr addr,uint16_t handle,uint8_t role)333 void A2dpStateConfigure::ProcessDisconnectInd(BtAddr addr, uint16_t handle, uint8_t role)
334 {
335 LOG_INFO("[A2dpStateIdle]%{public}s\n", __func__);
336
337 CallbackParameter param = {A2DP_ROLE_ACP, false, handle};
338 A2dpProfile *profile = GetProfileInstance(role);
339
340 if (profile == nullptr) {
341 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
342 return;
343 }
344
345 if (role == A2DP_ROLE_SOURCE) {
346 IPowerManager::GetInstance().StatusUpdate(
347 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
348 }
349
350 SetStateName(A2DP_PROFILE_IDLE);
351 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
352 }
353
ProcessOpenInd(A2dpAvdtMsgData msgData,uint8_t role)354 void A2dpStateConfigure::ProcessOpenInd(A2dpAvdtMsgData msgData, uint8_t role)
355 {
356 LOG_INFO("[A2dpStateConfigure]%{public}s\n", __func__);
357
358 CallbackParameter param = {A2DP_ROLE_ACP, false, 0};
359 A2dpProfile *profile = GetProfileInstance(role);
360 if (profile == nullptr) {
361 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
362 return;
363 }
364
365 SetStateName(A2DP_PROFILE_OPEN);
366 param.handle = msgData.stream.handle;
367 profile->CodecChangedNotify(msgData.stream.addr, nullptr);
368 LOG_INFO("[A2dpStateOpen]%{public}s open handle[%u]\n", __func__, param.handle);
369 profile->ConnectStateChangedNotify(msgData.stream.addr, STREAM_CONNECT, static_cast<void *>(¶m));
370
371 if (role == A2DP_ROLE_SOURCE) {
372 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON,
373 PROFILE_NAME_A2DP_SRC,
374 bluetooth::RawAddress::ConvertToString(msgData.stream.addr.addr));
375 }
376 }
377
ProcessSetConfigInd(A2dpAvdtMsgData msgData,uint8_t role)378 void A2dpStateConfigure::ProcessSetConfigInd(A2dpAvdtMsgData msgData, uint8_t role)
379 {
380 LOG_INFO("[A2dpStateConfigure]%{public}s\n", __func__);
381
382 A2dpProfile *profile = GetProfileInstance(role);
383 A2dpAvdtp avdtp(role);
384 A2dpProfilePeer *profilePeer = nullptr;
385 uint8_t resultConfig[A2DP_CODEC_SIZE];
386 uint8_t *pResultConfig = &resultConfig[0];
387 A2dpCodecCapability userConfig = {};
388 bool reconfig = false;
389
390 (void)memset_s(resultConfig, A2DP_CODEC_SIZE, 0, A2DP_CODEC_SIZE);
391 if (profile == nullptr) {
392 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
393 return;
394 }
395 profilePeer = profile->FindPeerByAddress(msgData.configRsp.addr);
396 if (profilePeer == nullptr) {
397 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profilePeer instance\n", __func__);
398 return;
399 }
400
401 A2dpCodecFactory *codecFactory = profilePeer->GetCodecConfigure();
402 uint8_t *pCodecInfo = msgData.configRsp.codecInfo;
403
404 if (role == A2DP_ROLE_SOURCE) {
405 codecFactory->SetCodecConfig(pCodecInfo, pResultConfig);
406 } else {
407 if (codecFactory->GetIndexedSinkCodecs().front() == nullptr ||
408 codecFactory->FindSourceCodec(pCodecInfo) == nullptr) {
409 return;
410 }
411 if (codecFactory->GetIndexedSinkCodecs().front()->GetCodecIndex() ==
412 (codecFactory->FindSourceCodec(pCodecInfo)->GetCodecIndex() + A2DP_SINK_CODEC_INDEX_MIN -
413 A2DP_SOURCE_CODEC_INDEX_SBC)) {
414 codecFactory->SetSinkCodecConfig(pCodecInfo, pResultConfig);
415 } else {
416 userConfig.codecIndex_ = codecFactory->FindSourceCodec(pCodecInfo)->GetCodecIndex();
417 userConfig.codecPriority_ = A2DP_CODEC_PRIORITY_HIGHEST;
418 codecFactory->SetCodecUserConfig(userConfig, pCodecInfo, pResultConfig, &reconfig);
419 }
420 }
421
422 avdtp.SetConfigureRsp(msgData.configRsp.handle, msgData.configRsp.label, msgData.configRsp.category);
423 }
424
ProcessDelayReportInd(A2dpAvdtMsgData msgData,uint8_t role) const425 void A2dpStateConfigure::ProcessDelayReportInd(A2dpAvdtMsgData msgData, uint8_t role) const
426 {
427 LOG_INFO("[A2dpStateConfigure]%{public}s\n", __func__);
428 if (role == A2DP_ROLE_SINK) {
429 LOG_INFO("[A2dpStateConfigure]%{public}s sink role does not handle delay report ind return.", __func__);
430 return;
431 }
432
433 A2dpProfile *profile = GetProfileInstance(role);
434 if (profile == nullptr) {
435 LOG_ERROR("[A2dpStateConfigure]%{public}s Failed to get profile instance\n", __func__);
436 return;
437 }
438
439 BtAddr addr = msgData.delayReportInfo.addr;
440 uint16_t value = msgData.delayReportInfo.delayValue;
441 profile->DelayReportNotify(addr, value);
442 }
443
Dispatch(const utility::Message & msg)444 bool A2dpStateOpening::Dispatch(const utility::Message &msg)
445 {
446 LOG_INFO("[A2dpStateOpening]%{public}s\n", __func__);
447 if (msg.arg2_ == nullptr) {
448 LOG_ERROR("[A2dpStateOpening]%{public}s input error parameter\n", __func__);
449 return false;
450 }
451
452 A2dpAvdtMsgData msgData = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->a2dpMsg;
453 uint8_t role = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->role;
454 A2dpAvdtp avdtp(role);
455 uint8_t label = 0;
456
457 switch (msg.what_) {
458 case EVT_GET_ALLCAP_REQ:
459 avdtp.GetAllCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
460 break;
461 case EVT_GET_CAP_REQ:
462 avdtp.GetCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
463 break;
464 case EVT_DISCONNECT_REQ:
465 ProcessDisconnectReq(msgData.connectInfo.addr, role);
466 break;
467 case EVT_DISCONNECT_IND:
468 ProcessDisconnectInd(msgData.stream.addr, msgData.stream.handle, role);
469 break;
470 case EVT_OPEN_CFM:
471 ProcessOpenCfm(msgData, role);
472 break;
473 case EVT_TIME_OUT:
474 avdtp.DisconnectReq(msgData.stream.addr);
475 SetStateName(A2DP_PROFILE_CLOSING);
476 break;
477 case EVT_DELAY_IND:
478 ProcessDelayReportInd(msgData, role);
479 break;
480 default:
481 break;
482 }
483 return true;
484 }
485
SetStateName(std::string state)486 void A2dpStateOpening::SetStateName(std::string state)
487 {
488 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
489 Transition(state);
490 }
491
ProcessOpenCfm(A2dpAvdtMsgData msgData,uint8_t role)492 void A2dpStateOpening::ProcessOpenCfm(A2dpAvdtMsgData msgData, uint8_t role)
493 {
494 LOG_INFO("[A2dpStateOpening]%{public}s\n", __func__);
495
496 CallbackParameter param = {A2DP_ROLE_INT, true, msgData.stream.handle};
497 A2dpAvdtp avdtp(role);
498 A2dpProfile *profile = GetProfileInstance(role);
499 if (profile == nullptr) {
500 LOG_ERROR("[A2dpStateOpening]%{public}s Failed to get profile instance\n", __func__);
501 return;
502 }
503
504 if (msgData.stream.errCode != AVDT_SUCCESS) {
505 LOG_ERROR("[A2dpStateOpening]%{public}s [errcode: %u]", __func__, msgData.stream.errCode);
506 profile->ConnectStateChangedNotify(msgData.stream.addr, STREAM_CONNECT_FAILED, static_cast<void *>(¶m));
507 } else {
508 SetStateName(A2DP_PROFILE_OPEN);
509 profile->CodecChangedNotify(msgData.stream.addr, nullptr);
510 LOG_INFO("[A2dpStateOpen]%{public}s open handle[%u]\n", __func__, param.handle);
511 if (role == A2DP_ROLE_SOURCE) {
512 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON,
513 PROFILE_NAME_A2DP_SRC,
514 bluetooth::RawAddress::ConvertToString(msgData.stream.addr.addr));
515 }
516 profile->ConnectStateChangedNotify(msgData.stream.addr, STREAM_CONNECT, static_cast<void *>(¶m));
517 }
518 }
519
ProcessDisconnectReq(BtAddr addr,uint8_t role)520 void A2dpStateOpening::ProcessDisconnectReq(BtAddr addr, uint8_t role)
521 {
522 LOG_INFO("[A2dpStateOpening]%{public}s\n", __func__);
523
524 A2dpAvdtp avdtp(role);
525
526 SetStateName(A2DP_PROFILE_CLOSING);
527 avdtp.DisconnectReq(addr);
528 }
529
ProcessDisconnectInd(BtAddr addr,uint16_t handle,uint8_t role)530 void A2dpStateOpening::ProcessDisconnectInd(BtAddr addr, uint16_t handle, uint8_t role)
531 {
532 LOG_INFO("[A2dpStateOpening]%{public}s\n", __func__);
533
534 CallbackParameter param = {A2DP_ROLE_ACP, false, handle};
535 A2dpProfile *profile = GetProfileInstance(role);
536
537 if (profile == nullptr) {
538 LOG_ERROR("[A2dpStateOpening]%{public}s Failed to get profile instance\n", __func__);
539 return;
540 }
541
542 if (role == A2DP_ROLE_SOURCE) {
543 IPowerManager::GetInstance().StatusUpdate(
544 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
545 }
546 SetStateName(A2DP_PROFILE_IDLE);
547 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
548 }
549
ProcessDelayReportInd(A2dpAvdtMsgData msgData,uint8_t role) const550 void A2dpStateOpening::ProcessDelayReportInd(A2dpAvdtMsgData msgData, uint8_t role) const
551 {
552 LOG_INFO("[A2dpStateOpening]%{public}s\n", __func__);
553 if (role == A2DP_ROLE_SINK) {
554 LOG_INFO("[A2dpStateOpening]%{public}s sink role does not handle delay report ind return.", __func__);
555 return;
556 }
557
558 A2dpProfile *profile = GetProfileInstance(role);
559 if (profile == nullptr) {
560 LOG_ERROR("[A2dpStateOpening]%{public}s Failed to get profile instance\n", __func__);
561 return;
562 }
563
564 BtAddr addr = msgData.delayReportInfo.addr;
565 uint16_t value = msgData.delayReportInfo.delayValue;
566 profile->DelayReportNotify(addr, value);
567 }
568
Dispatch(const utility::Message & msg)569 bool A2dpStateOpen::Dispatch(const utility::Message &msg)
570 {
571 if (msg.arg2_ == nullptr) {
572 return false;
573 }
574 A2dpAvdtMsgData msgData = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->a2dpMsg;
575 uint8_t role = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->role;
576 A2dpAvdtp avdtp(role);
577
578 switch (msg.what_) {
579 case EVT_START_IND:
580 ProcessStartInd(msgData, role);
581 break;
582 case EVT_CLOSE_IND:
583 ProcessCloseInd(msgData, role);
584 break;
585 case EVT_DISCONNECT_IND:
586 ProcessDisconnectInd(msgData.stream.addr, msgData.stream.handle, role);
587 break;
588 case EVT_RECONFIG_IND:
589 avdtp.ReconfigureRsp(msgData.configRsp.handle, msgData.configRsp.label, msgData.configRsp.category);
590 break;
591 case EVT_CLOSE_REQ:
592 avdtp.CloseReq(msgData.stream.handle);
593 break;
594 case EVT_DISCONNECT_REQ:
595 ProcessDisconnectReq(msgData.connectInfo.addr, role);
596 break;
597 case EVT_START_REQ:
598 avdtp.StartReq(msgData.stream.handle, label_);
599 break;
600 case EVT_RECONFIG_REQ:
601 avdtp.ReconfigureReq(msgData.configStream.intSeid, msgData.configStream.cfg, label_);
602 break;
603 case EVT_RECONFIG_CFM:
604 ProcessReconfigCfm(msgData.stream.addr, role, msgData.stream.handle);
605 break;
606 case EVT_CLOSE_CFM:
607 ProcessCloseCfm(msgData.stream.addr, role);
608 break;
609 case EVT_START_CFM:
610 ProcessStartCfm(msgData.stream.addr, role);
611 break;
612 case EVT_DELAY_IND:
613 ProcessDelayReportInd(msgData, role);
614 break;
615 default:
616 ProcessSubOpenState(msgData, role, msg.what_);
617 break;
618 }
619 return true;
620 }
621
SetStateName(std::string state)622 void A2dpStateOpen::SetStateName(std::string state)
623 {
624 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
625 Transition(state);
626 }
627
ProcessSubOpenState(A2dpAvdtMsgData msgData,uint8_t role,int cmd)628 void A2dpStateOpen::ProcessSubOpenState(A2dpAvdtMsgData msgData, uint8_t role, int cmd)
629 {
630 LOG_INFO("[A2dpStateOpen]%{public}s cmd(%{public}d)\n", __func__, cmd);
631
632 A2dpAvdtp avdtp(role);
633 uint8_t label = 0;
634
635 switch (cmd) {
636 case EVT_GET_ALLCAP_REQ:
637 avdtp.GetAllCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
638 break;
639 case EVT_GET_CAP_REQ:
640 avdtp.GetCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
641 break;
642 case EVT_TIME_OUT:
643 ProcessTimeout(msgData.stream.addr, role);
644 break;
645 default:
646 break;
647 }
648 }
649
ProcessCloseInd(A2dpAvdtMsgData msgData,uint8_t role)650 void A2dpStateOpen::ProcessCloseInd(A2dpAvdtMsgData msgData, uint8_t role)
651 {
652 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
653
654 A2dpAvdtp avdtp(role);
655
656 SetStateName(A2DP_PROFILE_CLOSING);
657 avdtp.CloseRsp(msgData.stream.handle, msgData.stream.label, 0);
658 }
659
ProcessStartInd(A2dpAvdtMsgData msgData,uint8_t role)660 void A2dpStateOpen::ProcessStartInd(A2dpAvdtMsgData msgData, uint8_t role)
661 {
662 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
663
664 A2dpProfile *profile = GetProfileInstance(role);
665 uint8_t gavdpRole = A2DP_ROLE_ACP;
666 A2dpAvdtp avdtp(role);
667 if (profile == nullptr) {
668 LOG_ERROR("[A2dpStateIdle]%{public}s Failed to get profile instance\n", __func__);
669 return;
670 }
671
672 SetStateName(A2DP_PROFILE_STREAMING);
673 if (avdtp.StartRsp(msgData.stream.handle, msgData.stream.label, 0, 0) == AVDT_SUCCESS) {
674 profile->AudioStateChangedNotify(msgData.stream.addr, A2DP_IS_PLAYING, (void *)&gavdpRole);
675 if (role == A2DP_ROLE_SOURCE) {
676 profile->NotifyEncoder(msgData.stream.addr);
677 } else {
678 profile->NotifyDecoder(msgData.stream.addr);
679 }
680 } else {
681 SetStateName(A2DP_PROFILE_OPEN);
682 }
683 }
684
ProcessDisconnectInd(BtAddr addr,uint16_t handle,uint8_t role)685 void A2dpStateOpen::ProcessDisconnectInd(BtAddr addr, uint16_t handle, uint8_t role)
686 {
687 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
688
689 CallbackParameter param = {A2DP_ROLE_ACP, false, handle};
690 A2dpProfile *profile = GetProfileInstance(role);
691 if (profile == nullptr) {
692 LOG_ERROR("[A2dpStateOpen]%{public}s Failed to get profile instance\n", __func__);
693 return;
694 }
695
696 if (role == A2DP_ROLE_SOURCE) {
697 IPowerManager::GetInstance().StatusUpdate(
698 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
699 }
700
701 SetStateName(A2DP_PROFILE_IDLE);
702 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
703 }
704
ProcessDisconnectReq(BtAddr addr,uint8_t role)705 void A2dpStateOpen::ProcessDisconnectReq(BtAddr addr, uint8_t role)
706 {
707 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
708
709 A2dpAvdtp avdtp(role);
710
711 SetStateName(A2DP_PROFILE_CLOSING);
712 avdtp.DisconnectReq(addr);
713 }
714
ProcessReconfigCfm(BtAddr addr,uint8_t role,uint16_t handle)715 void A2dpStateOpen::ProcessReconfigCfm(BtAddr addr, uint8_t role, uint16_t handle)
716 {
717 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
718
719 A2dpProfile *profile = GetProfileInstance(role);
720 A2dpAvdtp avdtp(role);
721 if (profile == nullptr) {
722 LOG_ERROR("[A2dpStateOpen]%{public}s Failed to get profile instance\n", __func__);
723 return;
724 }
725
726 profile->FindPeerByAddress(addr)->SetRestart(false);
727 if (Compat::CompatCheck(CompatType::COMPAT_REJECT_AVDTP_RECONFIGURE,
728 bluetooth::RawAddress::ConvertToString(addr.addr).GetAddress())) {
729 LOG_ERROR("[A2dpStateOpen]%{public}s The remote device is disable to reconfigure\n", __func__);
730 avdtp.CloseReq(handle);
731 return;
732 }
733 profile->CodecChangedNotify(addr, nullptr);
734
735 if (profile->IsActiveDevice(addr)) {
736 uint8_t label = 0;
737 avdtp.StartReq(handle, label);
738 }
739 }
740
ProcessCloseCfm(BtAddr addr,uint8_t role)741 void A2dpStateOpen::ProcessCloseCfm(BtAddr addr, uint8_t role)
742 {
743 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
744
745 A2dpProfile *profile = GetProfileInstance(role);
746 if (profile == nullptr) {
747 LOG_ERROR("[A2dpStateOpen]%{public}s Failed to get profile instance\n", __func__);
748 return;
749 }
750
751 SetStateName(A2DP_PROFILE_IDLE);
752 if (!profile->HasOpen() && profile->GetDisalbeTag()) {
753 profile->Disable();
754 }
755 if (profile->FindPeerByAddress(addr) != nullptr) {
756 if (profile->FindPeerByAddress(addr)->GetRestart()) {
757 profile->FindPeerByAddress(addr)->UpdateConfigure();
758 }
759 }
760 }
761
ProcessStartCfm(BtAddr addr,uint8_t role)762 void A2dpStateOpen::ProcessStartCfm(BtAddr addr, uint8_t role)
763 {
764 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
765
766 A2dpProfile *profile = GetProfileInstance(role);
767 uint8_t gavdpRole = A2DP_ROLE_INT;
768 if (profile == nullptr) {
769 LOG_ERROR("[A2dpStateOpen]%{public}s Failed to get profile instance\n", __func__);
770 return;
771 }
772
773 SetStateName(A2DP_PROFILE_STREAMING);
774 profile->AudioStateChangedNotify(addr, A2DP_IS_PLAYING, (void *)&gavdpRole);
775
776 if (role == A2DP_ROLE_SOURCE) {
777 profile->NotifyEncoder(addr);
778 } else {
779 profile->NotifyDecoder(addr);
780 }
781 }
782
ProcessDelayReportInd(A2dpAvdtMsgData msgData,uint8_t role) const783 void A2dpStateOpen::ProcessDelayReportInd(A2dpAvdtMsgData msgData, uint8_t role) const
784 {
785 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
786 if (role == A2DP_ROLE_SINK) {
787 LOG_INFO("[A2dpStateOpen]%{public}s sink role does not handle delay report ind return.", __func__);
788 return;
789 }
790
791 A2dpProfile *profile = GetProfileInstance(role);
792 if (profile == nullptr) {
793 LOG_ERROR("[A2dpStateOpen]%{public}s Failed to get profile instance\n", __func__);
794 return;
795 }
796
797 BtAddr addr = msgData.delayReportInfo.addr;
798 uint16_t value = msgData.delayReportInfo.delayValue;
799 profile->DelayReportNotify(addr, value);
800 }
801
ProcessTimeout(BtAddr addr,uint8_t role)802 void A2dpStateOpen::ProcessTimeout(BtAddr addr, uint8_t role)
803 {
804 LOG_INFO("[A2dpStateOpen]%{public}s\n", __func__);
805
806 A2dpAvdtp avdtp(role);
807
808 SetStateName(A2DP_PROFILE_CLOSING);
809 avdtp.DisconnectReq(addr);
810 }
811
Entry()812 void A2dpStateStreaming::Entry()
813 {
814 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
815 A2dpCodecThread *codecThread = A2dpCodecThread::GetInstance();
816 if (codecThread == nullptr) {
817 return;
818 }
819 if (codecThread->GetInitStatus()) {
820 codecThread->StartTimer();
821 } else {
822 if (codecThread != nullptr) {
823 codecThread->StartA2dpCodecThread();
824 }
825 }
826 }
827
Exit()828 void A2dpStateStreaming::Exit()
829 {
830 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
831 A2dpCodecThread *codecThread = A2dpCodecThread::GetInstance();
832 if (codecThread->GetInitStatus()) {
833 codecThread->StopTimer();
834 }
835 }
836
Dispatch(const utility::Message & msg)837 bool A2dpStateStreaming::Dispatch(const utility::Message &msg)
838 {
839 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
840 if (msg.arg2_ == nullptr) {
841 LOG_ERROR("[A2dpStateStreaming]%{public}s input error parameter\n", __func__);
842 return false;
843 }
844 A2dpAvdtMsgData msgData = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->a2dpMsg;
845 uint8_t role = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->role;
846 A2dpAvdtp avdtp(role);
847 uint8_t label = 0;
848
849 switch (msg.what_) {
850 case EVT_GET_ALLCAP_REQ:
851 avdtp.GetAllCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
852 break;
853 case EVT_GET_CAP_REQ:
854 avdtp.GetCapabilityReq(msgData.stream.addr, msgData.stream.acpSeid, label);
855 break;
856 case EVT_SUSPEND_IND:
857 ProcessSuspendInd(msgData, role);
858 break;
859 case EVT_CLOSE_IND:
860 SetStateName(A2DP_PROFILE_IDLE);
861 avdtp.CloseRsp(msgData.stream.handle, msgData.stream.label, 0);
862 break;
863 case EVT_DISCONNECT_IND:
864 ProcessDisconnectInd(msgData.stream.addr, msgData.stream.handle, role);
865 break;
866 case EVT_DISCONNECT_REQ:
867 ProcessDisconnectReq(msgData.connectInfo.addr, role);
868 break;
869 case EVT_CLOSE_REQ:
870 avdtp.CloseReq(msgData.stream.handle);
871 break;
872 case EVT_SUSPEND_REQ:
873 ProcessSuspendReq(msgData.stream.handle, role);
874 break;
875 case EVT_CLOSE_CFM:
876 ProcessCloseCfm(msgData.stream.addr, role);
877 break;
878 case EVT_SUSPEND_CFM:
879 ProcessSuspendCfm(msgData, role);
880 break;
881 case EVT_WRITE_CFM:
882 ProcessWriteCfm(msgData, role);
883 break;
884 case EVT_DELAY_IND:
885 ProcessDelayReportInd(msgData, role);
886 break;
887 default:
888 break;
889 }
890 return true;
891 }
892
SetStateName(std::string state)893 void A2dpStateStreaming::SetStateName(std::string state)
894 {
895 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
896 Transition(state);
897 }
898
ProcessSuspendInd(A2dpAvdtMsgData msgData,uint8_t role)899 void A2dpStateStreaming::ProcessSuspendInd(A2dpAvdtMsgData msgData, uint8_t role)
900 {
901 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
902
903 A2dpProfile *profile = GetProfileInstance(role);
904 uint8_t gavdpRole = A2DP_ROLE_ACP;
905 A2dpAvdtp avdtp(role);
906 if (profile == nullptr) {
907 LOG_ERROR("[A2dpStateStreaming]%{public}s Failed to get profile instance\n", __func__);
908 return;
909 }
910
911 /// check the stream status
912 if (avdtp.SuspendRsp(msgData.stream.handle, msgData.stream.label, 0, 0) == AVDT_SUCCESS) {
913 SetStateName(A2DP_PROFILE_OPEN);
914 profile->AudioStateChangedNotify(msgData.stream.addr, A2DP_NOT_PLAYING, (void *)&gavdpRole);
915 }
916 }
917
ProcessSuspendCfm(A2dpAvdtMsgData msgData,uint8_t role)918 void A2dpStateStreaming::ProcessSuspendCfm(A2dpAvdtMsgData msgData, uint8_t role)
919 {
920 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
921
922 A2dpProfile *profile = GetProfileInstance(role);
923 uint8_t gavdpRole = A2DP_ROLE_INT;
924 A2dpAvdtp avdtp(role);
925 if (profile == nullptr) {
926 LOG_ERROR("[A2dpStateStreaming]%{public}s Failed to get profile instance\n", __func__);
927 return;
928 }
929
930 if (role == A2DP_ROLE_SOURCE) {
931 IPowerManager::GetInstance().StatusUpdate(RequestStatus::CONNECT_ON,
932 PROFILE_NAME_A2DP_SRC,
933 bluetooth::RawAddress::ConvertToString(msgData.stream.addr.addr));
934 }
935 SetStateName(A2DP_PROFILE_OPEN);
936 profile->AudioStateChangedNotify(msgData.stream.addr, A2DP_NOT_PLAYING, (void *)&gavdpRole);
937 A2dpService *service = GetServiceInstance(role);
938 if (service != nullptr) {
939 std::string addr = service->GetActiveSinkDevice().GetAddress();
940 if (strcmp(addr.c_str(), RawAddress::ConvertToString(msgData.stream.addr.addr).GetAddress().c_str()) != 0) {
941 service->ActiveDevice();
942 }
943 }
944 if (profile->GetDisalbeTag()) {
945 profile->CloseAll();
946 }
947 if (profile->FindPeerByAddress(msgData.stream.addr)->GetRestart()) {
948 avdtp.ReconfigureReq(
949 msgData.stream.handle, profile->FindPeerByAddress(msgData.stream.addr)->GetReconfig(), label_);
950 }
951 }
952
ProcessWriteCfm(A2dpAvdtMsgData msgData,uint8_t role)953 void A2dpStateStreaming::ProcessWriteCfm(A2dpAvdtMsgData msgData, uint8_t role)
954 {
955 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
956 A2dpProfile *profile = GetProfileInstance(A2DP_ROLE_SOURCE);
957 profile->DequeuePacket();
958 }
959
ProcessDisconnectReq(BtAddr addr,uint8_t role)960 void A2dpStateStreaming::ProcessDisconnectReq(BtAddr addr, uint8_t role)
961 {
962 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
963
964 A2dpAvdtp avdtp(role);
965
966 SetStateName(A2DP_PROFILE_CLOSING);
967 avdtp.DisconnectReq(addr);
968 if (role == A2DP_ROLE_SOURCE) {
969 IPowerManager::GetInstance().StatusUpdate(
970 RequestStatus::IDLE, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
971 }
972 }
973
ProcessSuspendReq(uint16_t handle,uint8_t role)974 void A2dpStateStreaming::ProcessSuspendReq(uint16_t handle, uint8_t role)
975 {
976 LOG_INFO("[A2dpStateStreaming]%{public}s role(%u)\n", __func__, role);
977
978 A2dpAvdtp avdtp(role);
979 avdtp.SuspendReq(handle, label_);
980 }
981
ProcessDisconnectInd(BtAddr addr,uint16_t handle,uint8_t role)982 void A2dpStateStreaming::ProcessDisconnectInd(BtAddr addr, uint16_t handle, uint8_t role)
983 {
984 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
985
986 CallbackParameter param = {A2DP_ROLE_ACP, false, handle};
987 A2dpProfile *profile = GetProfileInstance(role);
988 uint8_t gavdpRole = A2DP_ROLE_ACP;
989 if (profile == nullptr) {
990 LOG_ERROR("[A2dpStateStreaming]%{public}s Failed to get profile instance\n", __func__);
991 return;
992 }
993
994 if (role == A2DP_ROLE_SOURCE) {
995 IPowerManager::GetInstance().StatusUpdate(
996 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
997 }
998 SetStateName(A2DP_PROFILE_IDLE);
999 profile->AudioStateChangedNotify(addr, A2DP_NOT_PLAYING, (void *)&gavdpRole);
1000 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
1001 }
1002
ProcessCloseCfm(BtAddr addr,uint8_t role)1003 void A2dpStateStreaming::ProcessCloseCfm(BtAddr addr, uint8_t role)
1004 {
1005 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
1006
1007 A2dpProfile *profile = GetProfileInstance(role);
1008 if (profile == nullptr) {
1009 LOG_ERROR("[A2dpStateOpen]%{public}s Failed to get profile instance\n", __func__);
1010 return;
1011 }
1012
1013 if (role == A2DP_ROLE_SOURCE) {
1014 IPowerManager::GetInstance().StatusUpdate(
1015 RequestStatus::IDLE, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
1016 }
1017
1018 SetStateName(A2DP_PROFILE_IDLE);
1019 if (profile->FindPeerByAddress(addr)->GetRestart()) {
1020 profile->FindPeerByAddress(addr)->UpdateConfigure();
1021 }
1022 }
1023
ProcessDelayReportInd(A2dpAvdtMsgData msgData,uint8_t role) const1024 void A2dpStateStreaming::ProcessDelayReportInd(A2dpAvdtMsgData msgData, uint8_t role) const
1025 {
1026 LOG_INFO("[A2dpStateStreaming]%{public}s\n", __func__);
1027 if (role == A2DP_ROLE_SINK) {
1028 LOG_INFO("[A2dpStateStreaming]%{public}s sink role does not handle delay report ind return.", __func__);
1029 return;
1030 }
1031
1032 A2dpProfile *profile = GetProfileInstance(role);
1033 if (profile == nullptr) {
1034 LOG_ERROR("[A2dpStateStreaming]%{public}s Failed to get profile instance\n", __func__);
1035 return;
1036 }
1037
1038 BtAddr addr = msgData.delayReportInfo.addr;
1039 uint16_t value = msgData.delayReportInfo.delayValue;
1040 profile->DelayReportNotify(addr, value);
1041 }
1042
Dispatch(const utility::Message & msg)1043 bool A2dpStateClosing::Dispatch(const utility::Message &msg)
1044 {
1045 LOG_INFO("[A2dpStateClosing]%{public}s\n", __func__);
1046
1047 if (msg.arg2_ == nullptr) {
1048 LOG_ERROR("[A2dpStateClosing]%{public}s input error parameter\n", __func__);
1049 return false;
1050 }
1051
1052 A2dpAvdtMsgData msgData = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->a2dpMsg;
1053 uint8_t role = (static_cast<A2dpAvdtMsg*>(msg.arg2_))->role;
1054
1055 switch (msg.what_) {
1056 case EVT_DISCONNECT_IND:
1057 ProcessDisconnectInd(msgData.stream.addr, msgData.stream.handle, role);
1058 break;
1059 case EVT_CLOSE_TRANS_IND:
1060 ProcessCloseStreamInd(msgData.stream.addr, msgData.stream.handle, role);
1061 break;
1062 case EVT_DISCONNECT_CFM:
1063 ProcessDisconnectCfm(msgData.stream.addr, msgData.stream.handle, role);
1064 break;
1065 default:
1066 break;
1067 }
1068 return true;
1069 }
1070
SetStateName(std::string state)1071 void A2dpStateClosing::SetStateName(std::string state)
1072 {
1073 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
1074 Transition(state);
1075 }
1076
ProcessCloseStreamInd(BtAddr addr,uint16_t handle,uint8_t role)1077 void A2dpStateClosing::ProcessCloseStreamInd(BtAddr addr, uint16_t handle, uint8_t role)
1078 {
1079 LOG_INFO("[A2dpStateClosing]%{public}s\n", __func__);
1080 A2dpProfile *profile = GetProfileInstance(role);
1081 if (profile == nullptr) {
1082 LOG_ERROR("[A2dpStateClosing]%{public}s Failed to get profile instance\n", __func__);
1083 return;
1084 }
1085
1086 SetStateName(A2DP_PROFILE_IDLE);
1087 A2dpProfilePeer *peer = profile->FindOrCreatePeer(addr, role);
1088 if (peer == nullptr) {
1089 LOG_ERROR("[A2dpStateClosing]%{public}s Failed to get profile Peer\n", __func__);
1090 return;
1091 }
1092 peer->SetCurrentCmd(EVT_DISCONNECT_IND);
1093 peer->SetSignalingTimer(A2DP_ACCEPT_SIGNALLING_TIMEOUT_MS, false);
1094 }
1095
ProcessDisconnectInd(BtAddr addr,uint16_t handle,uint8_t role)1096 void A2dpStateClosing::ProcessDisconnectInd(BtAddr addr, uint16_t handle, uint8_t role)
1097 {
1098 LOG_INFO("[A2dpStateClosing]%{public}s\n", __func__);
1099
1100 CallbackParameter param = {A2DP_ROLE_INT, false, handle};
1101 A2dpProfile *profile = GetProfileInstance(role);
1102 if (profile == nullptr) {
1103 LOG_ERROR("[A2dpStateClosing]%{public}s Failed to get profile instance\n", __func__);
1104 return;
1105 }
1106
1107 if (role == A2DP_ROLE_SOURCE) {
1108 IPowerManager::GetInstance().StatusUpdate(
1109 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
1110 }
1111
1112 SetStateName(A2DP_PROFILE_IDLE);
1113 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
1114 }
1115
ProcessDisconnectCfm(BtAddr addr,uint16_t handle,uint8_t role)1116 void A2dpStateClosing::ProcessDisconnectCfm(BtAddr addr, uint16_t handle, uint8_t role)
1117 {
1118 LOG_INFO("[A2dpStateClosing]%{public}s\n", __func__);
1119
1120 CallbackParameter param = {A2DP_ROLE_INT, true, handle};
1121 uint8_t gavdpRole = A2DP_ROLE_INT;
1122 A2dpProfile *profile = GetProfileInstance(role);
1123 if (profile == nullptr) {
1124 LOG_ERROR("[A2dpStateClosing]%{public}s Failed to get profile instance\n", __func__);
1125 return;
1126 }
1127
1128 if (role == A2DP_ROLE_SOURCE) {
1129 IPowerManager::GetInstance().StatusUpdate(
1130 RequestStatus::CONNECT_OFF, PROFILE_NAME_A2DP_SRC, bluetooth::RawAddress::ConvertToString(addr.addr));
1131 }
1132
1133 SetStateName(A2DP_PROFILE_IDLE);
1134 profile->AudioStateChangedNotify(addr, A2DP_NOT_PLAYING, (void *)&gavdpRole);
1135 profile->ConnectStateChangedNotify(addr, STREAM_DISCONNECT, (void *)¶m);
1136 }
1137
GetStateName(void) const1138 const std::string A2dpStateMachine::GetStateName(void) const
1139 {
1140 std::lock_guard<std::recursive_mutex> lock(g_stateMutex);
1141 return GetState()->Name();
1142 }
1143 } // namespace bluetooth
1144 } // namespace OHOS
1145