1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "avrcp_ct_state_machine.h"
17 #include "avrcp_ct_pass_through.h"
18 #include "avrcp_ct_vendor.h"
19
20 namespace OHOS {
21 namespace bluetooth {
22 /// The name of state "CONNECTING".
23 const std::string AVRC_CT_SM_STATE_CONNECTING = "CONNECTING";
24 /// The name of state "CONNECTED".
25 const std::string AVRC_CT_SM_STATE_CONNECTED = "CONNECTED";
26 /// The name of state "DISCONNECTING".
27 const std::string AVRC_CT_SM_STATE_DISCONNECTING = "DISCONNECTING";
28 /// The name of state "PENDING".
29 const std::string AVRC_CT_SM_STATE_PENDING = "PENDING";
30 /// The name of state "BUSY".
31 const std::string AVRC_CT_SM_STATE_BUSY = "BUSY";
32 /// The name of state "CONTINUATION".
33 const std::string AVRC_CT_SM_STATE_CONTINUATION = "CONTINUATION";
34 /// The name of state "DISABLE".
35 const std::string AVRC_CT_SM_STATE_DISABLE = "DISABLE";
36
GetInstance(void)37 AvrcCtStateMachineManager *AvrcCtStateMachineManager::GetInstance(void)
38 {
39 HILOGI("enter");
40
41 static AvrcCtStateMachineManager instance;
42
43 return &instance;
44 }
45
~AvrcCtStateMachineManager()46 AvrcCtStateMachineManager::~AvrcCtStateMachineManager()
47 {
48 HILOGI("enter");
49 stateMachines_.clear();
50 }
51
ShutDown(void)52 void AvrcCtStateMachineManager::ShutDown(void)
53 {
54 HILOGI("enter");
55 std::lock_guard<std::recursive_mutex> lock(mutex_);
56 stateMachines_.clear();
57 }
58
AddControlStateMachine(const RawAddress & rawAddr)59 int AvrcCtStateMachineManager::AddControlStateMachine(const RawAddress &rawAddr)
60 {
61 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
62
63 std::lock_guard<std::recursive_mutex> lock(mutex_);
64
65 int result = BT_SUCCESS;
66
67 if (GetPairOfStateMachine(rawAddr.GetAddress()) == nullptr) {
68 std::unique_ptr<StateMachine> stateMachine =
69 std::make_unique<StateMachine>(StateMachine::Type::AVRC_CT_SM_TYPE_CONTROL, rawAddr);
70 stateMachine->AddStates();
71 stateMachine->InitState(AVRC_CT_SM_STATE_CONNECTING);
72 stateMachines_.insert(std::make_pair(rawAddr.GetAddress(), std::make_pair(std::move(stateMachine), nullptr)));
73 } else {
74 result = RET_BAD_PARAM;
75 HILOGI("The control state machine exists! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
76 }
77
78 return result;
79 }
80
AddBrowseStateMachine(const RawAddress & rawAddr)81 int AvrcCtStateMachineManager::AddBrowseStateMachine(const RawAddress &rawAddr)
82 {
83 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
84
85 std::lock_guard<std::recursive_mutex> lock(mutex_);
86
87 int result = BT_SUCCESS;
88
89 StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
90 if (pair == nullptr) {
91 result = RET_BAD_PARAM;
92 HILOGI("The pair of state machines doest not exists! Address:%{public}s",
93 GET_ENCRYPT_AVRCP_ADDR(rawAddr));
94 } else if (pair->second == nullptr) {
95 pair->second = std::make_unique<StateMachine>(StateMachine::Type::AVRC_CT_SM_TYPE_BROWSE, rawAddr);
96 pair->second->AddStates();
97 pair->second->InitState(AVRC_CT_SM_STATE_CONNECTING);
98 } else {
99 result = RET_BAD_PARAM;
100 HILOGI("The browse state machine exists! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
101 }
102
103 return result;
104 }
105
DeletePairOfStateMachine(const RawAddress & rawAddr)106 void AvrcCtStateMachineManager::DeletePairOfStateMachine(const RawAddress &rawAddr)
107 {
108 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
109
110 std::lock_guard<std::recursive_mutex> lock(mutex_);
111
112 StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
113 if (pair != nullptr) {
114 stateMachines_.erase(rawAddr.GetAddress());
115 } else {
116 HILOGI("The pair of state machines does not exist! Address: %{public}s",
117 GET_ENCRYPT_AVRCP_ADDR(rawAddr));
118 }
119 }
120
DeleteBrowseStateMachine(const RawAddress & rawAddr)121 void AvrcCtStateMachineManager::DeleteBrowseStateMachine(const RawAddress &rawAddr)
122 {
123 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
124
125 std::lock_guard<std::recursive_mutex> lock(mutex_);
126
127 StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
128 if (pair != nullptr && pair->second != nullptr) {
129 pair->second = nullptr;
130 } else {
131 HILOGI("The browse state machine does not exist! Address: %{public}s",
132 GET_ENCRYPT_AVRCP_ADDR(rawAddr));
133 }
134 }
135
SendMessageToControlStateMachine(const RawAddress & rawAddr,const utility::Message & msg)136 bool AvrcCtStateMachineManager::SendMessageToControlStateMachine(const RawAddress &rawAddr, const utility::Message &msg)
137 {
138 HILOGI("addr: %{public}s, msg: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), msg.what_);
139 std::lock_guard<std::recursive_mutex> lock(mutex_);
140 bool result = false;
141
142 StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
143 if (pair != nullptr && pair->first != nullptr) {
144 result = pair->first->ProcessMessage(msg);
145 if (!result) {
146 HILOGI("Unknown message: %{public}d]! Address: %{public}s", msg.what_, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
147 }
148 } else {
149 HILOGI("The control state machine does not exist! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
150 }
151
152 return result;
153 }
154
SendMessageToAllControlStateMachine(const utility::Message & msg)155 void AvrcCtStateMachineManager::SendMessageToAllControlStateMachine(const utility::Message &msg)
156 {
157 HILOGI("msg: %{public}x", msg.what_);
158 std::lock_guard<std::recursive_mutex> lock(mutex_);
159
160 for (auto &pairSm : stateMachines_) {
161 if (pairSm.second.first != nullptr) {
162 pairSm.second.first->ProcessMessage(msg);
163 }
164 }
165 }
166
SendMessageToBrowseStateMachine(const RawAddress & rawAddr,const utility::Message & msg)167 bool AvrcCtStateMachineManager::SendMessageToBrowseStateMachine(const RawAddress &rawAddr, const utility::Message &msg)
168 {
169 HILOGI("addr: %{public}s, msg: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), msg.what_);
170 std::lock_guard<std::recursive_mutex> lock(mutex_);
171 bool result = false;
172
173 StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
174 if (pair != nullptr && pair->second != nullptr) {
175 result = pair->second->ProcessMessage(msg);
176 if (!result) {
177 HILOGI("Unknown message: %{public}d]! Address: %{public}s", msg.what_, GET_ENCRYPT_AVRCP_ADDR(rawAddr));
178 }
179 } else {
180 HILOGI("The browse state machine does not exist! Address: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
181 }
182
183 return result;
184 }
185
SendMessageToAllBrowseStateMachine(const utility::Message & msg)186 void AvrcCtStateMachineManager::SendMessageToAllBrowseStateMachine(const utility::Message &msg)
187 {
188 HILOGI("msg: %{public}x", msg.what_);
189 std::lock_guard<std::recursive_mutex> lock(mutex_);
190
191 for (auto &pairSm : stateMachines_) {
192 if (pairSm.second.second != nullptr) {
193 pairSm.second.second->ProcessMessage(msg);
194 }
195 }
196 }
197
IsControlConnectingState(const RawAddress & rawAddr)198 bool AvrcCtStateMachineManager::IsControlConnectingState(const RawAddress &rawAddr)
199 {
200 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
201
202 return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_CONNECTING);
203 }
204
IsControlConnectedState(const RawAddress & rawAddr)205 bool AvrcCtStateMachineManager::IsControlConnectedState(const RawAddress &rawAddr)
206 {
207 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
208
209 return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_CONNECTED);
210 }
211
IsControlDisconnectingState(const RawAddress & rawAddr)212 bool AvrcCtStateMachineManager::IsControlDisconnectingState(const RawAddress &rawAddr)
213 {
214 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
215
216 return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_DISCONNECTING);
217 }
218
IsControlPendingState(const RawAddress & rawAddr)219 bool AvrcCtStateMachineManager::IsControlPendingState(const RawAddress &rawAddr)
220 {
221 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
222
223 return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_PENDING);
224 }
225
IsBrowsePendingState(const RawAddress & rawAddr)226 bool AvrcCtStateMachineManager::IsBrowsePendingState(const RawAddress &rawAddr)
227 {
228 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
229
230 return IsBrowseSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_PENDING);
231 }
232
IsControlContinuationState(const RawAddress & rawAddr)233 bool AvrcCtStateMachineManager::IsControlContinuationState(const RawAddress &rawAddr)
234 {
235 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
236
237 return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_CONTINUATION);
238 }
239
IsControlDisableState(const RawAddress & rawAddr)240 bool AvrcCtStateMachineManager::IsControlDisableState(const RawAddress &rawAddr)
241 {
242 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
243
244 return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_CT_SM_STATE_DISABLE);
245 }
246
AvrcCtStateMachineManager()247 AvrcCtStateMachineManager::AvrcCtStateMachineManager()
248 {
249 HILOGI("enter");
250 }
251
GetPairOfStateMachine(const std::string & addr)252 AvrcCtStateMachineManager::StateMachinePair *AvrcCtStateMachineManager::GetPairOfStateMachine(const std::string &addr)
253 {
254 HILOGI("addr: %{public}s", GetEncryptAddr(addr).c_str());
255 std::lock_guard<std::recursive_mutex> lock(mutex_);
256 StateMachinePair *pair = nullptr;
257
258 auto iter = stateMachines_.find(addr);
259 if (iter != stateMachines_.end()) {
260 pair = &iter->second;
261 }
262
263 return pair;
264 }
265
IsControlSpecifiedState(const std::string & addr,std::string stateName)266 bool AvrcCtStateMachineManager::IsControlSpecifiedState(const std::string &addr, std::string stateName)
267 {
268 HILOGI("addr: %{public}s, stateName: %{public}s", GetEncryptAddr(addr).c_str(), stateName.c_str());
269
270 std::lock_guard<std::recursive_mutex> lock(mutex_);
271
272 int result = false;
273
274 StateMachinePair *pair = GetPairOfStateMachine(addr);
275 if (pair != nullptr && pair->first != nullptr) {
276 if (pair->first->GetState()->Name().compare(stateName) == 0) {
277 result = true;
278 }
279 } else {
280 HILOGI("The pair of state machines does not exist!");
281 }
282
283 return result;
284 }
285
IsBrowseSpecifiedState(const std::string & addr,std::string stateName)286 bool AvrcCtStateMachineManager::IsBrowseSpecifiedState(const std::string &addr, std::string stateName)
287 {
288 HILOGI("addr: %{public}s, stateName: %{public}s", GetEncryptAddr(addr).c_str(), stateName.c_str());
289
290 std::lock_guard<std::recursive_mutex> lock(mutex_);
291
292 int result = false;
293
294 StateMachinePair *pair = GetPairOfStateMachine(addr);
295 if (pair != nullptr && pair->second != nullptr) {
296 if (pair->second->GetState()->Name().compare(stateName) == 0) {
297 result = true;
298 }
299 } else {
300 HILOGI("The pair of state machines does not exist!");
301 }
302
303 return result;
304 }
305
StateMachine(Type type,const RawAddress & rawAddr)306 AvrcCtStateMachineManager::StateMachine::StateMachine(Type type, const RawAddress &rawAddr)
307 : type_(type), rawAddr_(rawAddr)
308 {
309 HILOGI("enter");
310 }
311
AddStates(void)312 void AvrcCtStateMachineManager::StateMachine::AddStates(void)
313 {
314 HILOGI("enter");
315
316 if (type_ == Type::AVRC_CT_SM_TYPE_CONTROL) {
317 /// CONNECTING state.
318
319 std::unique_ptr<utility::StateMachine::State> ctConnectingPtr =
320 std::make_unique<CtConnecting>(AVRC_CT_SM_STATE_CONNECTING, *this, rawAddr_);
321
322 /// CONNECTED state.
323
324 std::unique_ptr<utility::StateMachine::State> ctConnectedPtr =
325 std::make_unique<CtConnected>(AVRC_CT_SM_STATE_CONNECTED, *this, rawAddr_, *ctConnectingPtr.get());
326
327 /// DISCONNECTING state.
328
329 std::unique_ptr<utility::StateMachine::State> ctDisconnectingPtr =
330 std::make_unique<CtDisconnecting>(AVRC_CT_SM_STATE_DISCONNECTING, *this, rawAddr_, *ctConnectedPtr.get());
331
332 /// PENDING state.
333
334 std::unique_ptr<utility::StateMachine::State> ctPendingPtr =
335 std::make_unique<CtPending>(AVRC_CT_SM_STATE_PENDING, *this, rawAddr_, *ctConnectedPtr.get());
336
337 /// CONTINUATION state.
338
339 std::unique_ptr<utility::StateMachine::State> ctContinuationPtr =
340 std::make_unique<CtContinuation>(AVRC_CT_SM_STATE_CONTINUATION, *this, rawAddr_, *ctConnectedPtr.get());
341
342 /// DISABLE state.
343
344 std::unique_ptr<utility::StateMachine::State> ctDisablePtr =
345 std::make_unique<CtDisable>(AVRC_CT_SM_STATE_DISABLE, *this, rawAddr_, *ctConnectedPtr.get());
346
347 Move(ctDisconnectingPtr);
348 Move(ctPendingPtr);
349 Move(ctContinuationPtr);
350 Move(ctDisablePtr);
351 Move(ctConnectedPtr);
352 Move(ctConnectingPtr);
353 } else if (type_ == Type::AVRC_CT_SM_TYPE_BROWSE) {
354 /// CONNECTING state.
355
356 std::unique_ptr<utility::StateMachine::State> brConnectingPtr =
357 std::make_unique<BrConnecting>(AVRC_CT_SM_STATE_CONNECTING, *this, rawAddr_);
358
359 /// CONNECTED state.
360
361 std::unique_ptr<utility::StateMachine::State> brConnectedPtr =
362 std::make_unique<BrConnected>(AVRC_CT_SM_STATE_CONNECTED, *this, rawAddr_, *brConnectingPtr.get());
363
364 /// DISCONNECTING state.
365
366 std::unique_ptr<utility::StateMachine::State> brDisconnectingPtr =
367 std::make_unique<BrDisconnecting>(AVRC_CT_SM_STATE_DISCONNECTING, *this, rawAddr_, *brConnectedPtr.get());
368
369 /// PENDING state.
370
371 std::unique_ptr<utility::StateMachine::State> brPendingPtr =
372 std::make_unique<BrPending>(AVRC_CT_SM_STATE_PENDING, *this, rawAddr_, *brConnectedPtr.get());
373
374 Move(brPendingPtr);
375 Move(brDisconnectingPtr);
376 Move(brConnectedPtr);
377 Move(brConnectingPtr);
378 } else {
379 HILOGI("The type of the state machine is wrong!");
380 }
381 }
382
383 /******************************************************************
384 * AvrcCtStateMachineManager::StateMachine::State *
385 ******************************************************************/
386
State(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)387 AvrcCtStateMachineManager::StateMachine::State::State(const std::string &name, utility::StateMachine &stateMachine,
388 const RawAddress &rawAddr, utility::StateMachine::State &parent)
389 : utility::StateMachine::State(name, stateMachine, parent), rawAddr_(rawAddr)
390 {
391 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
392 }
393
State(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr)394 AvrcCtStateMachineManager::StateMachine::State::State(
395 const std::string &name, utility::StateMachine &stateMachine, const RawAddress &rawAddr)
396 : utility::StateMachine::State(name, stateMachine), rawAddr_(rawAddr)
397 {
398 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
399 }
400
~State()401 AvrcCtStateMachineManager::StateMachine::State::~State()
402 {
403 HILOGI("enter");
404 }
405
406 /******************************************************************
407 * AvrcCtStateMachineManager::StateMachine::CtConnecting *
408 ******************************************************************/
409
CtConnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr)410 AvrcCtStateMachineManager::StateMachine::CtConnecting::CtConnecting(
411 const std::string &name, utility::StateMachine &stateMachine, const RawAddress &rawAddr)
412 : State(name, stateMachine, rawAddr)
413 {
414 HILOGI("addr: %{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
415 }
416
Entry(void)417 void AvrcCtStateMachineManager::StateMachine::CtConnecting::Entry(void)
418 {
419 HILOGI("enter");
420
421 const AvrcCtConnectInfo *info = AvrcCtConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
422
423 AVCT_Register(info->controlMtu_, info->browseMtu_, AVCT_CT);
424
425 uint8_t connectId = 0x00;
426 AvctConnectParam param = {info->eventCallback_, info->msgCallback_, AVRC_CT_AV_REMOTE_CONTROL, info->role_,
427 nullptr};
428 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
429 rawAddr_.ConvertToUint8(btAddr.addr);
430
431 if (AVCT_ConnectReq(&connectId, ¶m, &btAddr) != AVCT_SUCCESS) {
432 info->eventCallback_(connectId, AVCT_CONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
433 HILOGI("Call AVCT_ConnectReq Failed! Address: %{public}s", GetEncryptAddr(rawAddr_.GetAddress()).c_str());
434 }
435 }
436
Exit(void)437 void AvrcCtStateMachineManager::StateMachine::CtConnecting::Exit(void)
438 {
439 HILOGI("enter");
440 }
441
Dispatch(const utility::Message & msg)442 bool AvrcCtStateMachineManager::StateMachine::CtConnecting::Dispatch(const utility::Message &msg)
443 {
444 HILOGI("enter");
445
446 bool result = true;
447
448 switch (msg.what_) {
449 case AVRC_CT_SM_EVENT_TO_DISABLE_STATE:
450 Transition(AVRC_CT_SM_STATE_DISABLE);
451 break;
452 case AVRC_CT_SM_EVENT_TO_CONNECTED_STATE:
453 Transition(AVRC_CT_SM_STATE_CONNECTED);
454 break;
455 default:
456 result = false;
457 break;
458 }
459
460 return result;
461 }
462
463 /******************************************************************
464 * AvrcCtStateMachineManager::StateMachine::CtConnected *
465 ******************************************************************/
466
CtConnected(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)467 AvrcCtStateMachineManager::StateMachine::CtConnected::CtConnected(const std::string &name,
468 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
469 : State(name, stateMachine, rawAddr, parent)
470 {
471 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
472 }
473
Entry(void)474 void AvrcCtStateMachineManager::StateMachine::CtConnected::Entry(void)
475 {
476 HILOGI("enter");
477 }
478
Exit(void)479 void AvrcCtStateMachineManager::StateMachine::CtConnected::Exit(void)
480 {
481 HILOGI("enter");
482 }
483
Dispatch(const utility::Message & msg)484 bool AvrcCtStateMachineManager::StateMachine::CtConnected::Dispatch(const utility::Message &msg)
485 {
486 HILOGI("enter");
487
488 bool result = true;
489 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
490
491 switch (msg.what_) {
492 case AVRC_CT_SM_EVENT_TO_DISCONNECTING_STATE:
493 Transition(AVRC_CT_SM_STATE_DISCONNECTING);
494 break;
495 case AVRC_CT_SM_EVENT_PASS_THROUGH: {
496 std::shared_ptr<AvrcCtPassPacket> packet = cnManager->GetPassPacket(rawAddr_);
497
498 AVCT_SendMsgReq(
499 cnManager->GetConnectId(rawAddr_), AVRC_DEFAULT_LABEL, AVCT_COMMAND, packet->AssemblePacket());
500 break;
501 }
502 case AVRC_CT_SM_EVENT_UNIT_INFO:
503 /// FALL THROUGH
504 case AVRC_CT_SM_EVENT_SUB_UNIT_INFO: {
505 std::shared_ptr<AvrcCtUnitPacket> packet = cnManager->GetUnitPacket(rawAddr_);
506
507 AVCT_SendMsgReq(
508 cnManager->GetConnectId(rawAddr_), AVRC_DEFAULT_LABEL, AVCT_COMMAND, packet->AssemblePacket());
509
510 Transition(AVRC_CT_SM_STATE_PENDING);
511 break;
512 }
513 case AVRC_CT_SM_EVENT_REGISTER_NOTIFICATION:
514 case AVRC_CT_SM_EVENT_GET_CAPABILITIES:
515 case AVRC_CT_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:
516 case AVRC_CT_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_VALUES:
517 case AVRC_CT_SM_EVENT_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:
518 case AVRC_CT_SM_EVENT_SET_PLAYER_APPLICATION_SETTING_VALUE:
519 case AVRC_CT_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:
520 case AVRC_CT_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:
521 case AVRC_CT_SM_EVENT_GET_ELEMENT_ATTRIBUTES:
522 case AVRC_CT_SM_EVENT_GET_PLAY_STATUS:
523 case AVRC_CT_SM_EVENT_REQUEST_CONTINUING_RESPONSE:
524 case AVRC_CT_SM_EVENT_ABORT_CONTINUING_RESPONSE:
525 case AVRC_CT_SM_EVENT_SET_ADDRESSED_PLAYER:
526 case AVRC_CT_SM_EVENT_PLAY_ITEM:
527 case AVRC_CT_SM_EVENT_ADD_TO_NOW_PLAYING:
528 case AVRC_CT_SM_EVENT_SET_ABSOLUTE_VOLUME: {
529 std::shared_ptr<AvrcCtVendorPacket> packet = cnManager->GetVendorPacket(rawAddr_);
530
531 AVCT_SendMsgReq(
532 cnManager->GetConnectId(rawAddr_), AVRC_DEFAULT_LABEL, AVCT_COMMAND, packet->AssemblePacket());
533
534 Transition(AVRC_CT_SM_STATE_PENDING);
535 break;
536 }
537 default:
538 result = false;
539 break;
540 }
541
542 return result;
543 }
544
545 /******************************************************************
546 * AvrcCtStateMachineManager::StateMachine::CtDisconnecting *
547 ******************************************************************/
548
CtDisconnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)549 AvrcCtStateMachineManager::StateMachine::CtDisconnecting::CtDisconnecting(const std::string &name,
550 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
551 : State(name, stateMachine, rawAddr, parent)
552 {
553 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
554 }
555
Entry(void)556 void AvrcCtStateMachineManager::StateMachine::CtDisconnecting::Entry(void)
557 {
558 HILOGI("enter");
559
560 const AvrcCtConnectInfo *info = AvrcCtConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
561
562 if (AVCT_DisconnectReq(info->connectId_) != AVCT_SUCCESS) {
563 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
564 rawAddr_.ConvertToUint8(btAddr.addr);
565 info->eventCallback_(info->connectId_, AVCT_DISCONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
566 HILOGI("Call AVCT_DisconnectReq Failed! Address: %{public}s", GetEncryptAddr(rawAddr_.GetAddress()).c_str());
567 }
568 }
569
Exit(void)570 void AvrcCtStateMachineManager::StateMachine::CtDisconnecting::Exit(void)
571 {
572 HILOGI("enter");
573 }
574
Dispatch(const utility::Message & msg)575 bool AvrcCtStateMachineManager::StateMachine::CtDisconnecting::Dispatch(const utility::Message &msg)
576 {
577 HILOGI("enter");
578
579 bool result = true;
580
581 switch (msg.what_) {
582 default:
583 result = false;
584 break;
585 }
586
587 return result;
588 }
589
590 /******************************************************************
591 * AvrcCtStateMachineManager::StateMachine::CtPending *
592 ******************************************************************/
593
CtPending(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)594 AvrcCtStateMachineManager::StateMachine::CtPending::CtPending(const std::string &name,
595 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
596 : State(name, stateMachine, rawAddr, parent)
597 {
598 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
599 }
600
Entry(void)601 void AvrcCtStateMachineManager::StateMachine::CtPending::Entry(void)
602 {
603 HILOGI("enter");
604 }
605
Exit(void)606 void AvrcCtStateMachineManager::StateMachine::CtPending::Exit(void)
607 {
608 HILOGI("enter");
609 }
610
Dispatch(const utility::Message & msg)611 bool AvrcCtStateMachineManager::StateMachine::CtPending::Dispatch(const utility::Message &msg)
612 {
613 HILOGI("enter");
614
615 bool result = true;
616
617 switch (msg.what_) {
618 case AVRC_CT_SM_EVENT_TO_CONNECTED_STATE:
619 Transition(AVRC_CT_SM_STATE_CONNECTED);
620 break;
621 default:
622 result = false;
623 break;
624 }
625
626 return result;
627 }
628
629 /******************************************************************
630 * AvrcCtStateMachineManager::StateMachine::CtContinuation *
631 ******************************************************************/
632
CtContinuation(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)633 AvrcCtStateMachineManager::StateMachine::CtContinuation::CtContinuation(const std::string &name,
634 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
635 : State(name, stateMachine, rawAddr, parent)
636 {
637 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
638 }
639
Entry(void)640 void AvrcCtStateMachineManager::StateMachine::CtContinuation::Entry(void)
641 {
642 HILOGI("enter");
643 }
644
Exit(void)645 void AvrcCtStateMachineManager::StateMachine::CtContinuation::Exit(void)
646 {
647 HILOGI("enter");
648 }
649
Dispatch(const utility::Message & msg)650 bool AvrcCtStateMachineManager::StateMachine::CtContinuation::Dispatch(const utility::Message &msg)
651 {
652 HILOGI("enter");
653
654 bool result = true;
655
656 switch (msg.what_) {
657 case AVRC_CT_SM_EVENT_TO_CONNECTED_STATE:
658 Transition(AVRC_CT_SM_STATE_CONNECTED);
659 break;
660
661 default:
662 result = false;
663 break;
664 }
665
666 return result;
667 }
668
669 /******************************************************************
670 * AvrcCtStateMachineManager::StateMachine::CtDisable *
671 ******************************************************************/
672
CtDisable(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)673 AvrcCtStateMachineManager::StateMachine::CtDisable::CtDisable(const std::string &name,
674 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
675 : State(name, stateMachine, rawAddr, parent)
676 {
677 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
678 }
679
Entry(void)680 void AvrcCtStateMachineManager::StateMachine::CtDisable::Entry(void)
681 {
682 HILOGI("enter");
683
684 AVCT_Deregister();
685
686 const AvrcCtConnectInfo *info = AvrcCtConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
687
688 if (AVCT_DisconnectReq(info->connectId_) != AVCT_SUCCESS) {
689 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
690 rawAddr_.ConvertToUint8(btAddr.addr);
691
692 HILOGI("Call AVCT_DisconnectReq Failed! Address: %{public}s", GetEncryptAddr(rawAddr_.GetAddress()).c_str());
693 info->eventCallback_(info->connectId_, AVCT_DISCONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
694 }
695 }
696
Exit(void)697 void AvrcCtStateMachineManager::StateMachine::CtDisable::Exit(void)
698 {
699 HILOGI("enter");
700 }
701
Dispatch(const utility::Message & msg)702 bool AvrcCtStateMachineManager::StateMachine::CtDisable::Dispatch(const utility::Message &msg)
703 {
704 HILOGI("enter");
705
706 bool result = true;
707
708 switch (msg.what_) {
709 default:
710 result = false;
711 break;
712 }
713
714 return result;
715 }
716
717 /******************************************************************
718 * AvrcCtStateMachineManager::StateMachine::BrConnecting *
719 ******************************************************************/
720
BrConnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr)721 AvrcCtStateMachineManager::StateMachine::BrConnecting::BrConnecting(
722 const std::string &name, utility::StateMachine &stateMachine, const RawAddress &rawAddr)
723 : State(name, stateMachine, rawAddr)
724 {
725 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
726 }
727
Entry(void)728 void AvrcCtStateMachineManager::StateMachine::BrConnecting::Entry(void)
729 {
730 HILOGI("enter");
731
732 const AvrcCtConnectInfo *info = AvrcCtConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
733
734 if (AVCT_BrConnectReq(info->connectId_, info->role_) != AVCT_SUCCESS) {
735 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
736 rawAddr_.ConvertToUint8(btAddr.addr);
737 info->eventCallback_(info->connectId_, AVCT_BR_CONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
738 HILOGI("Call AVCT_BrConnectReq Failed! Address: %{public}s", GetEncryptAddr(rawAddr_.GetAddress()).c_str());
739 }
740 }
741
Exit(void)742 void AvrcCtStateMachineManager::StateMachine::BrConnecting::Exit(void)
743 {
744 HILOGI("enter");
745 }
746
Dispatch(const utility::Message & msg)747 bool AvrcCtStateMachineManager::StateMachine::BrConnecting::Dispatch(const utility::Message &msg)
748 {
749 HILOGI("enter");
750
751 bool result = true;
752
753 switch (msg.what_) {
754 case AVRC_CT_SM_EVENT_TO_DISABLE_STATE:
755 Transition(AVRC_CT_SM_STATE_DISABLE);
756 break;
757 case AVRC_CT_SM_EVENT_TO_CONNECTED_STATE:
758 Transition(AVRC_CT_SM_STATE_CONNECTED);
759 break;
760 default:
761 result = false;
762 break;
763 }
764
765 return result;
766 }
767
768 /******************************************************************
769 * AvrcCtStateMachineManager::StateMachine::BrConnected *
770 ******************************************************************/
771
BrConnected(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)772 AvrcCtStateMachineManager::StateMachine::BrConnected::BrConnected(const std::string &name,
773 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
774 : State(name, stateMachine, rawAddr, parent)
775 {
776 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
777 }
778
Entry(void)779 void AvrcCtStateMachineManager::StateMachine::BrConnected::Entry(void)
780 {
781 HILOGI("enter");
782 }
783
Exit(void)784 void AvrcCtStateMachineManager::StateMachine::BrConnected::Exit(void)
785 {
786 HILOGI("enter");
787 }
788
Dispatch(const utility::Message & msg)789 bool AvrcCtStateMachineManager::StateMachine::BrConnected::Dispatch(const utility::Message &msg)
790 {
791 HILOGI("enter");
792
793 bool result = true;
794 AvrcCtConnectManager *cnManager = AvrcCtConnectManager::GetInstance();
795
796 switch (msg.what_) {
797 case AVRC_CT_SM_EVENT_TO_DISCONNECTING_STATE:
798 Transition(AVRC_CT_SM_STATE_DISCONNECTING);
799 break;
800 case AVRC_CT_SM_EVENT_SET_BROWSED_PLAYER:
801 case AVRC_CT_SM_EVENT_CHANGE_PATH:
802 case AVRC_CT_SM_EVENT_GET_FOLDER_ITEMS:
803 case AVRC_CT_SM_EVENT_GET_ITEM_ATTRIBUTES:
804 case AVRC_CT_SM_EVENT_GET_TOTAL_NUMBER_OF_ITEMS: {
805 std::shared_ptr<AvrcCtBrowsePacket> packet = cnManager->GetBrowsePacket(rawAddr_);
806
807 AVCT_BrSendMsgReq(
808 cnManager->GetConnectId(rawAddr_), AVRC_DEFAULT_LABEL, AVCT_COMMAND, packet->AssemblePacket());
809
810 Transition(AVRC_CT_SM_STATE_PENDING);
811 break;
812 }
813 default:
814 result = false;
815 break;
816 }
817
818 return result;
819 }
820
821 /******************************************************************
822 * AvrcCtStateMachineManager::StateMachine::BrDisconnecting *
823 ******************************************************************/
824
BrDisconnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)825 AvrcCtStateMachineManager::StateMachine::BrDisconnecting::BrDisconnecting(const std::string &name,
826 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
827 : State(name, stateMachine, rawAddr, parent)
828 {
829 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
830 }
831
Entry(void)832 void AvrcCtStateMachineManager::StateMachine::BrDisconnecting::Entry(void)
833 {
834 HILOGI("enter");
835
836 const AvrcCtConnectInfo *info = AvrcCtConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
837
838 if (AVCT_BrDisconnectReq(info->connectId_) != AVCT_SUCCESS) {
839 BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
840 rawAddr_.ConvertToUint8(btAddr.addr);
841 info->eventCallback_(info->connectId_, AVCT_BR_DISCONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
842 HILOGI("Call AVCT_BrDisconnectReq Failed! Address: %{public}s", GetEncryptAddr(rawAddr_.GetAddress()).c_str());
843 }
844 }
845
Exit(void)846 void AvrcCtStateMachineManager::StateMachine::BrDisconnecting::Exit(void)
847 {
848 HILOGI("enter");
849 }
850
Dispatch(const utility::Message & msg)851 bool AvrcCtStateMachineManager::StateMachine::BrDisconnecting::Dispatch(const utility::Message &msg)
852 {
853 HILOGI("enter");
854
855 bool result = true;
856
857 switch (msg.what_) {
858 default:
859 result = false;
860 break;
861 }
862
863 return result;
864 }
865
866 /******************************************************************
867 * AvrcCtStateMachineManager::StateMachine::BrPending *
868 ******************************************************************/
869
BrPending(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)870 AvrcCtStateMachineManager::StateMachine::BrPending::BrPending(const std::string &name,
871 utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
872 : State(name, stateMachine, rawAddr, parent)
873 {
874 HILOGI("name: %{public}s, addr: %{public}s", name.c_str(), GET_ENCRYPT_AVRCP_ADDR(rawAddr));
875 }
876
Entry(void)877 void AvrcCtStateMachineManager::StateMachine::BrPending::Entry(void)
878 {
879 HILOGI("enter");
880 }
881
Exit(void)882 void AvrcCtStateMachineManager::StateMachine::BrPending::Exit(void)
883 {
884 HILOGI("enter");
885 }
886
Dispatch(const utility::Message & msg)887 bool AvrcCtStateMachineManager::StateMachine::BrPending::Dispatch(const utility::Message &msg)
888 {
889 HILOGI("enter");
890
891 bool result = true;
892
893 switch (msg.what_) {
894 case AVRC_CT_SM_EVENT_TO_CONNECTED_STATE:
895 Transition(AVRC_CT_SM_STATE_CONNECTED);
896 break;
897 default:
898 result = false;
899 break;
900 }
901
902 return result;
903 }
904 } // namespace bluetooth
905 } // namespace OHOS
906