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_tg_state_machine.h"
17 #include "avrcp_tg_pass_through.h"
18 #include "avrcp_tg_sub_unit_info.h"
19 #include "avrcp_tg_unit_info.h"
20 #include "avrcp_tg_vendor.h"
21 #include "avrcp_tg_vendor_continuation.h"
22 #include "avrcp_tg_vendor_player_application_settings.h"
23 #include "log_util.h"
24 
25 namespace OHOS {
26 namespace bluetooth {
27 /// The name of state "CONNECTING".
28 const std::string AVRC_TG_SM_STATE_CONNECTING = "CONNECTING";
29 /// The name of state "CONNECTED".
30 const std::string AVRC_TG_SM_STATE_CONNECTED = "CONNECTED";
31 /// The name of state "DISCONNECTING".
32 const std::string AVRC_TG_SM_STATE_DISCONNECTING = "DISCONNECTING";
33 /// The name of state "PENDING".
34 const std::string AVRC_TG_SM_STATE_PENDING = "PENDING";
35 /// The name of state "BUSY".
36 const std::string AVRC_TG_SM_STATE_BUSY = "BUSY";
37 /// The name of state "CONTINUATION".
38 const std::string AVRC_TG_SM_STATE_CONTINUATION = "CONTINUATION";
39 /// The name of state "DISABLE".
40 const std::string AVRC_TG_SM_STATE_DISABLE = "DISABLE";
41 
GetInstance(void)42 AvrcTgStateMachineManager *AvrcTgStateMachineManager::GetInstance(void)
43 {
44     HILOGI("enter");
45 
46     static AvrcTgStateMachineManager instance;
47 
48     return &instance;
49 }
50 
~AvrcTgStateMachineManager()51 AvrcTgStateMachineManager::~AvrcTgStateMachineManager()
52 {
53     HILOGI("enter");
54 
55     stateMachines_.clear();
56 }
57 
ShutDown(void)58 void AvrcTgStateMachineManager::ShutDown(void)
59 {
60     HILOGI("enter");
61     std::lock_guard<std::mutex> lock(mutex_);
62     stateMachines_.clear();
63 }
64 
AddControlStateMachine(const RawAddress & rawAddr)65 int AvrcTgStateMachineManager::AddControlStateMachine(const RawAddress &rawAddr)
66 {
67     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
68 
69     std::lock_guard<std::mutex> lock(mutex_);
70 
71     int result = BT_SUCCESS;
72 
73     if (GetPairOfStateMachine(rawAddr.GetAddress()) == nullptr) {
74         std::unique_ptr<StateMachine> statemachine =
75             std::make_unique<StateMachine>(StateMachine::Type::AVRC_TG_SM_TYPE_CONTROL, rawAddr);
76         statemachine->AddStates();
77         statemachine->InitState(AVRC_TG_SM_STATE_CONNECTING);
78         stateMachines_.insert(std::make_pair(rawAddr.GetAddress(), std::make_pair(std::move(statemachine), nullptr)));
79     } else {
80         result = RET_BAD_PARAM;
81         HILOGI("exists! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
82     }
83 
84     return result;
85 }
86 
AddBrowseStateMachine(const RawAddress & rawAddr)87 int AvrcTgStateMachineManager::AddBrowseStateMachine(const RawAddress &rawAddr)
88 {
89     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
90 
91     std::lock_guard<std::mutex> lock(mutex_);
92 
93     int result = BT_SUCCESS;
94 
95     StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
96     if (pair == nullptr) {
97         result = RET_BAD_PARAM;
98         HILOGI("doest not exists! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
99     } else if (pair->second == nullptr) {
100         pair->second = std::make_unique<StateMachine>(StateMachine::Type::AVRC_TG_SM_TYPE_BROWSE, rawAddr);
101         pair->second->AddStates();
102         pair->second->InitState(AVRC_TG_SM_STATE_CONNECTING);
103     } else {
104         result = RET_BAD_PARAM;
105         HILOGI("exists! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
106     }
107 
108     return result;
109 }
110 
DeletePairOfStateMachine(const RawAddress & rawAddr)111 void AvrcTgStateMachineManager::DeletePairOfStateMachine(const RawAddress &rawAddr)
112 {
113     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
114 
115     std::lock_guard<std::mutex> lock(mutex_);
116 
117     StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
118     if (pair != nullptr) {
119         stateMachines_.erase(rawAddr.GetAddress());
120     } else {
121         HILOGI("does not exist! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
122     }
123 }
124 
DeleteBrowseStateMachine(const RawAddress & rawAddr)125 void AvrcTgStateMachineManager::DeleteBrowseStateMachine(const RawAddress &rawAddr)
126 {
127     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
128 
129     std::lock_guard<std::mutex> lock(mutex_);
130 
131     StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
132     if (pair != nullptr && pair->second != nullptr) {
133         pair->second = nullptr;
134     } else {
135         HILOGI("does not exist! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
136     }
137 }
138 
SendMessageToControlStateMachine(const RawAddress & rawAddr,const utility::Message & msg)139 bool AvrcTgStateMachineManager::SendMessageToControlStateMachine(const RawAddress &rawAddr, const utility::Message &msg)
140 {
141     HILOGI("addr:%{public}s, msg: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), msg.what_);
142     std::lock_guard<std::mutex> lock(mutex_);
143     bool result = false;
144 
145     StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
146     if (pair != nullptr && pair->first != nullptr) {
147         result = pair->first->ProcessMessage(msg);
148         if (!result) {
149             HILOGI("Unknown message: %{public}d, Address: %{public}s",
150                 msg.what_, GetEncryptAddr(rawAddr.GetAddress()).c_str());
151         }
152     } else {
153         HILOGI("does not exist! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
154     }
155 
156     return result;
157 }
158 
SendMessageToAllControlStateMachine(const utility::Message & msg)159 void AvrcTgStateMachineManager::SendMessageToAllControlStateMachine(const utility::Message &msg)
160 {
161     HILOGI("enter, msg: %{public}x", msg.what_);
162     std::lock_guard<std::mutex> lock(mutex_);
163 
164     for (auto &pairSm : stateMachines_) {
165         if (pairSm.second.first != nullptr) {
166             pairSm.second.first->ProcessMessage(msg);
167         }
168     }
169 }
170 
SendMessageToBrowseStateMachine(const RawAddress & rawAddr,const utility::Message & msg)171 bool AvrcTgStateMachineManager::SendMessageToBrowseStateMachine(const RawAddress &rawAddr, const utility::Message &msg)
172 {
173     HILOGI("addr:%{public}s, msg: %{public}x", GET_ENCRYPT_AVRCP_ADDR(rawAddr), msg.what_);
174     std::lock_guard<std::mutex> lock(mutex_);
175     bool result = false;
176 
177     StateMachinePair *pair = GetPairOfStateMachine(rawAddr.GetAddress());
178     if (pair != nullptr && pair->second != nullptr) {
179         result = pair->second->ProcessMessage(msg);
180         if (!result) {
181             HILOGI("Unknown message: %{public}d, Address:%{public}s",
182                 msg.what_, GetEncryptAddr(rawAddr.GetAddress()).c_str());
183         }
184     } else {
185         HILOGI("does not exist! Address: %{public}s", GetEncryptAddr(rawAddr.GetAddress()).c_str());
186     }
187 
188     return result;
189 }
190 
SendMessageToAllBrowseStateMachine(const utility::Message & msg)191 void AvrcTgStateMachineManager::SendMessageToAllBrowseStateMachine(const utility::Message &msg)
192 {
193     HILOGI("enter, msg: %{public}x", msg.what_);
194     std::lock_guard<std::mutex> lock(mutex_);
195     for (auto &pairSm : stateMachines_) {
196         if (pairSm.second.second != nullptr) {
197             pairSm.second.second->ProcessMessage(msg);
198         }
199     }
200 }
201 
IsControlConnectingState(const RawAddress & rawAddr)202 bool AvrcTgStateMachineManager::IsControlConnectingState(const RawAddress &rawAddr)
203 {
204     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
205 
206     return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_TG_SM_STATE_CONNECTING);
207 }
208 
IsControlConnectedState(const RawAddress & rawAddr)209 bool AvrcTgStateMachineManager::IsControlConnectedState(const RawAddress &rawAddr)
210 {
211     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
212 
213     return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_TG_SM_STATE_CONNECTED);
214 }
215 
IsControlDisconnectingState(const RawAddress & rawAddr)216 bool AvrcTgStateMachineManager::IsControlDisconnectingState(const RawAddress &rawAddr)
217 {
218     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
219 
220     return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_TG_SM_STATE_DISCONNECTING);
221 }
222 
IsControlContinuationState(const RawAddress & rawAddr)223 bool AvrcTgStateMachineManager::IsControlContinuationState(const RawAddress &rawAddr)
224 {
225     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
226 
227     return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_TG_SM_STATE_CONTINUATION);
228 }
229 
IsControlDisableState(const RawAddress & rawAddr)230 bool AvrcTgStateMachineManager::IsControlDisableState(const RawAddress &rawAddr)
231 {
232     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
233 
234     return IsControlSpecifiedState(rawAddr.GetAddress(), AVRC_TG_SM_STATE_DISABLE);
235 }
236 
AvrcTgStateMachineManager()237 AvrcTgStateMachineManager::AvrcTgStateMachineManager()
238 {
239     HILOGI("enter");
240 }
241 
GetPairOfStateMachine(const std::string & addr)242 AvrcTgStateMachineManager::StateMachinePair *AvrcTgStateMachineManager::GetPairOfStateMachine(const std::string &addr)
243 {
244     HILOGI("addr:%{public}s", GetEncryptAddr(addr).c_str());
245 
246     StateMachinePair *pair = nullptr;
247 
248     auto iter = stateMachines_.find(addr);
249     if (iter != stateMachines_.end()) {
250         pair = &iter->second;
251     }
252 
253     return pair;
254 }
255 
IsControlSpecifiedState(const std::string & addr,std::string stateName)256 bool AvrcTgStateMachineManager::IsControlSpecifiedState(const std::string &addr, std::string stateName)
257 {
258     HILOGI("addr:%{public}s, stateName:%{public}s", GetEncryptAddr(addr).c_str(), stateName.c_str());
259 
260     std::lock_guard<std::mutex> lock(mutex_);
261 
262     int result = false;
263 
264     StateMachinePair *pair = GetPairOfStateMachine(addr);
265     if (pair != nullptr && pair->first != nullptr) {
266         if (pair->first->GetState()->Name().compare(stateName) == 0) {
267             result = true;
268         }
269     } else {
270         HILOGI("The pair of state machines does not exist!");
271     }
272 
273     return result;
274 }
275 
StateMachine(Type type,const RawAddress & rawAddr)276 AvrcTgStateMachineManager::StateMachine::StateMachine(Type type, const RawAddress &rawAddr)
277     : type_(type), rawAddr_(rawAddr)
278 {
279     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
280 }
281 
AddStates(void)282 void AvrcTgStateMachineManager::StateMachine::AddStates(void)
283 {
284     HILOGI("enter");
285 
286     if (type_ == Type::AVRC_TG_SM_TYPE_CONTROL) {
287         /// CONNECTING state.
288         std::unique_ptr<utility::StateMachine::State> ctConnectingPtr =
289             std::make_unique<CtConnecting>(AVRC_TG_SM_STATE_CONNECTING, *this, rawAddr_);
290         /// CONNECTED state.
291         std::unique_ptr<utility::StateMachine::State> ctConnectedPtr =
292             std::make_unique<CtConnected>(AVRC_TG_SM_STATE_CONNECTED, *this, rawAddr_, *ctConnectingPtr.get());
293         /// DISCONNECTING state.
294         std::unique_ptr<utility::StateMachine::State> ctDisconnectingPtr =
295             std::make_unique<CtDisconnecting>(AVRC_TG_SM_STATE_DISCONNECTING, *this, rawAddr_, *ctConnectedPtr.get());
296         /// CONTINUATION state.
297         std::unique_ptr<utility::StateMachine::State> ctContinuationPtr =
298             std::make_unique<CtContinuation>(AVRC_TG_SM_STATE_CONTINUATION, *this, rawAddr_, *ctConnectedPtr.get());
299         /// DISABLE state.
300         std::unique_ptr<utility::StateMachine::State> ctDisablePtr =
301             std::make_unique<CtDisable>(AVRC_TG_SM_STATE_DISABLE, *this, rawAddr_, *ctConnectedPtr.get());
302         Move(ctDisconnectingPtr);
303         Move(ctContinuationPtr);
304         Move(ctDisablePtr);
305         Move(ctConnectedPtr);
306         Move(ctConnectingPtr);
307     } else if (type_ == Type::AVRC_TG_SM_TYPE_BROWSE) {
308         /// CONNECTING state.
309         std::unique_ptr<utility::StateMachine::State> brConnectingPtr =
310             std::make_unique<BrConnecting>(AVRC_TG_SM_STATE_CONNECTING, *this, rawAddr_);
311         /// CONNECTED state.
312         std::unique_ptr<utility::StateMachine::State> brConnectedPtr =
313             std::make_unique<BrConnected>(AVRC_TG_SM_STATE_CONNECTED, *this, rawAddr_, *brConnectingPtr.get());
314         /// DISCONNECTING state.
315         std::unique_ptr<utility::StateMachine::State> brDisconnectingPtr =
316             std::make_unique<BrDisconnecting>(AVRC_TG_SM_STATE_DISCONNECTING, *this, rawAddr_, *brConnectedPtr.get());
317         Move(brDisconnectingPtr);
318         Move(brConnectedPtr);
319         Move(brConnectingPtr);
320     } else {
321         HILOGI("The type of the state machine is wrong!");
322     }
323 }
324 
325 /******************************************************************
326  * AvrcTgStateMachineManager::StateMachine::State                 *
327  ******************************************************************/
328 
State(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)329 AvrcTgStateMachineManager::StateMachine::State::State(const std::string &name, utility::StateMachine &stateMachine,
330     const RawAddress &rawAddr, utility::StateMachine::State &parent)
331     : utility::StateMachine::State(name, stateMachine, parent), rawAddr_(rawAddr)
332 {
333     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
334 }
335 
State(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr)336 AvrcTgStateMachineManager::StateMachine::State::State(
337     const std::string &name, utility::StateMachine &stateMachine, const RawAddress &rawAddr)
338     : utility::StateMachine::State(name, stateMachine), rawAddr_(rawAddr)
339 {
340     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
341 }
342 
~State()343 AvrcTgStateMachineManager::StateMachine::State::~State()
344 {
345     HILOGI("enter");
346 }
347 
348 /******************************************************************
349  * AvrcTgStateMachineManager::StateMachine::CtConnecting          *
350  ******************************************************************/
351 
CtConnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr)352 AvrcTgStateMachineManager::StateMachine::CtConnecting::CtConnecting(
353     const std::string &name, utility::StateMachine &stateMachine, const RawAddress &rawAddr)
354     : State(name, stateMachine, rawAddr)
355 {
356     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
357 }
358 
Entry(void)359 void AvrcTgStateMachineManager::StateMachine::CtConnecting::Entry(void)
360 {
361     HILOGI("enter");
362 
363     const AvrcTgConnectInfo *info = AvrcTgConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
364 
365     AVCT_Register(info->controlMtu_, info->browseMtu_, AVCT_CT);
366 
367     uint8_t connectId = 0x00;
368     AvctConnectParam param = {info->eventCallback_, info->msgCallback_, AVRC_TG_AV_REMOTE_CONTROL,
369         info->role_, nullptr};
370     BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
371     rawAddr_.ConvertToUint8(btAddr.addr);
372 
373     if (AVCT_ConnectReq(&connectId, &param, &btAddr) != AVCT_SUCCESS) {
374         info->eventCallback_(connectId, AVCT_CONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
375         HILOGI("Call AVCT_ConnectReq Failed! Address: %{public}s",
376             GetEncryptAddr(rawAddr_.GetAddress()).c_str());
377     }
378 }
379 
Exit(void)380 void AvrcTgStateMachineManager::StateMachine::CtConnecting::Exit(void)
381 {
382     HILOGI("enter");
383 }
384 
Dispatch(const utility::Message & msg)385 bool AvrcTgStateMachineManager::StateMachine::CtConnecting::Dispatch(const utility::Message &msg)
386 {
387     HILOGI("enter, msg: %{public}x", msg.what_);
388 
389     bool result = true;
390 
391     switch (msg.what_) {
392         case AVRC_TG_SM_EVENT_TO_DISABLE_STATE:
393             Transition(AVRC_TG_SM_STATE_DISABLE);
394             break;
395         case AVRC_TG_SM_EVENT_TO_CONNECTED_STATE:
396             Transition(AVRC_TG_SM_STATE_CONNECTED);
397             break;
398         default:
399             result = false;
400             break;
401     }
402 
403     return result;
404 }
405 
406 /******************************************************************
407  * AvrcTgStateMachineManager::StateMachine::CtConnected           *
408  ******************************************************************/
CtConnected(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)409 AvrcTgStateMachineManager::StateMachine::CtConnected::CtConnected(const std::string &name,
410     utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
411     : State(name, stateMachine, rawAddr, parent)
412 {
413     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
414 }
415 
Entry(void)416 void AvrcTgStateMachineManager::StateMachine::CtConnected::Entry(void)
417 {
418     HILOGI("enter");
419 }
420 
Exit(void)421 void AvrcTgStateMachineManager::StateMachine::CtConnected::Exit(void)
422 {
423     HILOGI("enter");
424 }
425 
Dispatch(const utility::Message & msg)426 bool AvrcTgStateMachineManager::StateMachine::CtConnected::Dispatch(const utility::Message &msg)
427 {
428     HILOGI("msg: %{public}x", msg.what_);
429 
430     bool result = true;
431     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
432     if (cnManager->GetActiveDevice().compare(rawAddr_.GetAddress()) == 0x00) {
433         switch (msg.what_) {
434             case AVRC_TG_SM_EVENT_TO_DISCONNECTING_STATE:
435                 Transition(AVRC_TG_SM_STATE_DISCONNECTING);
436                 break;
437             case AVRC_TG_SM_EVENT_PASS_THROUGH: {
438                 ToPassThroughEvent();
439                 break;
440             }
441             case AVRC_TG_SM_EVENT_UNIT_INFO:
442             case AVRC_TG_SM_EVENT_SUB_UNIT_INFO: {
443                 ToUnitInfoEvent();
444                 break;
445             }
446             case AVRC_TG_PDU_ID_GENERAL_REJECT:
447             case AVRC_TG_SM_EVENT_REGISTER_NOTIFICATION:
448             case AVRC_TG_SM_EVENT_GET_CAPABILITIES:
449             case AVRC_TG_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES:
450             case AVRC_TG_SM_EVENT_LIST_PLAYER_APPLICATION_SETTING_VALUES:
451             case AVRC_TG_SM_EVENT_GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE:
452             case AVRC_TG_SM_EVENT_SET_PLAYER_APPLICATION_SETTING_VALUE:
453             case AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT:
454             case AVRC_TG_SM_EVENT_GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT:
455             case AVRC_TG_SM_EVENT_GET_ELEMENT_ATTRIBTUES:
456             case AVRC_TG_SM_EVENT_GET_PLAY_STATUS:
457             case AVRC_TG_SM_EVENT_SET_ADDRESSED_PLAYER:
458             case AVRC_TG_SM_EVENT_PLAY_ITEM:
459             case AVRC_TG_SM_EVENT_ADD_TO_NOW_PLAYING:
460             case AVRC_TG_SM_EVENT_SET_ABSOLUTE_VOLUME: {
461                 ToCommonEvent();
462                 break;
463             }
464             case AVRC_TG_SM_EVENT_ABORT_CONTINUING_RESPONSE: {
465                 ToAbortContinuingEvent();
466                 break;
467             }
468             default:
469                 result = false;
470                 break;
471         }
472     }
473 
474     return result;
475 }
476 
ToPassThroughEvent()477 void AvrcTgStateMachineManager::StateMachine::CtConnected::ToPassThroughEvent()
478 {
479     HILOGI("enter");
480 
481     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
482 
483     if (cnManager->GetActiveDevice().compare(rawAddr_.GetAddress()) == 0x00) {
484         std::shared_ptr<AvrcTgPassPacket> packet = cnManager->GetPassPacket(rawAddr_);
485         AVCT_SendMsgReq(cnManager->GetConnectId(rawAddr_), packet->GetLabel(), AVCT_RESPONSE, packet->AssemblePacket());
486     }
487 }
ToUnitInfoEvent()488 void AvrcTgStateMachineManager::StateMachine::CtConnected::ToUnitInfoEvent()
489 {
490     HILOGI("enter");
491 
492     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
493 
494     std::shared_ptr<AvrcTgUnitPacket> packet = cnManager->GetUnitPacket(rawAddr_);
495     AVCT_SendMsgReq(cnManager->GetConnectId(rawAddr_), packet->GetLabel(), AVCT_RESPONSE, packet->AssemblePacket());
496     Transition(AVRC_TG_SM_STATE_CONNECTED);
497 }
ToCommonEvent()498 void AvrcTgStateMachineManager::StateMachine::CtConnected::ToCommonEvent()
499 {
500     HILOGI("enter");
501 
502     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
503 
504     std::shared_ptr<AvrcTgVendorPacket> packet = cnManager->GetVendorPacket(rawAddr_);
505     Packet *pkt = packet->PopAssembledPacket();
506 
507     AVCT_SendMsgReq(cnManager->GetConnectId(rawAddr_), packet->GetLabel(), AVCT_RESPONSE, pkt);
508     PacketFree(pkt);
509 
510     if (packet->IsPacketExist()) {
511         Transition(AVRC_TG_SM_STATE_CONTINUATION);
512     } else {
513         Transition(AVRC_TG_SM_STATE_CONNECTED);
514     }
515 }
ToAbortContinuingEvent()516 void AvrcTgStateMachineManager::StateMachine::CtConnected::ToAbortContinuingEvent()
517 {
518     HILOGI("enter");
519 
520     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
521 
522     AvrcTgAcrPacket *packet = static_cast<AvrcTgAcrPacket *>(cnManager->GetVendorPacket(rawAddr_).get());
523     Packet *pkt = packet->PopAssembledPacket();
524 
525     AVCT_SendMsgReq(cnManager->GetConnectId(rawAddr_), packet->GetLabel(), AVCT_RESPONSE, pkt);
526     PacketFree(pkt);
527 
528     Transition(AVRC_TG_SM_STATE_CONNECTED);
529 }
530 
531 /******************************************************************
532  * AvrcTgStateMachineManager::StateMachine::CtDisconnecting       *
533  ******************************************************************/
534 
CtDisconnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)535 AvrcTgStateMachineManager::StateMachine::CtDisconnecting::CtDisconnecting(const std::string &name,
536     utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
537     : State(name, stateMachine, rawAddr, parent)
538 {
539     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
540 }
541 
Entry(void)542 void AvrcTgStateMachineManager::StateMachine::CtDisconnecting::Entry(void)
543 {
544     HILOGI("enter");
545 
546     const AvrcTgConnectInfo *info = AvrcTgConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
547 
548     if (AVCT_DisconnectReq(info->connectId_) != AVCT_SUCCESS) {
549         BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
550         rawAddr_.ConvertToUint8(btAddr.addr);
551         info->eventCallback_(info->connectId_, AVCT_DISCONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
552         HILOGI("Call AVCT_DisconnectReq Failed! Address: %{public}s",
553             GetEncryptAddr(rawAddr_.GetAddress()).c_str());
554     }
555 }
556 
Exit(void)557 void AvrcTgStateMachineManager::StateMachine::CtDisconnecting::Exit(void)
558 {
559     HILOGI("enter");
560 }
561 
Dispatch(const utility::Message & msg)562 bool AvrcTgStateMachineManager::StateMachine::CtDisconnecting::Dispatch(const utility::Message &msg)
563 {
564     HILOGI("msg: %{public}x", msg.what_);
565 
566     bool result = true;
567 
568     switch (msg.what_) {
569         default:
570             result = false;
571             break;
572     }
573 
574     return result;
575 }
576 
577 /******************************************************************
578  * AvrcTgStateMachineManager::StateMachine::CtContinuation        *
579  ******************************************************************/
580 
CtContinuation(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)581 AvrcTgStateMachineManager::StateMachine::CtContinuation::CtContinuation(const std::string &name,
582     utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
583     : State(name, stateMachine, rawAddr, parent)
584 {
585     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
586 }
587 
Entry(void)588 void AvrcTgStateMachineManager::StateMachine::CtContinuation::Entry(void)
589 {
590     HILOGI("enter");
591 }
592 
Exit(void)593 void AvrcTgStateMachineManager::StateMachine::CtContinuation::Exit(void)
594 {
595     HILOGI("enter");
596 }
597 
Dispatch(const utility::Message & msg)598 bool AvrcTgStateMachineManager::StateMachine::CtContinuation::Dispatch(const utility::Message &msg)
599 {
600     HILOGI("msg: %{public}x", msg.what_);
601 
602     bool result = true;
603     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
604 
605     if (cnManager->GetActiveDevice().compare(rawAddr_.GetAddress()) == 0x00) {
606         switch (msg.what_) {
607             case AVRC_TG_SM_EVENT_TO_CONNECTED_STATE:
608                 Transition(AVRC_TG_SM_STATE_CONNECTED);
609                 break;
610             case AVRC_TG_SM_EVENT_REQUEST_CONTINUING_RESPONSE: {
611                 std::shared_ptr<AvrcTgVendorPacket> packet = cnManager->GetVendorPacket(rawAddr_);
612                 Packet *pkt = packet->PopAssembledPacket();
613 
614                 AVCT_SendMsgReq(cnManager->GetConnectId(rawAddr_), packet->GetLabel(), AVCT_RESPONSE, pkt);
615                 PacketFree(pkt);
616 
617                 if (!packet->IsPacketExist()) {
618                     Transition(AVRC_TG_SM_STATE_CONNECTED);
619                 }
620                 break;
621             }
622             case AVRC_TG_SM_EVENT_ABORT_CONTINUING_RESPONSE:
623             /// FALL THROUGH
624             default:
625                 result = false;
626                 break;
627         }
628     } else {
629         /// Drops the message which is sent to the inactive device !
630     }
631 
632     return result;
633 }
634 
635 /******************************************************************
636  * AvrcTgStateMachineManager::StateMachine::CtDisable             *
637  ******************************************************************/
638 
CtDisable(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)639 AvrcTgStateMachineManager::StateMachine::CtDisable::CtDisable(const std::string &name,
640     utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
641     : State(name, stateMachine, rawAddr, parent)
642 {
643     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
644 }
645 
Entry(void)646 void AvrcTgStateMachineManager::StateMachine::CtDisable::Entry(void)
647 {
648     HILOGI("enter");
649 
650     AVCT_Deregister();
651 
652     const AvrcTgConnectInfo *info = AvrcTgConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
653     if (info != nullptr) {
654         if (AVCT_DisconnectReq(info->connectId_) != AVCT_SUCCESS) {
655             BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
656             rawAddr_.ConvertToUint8(btAddr.addr);
657             info->eventCallback_(info->connectId_, AVCT_DISCONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
658             HILOGI("Call AVCT_DisconnectReq Failed! Address: %{public}s",
659                 GetEncryptAddr(rawAddr_.GetAddress()).c_str());
660         }
661     }
662 }
663 
Exit(void)664 void AvrcTgStateMachineManager::StateMachine::CtDisable::Exit(void)
665 {
666     HILOGI("enter");
667 }
668 
Dispatch(const utility::Message & msg)669 bool AvrcTgStateMachineManager::StateMachine::CtDisable::Dispatch(const utility::Message &msg)
670 {
671     HILOGI("msg: %{public}x", msg.what_);
672 
673     bool result = true;
674 
675     switch (msg.what_) {
676         default:
677             result = false;
678             break;
679     }
680 
681     return result;
682 }
683 
684 /******************************************************************
685  * AvrcTgStateMachineManager::StateMachine::BrConnecting          *
686  ******************************************************************/
687 
BrConnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr)688 AvrcTgStateMachineManager::StateMachine::BrConnecting::BrConnecting(
689     const std::string &name, utility::StateMachine &stateMachine, const RawAddress &rawAddr)
690     : State(name, stateMachine, rawAddr)
691 {
692     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
693 }
694 
Entry(void)695 void AvrcTgStateMachineManager::StateMachine::BrConnecting::Entry(void)
696 {
697     HILOGI("enter");
698 
699     const AvrcTgConnectInfo *info = AvrcTgConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
700 
701     if (AVCT_BrConnectReq(info->connectId_, info->role_) != AVCT_SUCCESS) {
702         BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
703         rawAddr_.ConvertToUint8(btAddr.addr);
704         info->eventCallback_(info->connectId_, AVCT_BR_CONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
705         HILOGI("Call AVCT_BrConnectReq Failed! Address: %{public}s",
706             GetEncryptAddr(rawAddr_.GetAddress()).c_str());
707     }
708 }
709 
Exit(void)710 void AvrcTgStateMachineManager::StateMachine::BrConnecting::Exit(void)
711 {
712     HILOGI("enter");
713 }
714 
Dispatch(const utility::Message & msg)715 bool AvrcTgStateMachineManager::StateMachine::BrConnecting::Dispatch(const utility::Message &msg)
716 {
717     HILOGI("msg: %{public}x", msg.what_);
718 
719     bool result = true;
720 
721     switch (msg.what_) {
722         case AVRC_TG_SM_EVENT_TO_DISABLE_STATE:
723             Transition(AVRC_TG_SM_STATE_DISABLE);
724             break;
725         case AVRC_TG_SM_EVENT_TO_CONNECTED_STATE:
726             Transition(AVRC_TG_SM_STATE_CONNECTED);
727             break;
728         default:
729             result = false;
730             break;
731     }
732 
733     return result;
734 }
735 
736 /******************************************************************
737  * AvrcTgStateMachineManager::StateMachine::BrConnected           *
738  ******************************************************************/
739 
BrConnected(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)740 AvrcTgStateMachineManager::StateMachine::BrConnected::BrConnected(const std::string &name,
741     utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
742     : State(name, stateMachine, rawAddr, parent)
743 {
744     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
745 }
746 
Entry(void)747 void AvrcTgStateMachineManager::StateMachine::BrConnected::Entry(void)
748 {
749     HILOGI("enter");
750 }
751 
Exit(void)752 void AvrcTgStateMachineManager::StateMachine::BrConnected::Exit(void)
753 {
754     HILOGI("enter");
755 }
756 
Dispatch(const utility::Message & msg)757 bool AvrcTgStateMachineManager::StateMachine::BrConnected::Dispatch(const utility::Message &msg)
758 {
759     HILOGI("msg: %{public}x", msg.what_);
760 
761     bool result = true;
762     AvrcTgConnectManager *cnManager = AvrcTgConnectManager::GetInstance();
763 
764     if (cnManager->GetActiveDevice().compare(rawAddr_.GetAddress()) == 0x00) {
765         switch (msg.what_) {
766             case AVRC_TG_SM_EVENT_TO_DISCONNECTING_STATE:
767                 Transition(AVRC_TG_SM_STATE_DISCONNECTING);
768                 break;
769             case AVRC_TG_SM_EVENT_GENERAL_REJECT:
770             case AVRC_TG_SM_EVENT_SET_BROWSED_PLAYER:
771             case AVRC_TG_SM_EVENT_CHANGE_PATH:
772             case AVRC_TG_SM_EVENT_GET_FOLDER_ITEMS:
773             case AVRC_TG_SM_EVENT_GET_ITEM_ATTRIBUTES:
774             case AVRC_TG_SM_EVENT_GET_TOTAL_NUMBER_OF_ITEMS: {
775                 std::shared_ptr<AvrcTgBrowsePacket> packet = cnManager->GetBrowsePacket(rawAddr_);
776 
777                 AVCT_BrSendMsgReq(
778                     cnManager->GetConnectId(rawAddr_), packet->GetLabel(), AVCT_RESPONSE, packet->AssemblePacket());
779 
780                 Transition(AVRC_TG_SM_STATE_CONNECTED);
781                 break;
782             }
783             default:
784                 result = false;
785                 break;
786         }
787     } else {
788         /// Drops the message which is sent to the inactive device !
789     }
790 
791     return result;
792 }
793 
794 /******************************************************************
795  * AvrcTgStateMachineManager::StateMachine::BrDisconnecting       *
796  ******************************************************************/
797 
BrDisconnecting(const std::string & name,utility::StateMachine & stateMachine,const RawAddress & rawAddr,utility::StateMachine::State & parent)798 AvrcTgStateMachineManager::StateMachine::BrDisconnecting::BrDisconnecting(const std::string &name,
799     utility::StateMachine &stateMachine, const RawAddress &rawAddr, utility::StateMachine::State &parent)
800     : State(name, stateMachine, rawAddr, parent)
801 {
802     HILOGI("addr:%{public}s", GET_ENCRYPT_AVRCP_ADDR(rawAddr));
803 }
804 
Entry(void)805 void AvrcTgStateMachineManager::StateMachine::BrDisconnecting::Entry(void)
806 {
807     HILOGI("enter");
808 
809     const AvrcTgConnectInfo *info = AvrcTgConnectManager::GetInstance()->GetConnectInfo(rawAddr_);
810 
811     if (AVCT_BrDisconnectReq(info->connectId_) != AVCT_SUCCESS) {
812         BtAddr btAddr = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0x00};
813         rawAddr_.ConvertToUint8(btAddr.addr);
814         info->eventCallback_(info->connectId_, AVCT_BR_DISCONNECT_CFM_EVT, AVCT_FAILED, &btAddr, nullptr);
815         HILOGI("Call AVCT_BrDisconnectReq Failed! Address: %{public}s",
816             GetEncryptAddr(rawAddr_.GetAddress()).c_str());
817     }
818 }
819 
Exit(void)820 void AvrcTgStateMachineManager::StateMachine::BrDisconnecting::Exit(void)
821 {
822     HILOGI("enter");
823 }
824 
Dispatch(const utility::Message & msg)825 bool AvrcTgStateMachineManager::StateMachine::BrDisconnecting::Dispatch(const utility::Message &msg)
826 {
827     HILOGI("msg: %{public}x", msg.what_);
828 
829     bool result = true;
830     switch (msg.what_) {
831         default:
832             result = false;
833             break;
834     }
835 
836     return result;
837 }
838 }  // namespace bluetooth
839 }  // namespace OHOS
840