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 "hfp_ag_statemachine.h"
17 
18 #include "adapter_config.h"
19 #include "hfp_ag_data_connection_server.h"
20 #include "hfp_ag_defines.h"
21 #include "hfp_ag_message.h"
22 #include "hfp_ag_service.h"
23 #include "hfp_ag_system_interface.h"
24 #include "power_manager.h"
25 #include "log_util.h"
26 
27 namespace OHOS {
28 namespace bluetooth {
HfpAgStateMachine(const std::string & address)29 HfpAgStateMachine::HfpAgStateMachine(const std::string &address)
30     : address_(address), profile_(address), eventProcessor_(profile_, address)
31 {
32 }
33 
Init()34 void HfpAgStateMachine::Init()
35 {
36     profile_.Init();
37     connTimer_ = std::make_unique<utility::Timer>(std::bind(&bluetooth::HfpAgStateMachine::ConnectionTimeout, this));
38 
39     std::unique_ptr<utility::StateMachine::State> disconnectedState =
40         std::make_unique<HfpAgDisconnected>(DISCONNECTED, *this, profile_, eventProcessor_);
41     std::unique_ptr<utility::StateMachine::State> connectingState =
42         std::make_unique<HfpAgConnecting>(CONNECTING, *this, profile_, eventProcessor_);
43     std::unique_ptr<utility::StateMachine::State> disconnectingState =
44         std::make_unique<HfpAgDisconnecting>(DISCONNECTING, *this, profile_, eventProcessor_);
45     std::unique_ptr<utility::StateMachine::State> connectedState =
46         std::make_unique<HfpAgConnected>(CONNECTED, *this, profile_, eventProcessor_);
47     std::unique_ptr<utility::StateMachine::State> audioConnecting =
48         std::make_unique<HfpAgAudioConnecting>(AUDIO_CONNECTING, *this, profile_, eventProcessor_, *connectedState);
49     std::unique_ptr<utility::StateMachine::State> audioConnected =
50         std::make_unique<HfpAgAudioConnected>(AUDIO_CONNECTED, *this, profile_, eventProcessor_, *connectedState);
51     std::unique_ptr<utility::StateMachine::State> audioDisconnecting =
52         std::make_unique<HfpAgAudioDisconnecting>(AUDIO_DISCONNECTING,
53                                                   *this, profile_, eventProcessor_, *connectedState);
54 
55     Move(disconnectedState);
56     Move(connectingState);
57     Move(disconnectingState);
58     Move(audioConnecting);
59     Move(audioConnected);
60     Move(audioDisconnecting);
61     Move(connectedState);   // Add parenet state at last
62     InitState(DISCONNECTED);
63 }
64 
GetDeviceAddr() const65 inline std::string HfpAgStateMachine::GetDeviceAddr() const
66 {
67     return address_;
68 }
69 
GetStateInt() const70 int HfpAgStateMachine::GetStateInt() const
71 {
72     return static_cast<const HfpAgState*>(GetState())->GetStateInt();
73 }
74 
AddDeferredMessage(const HfpAgMessage & msg)75 void HfpAgStateMachine::AddDeferredMessage(const HfpAgMessage &msg)
76 {
77     deferMsgs_.push_back(msg);
78 }
79 
ProcessDeferredMessage()80 void HfpAgStateMachine::ProcessDeferredMessage()
81 {
82     auto size = deferMsgs_.size();
83     while (size-- > 0 && !deferMsgs_.empty()) {
84         HfpAgMessage event = deferMsgs_.front();
85         deferMsgs_.pop_front();
86         HfpAgService::GetService()->PostEvent(event);
87     }
88 }
89 
NotifyStateTransitions()90 void HfpAgStateMachine::NotifyStateTransitions()
91 {
92     int toState = GetStateInt();
93     if (toState == HFP_AG_STATE_CONNECTED && preState_ == HFP_AG_STATE_CONNECTING) {
94         HfpAgSystemInterface::GetInstance().QueryPhoneState();
95     }
96 
97     HfpAgService *service = HfpAgService::GetService();
98     if (service != nullptr) {
99         RawAddress device(address_);
100         if ((preState_ != toState) && (preState_ <= HFP_AG_STATE_CONNECTED) && (toState <= HFP_AG_STATE_CONNECTED)) {
101             service->NotifySlcStateChanged(device, toState);
102         }
103 
104         if ((preState_ != toState) && (preState_ >= HFP_AG_AUDIO_STATE_DISCONNECTED) &&
105             (toState >= HFP_AG_AUDIO_STATE_DISCONNECTED)) {
106             service->NotifyAudioStateChanged(device, toState);
107         }
108 
109         if (((toState == HFP_AG_STATE_CONNECTED) && (preState_ < toState)) ||
110             ((toState == HFP_AG_STATE_DISCONNECTED) && (preState_ > toState))) {
111             service->SlcStateChanged(address_, toState);
112         }
113 
114         service->ScoStateChanged(address_, preState_, toState);
115     }
116 
117     preState_ = toState;
118 }
119 
NotifyChildStateToParentState(int fromState,int toState,int reason)120 void HfpAgStateMachine::NotifyChildStateToParentState(int fromState, int toState, int reason)
121 {
122     LOG_INFO("[HFP AG]%{public}s(): fromState[%{public}d], toState[%{public}d], reason[%{public}d]",
123         __FUNCTION__, fromState, toState, reason);
124     HfpAgService *service = HfpAgService::GetService();
125     if (service != nullptr) {
126         if ((fromState != toState) && (fromState >= HFP_AG_AUDIO_STATE_DISCONNECTED) &&
127             (toState >= HFP_AG_AUDIO_STATE_DISCONNECTED)) {
128             RawAddress device(address_);
129             service->NotifyAudioStateChanged(device, toState, reason);
130         }
131 
132         if (((toState == HFP_AG_STATE_CONNECTED) && (fromState < toState)) ||
133             ((toState == HFP_AG_STATE_DISCONNECTED) && (fromState > toState))) {
134             service->SlcStateChanged(address_, toState);
135         }
136 
137         service->ScoStateChanged(address_, fromState, toState);
138     }
139     preState_ = toState;
140     ProcessDeferredMessage();
141 }
142 
ProcessAudioDisconnected(int reason)143 void HfpAgStateMachine::ProcessAudioDisconnected(int reason)
144 {
145     IPowerManager::GetInstance().StatusUpdate(RequestStatus::SCO_OFF, PROFILE_NAME_HFP_AG, RawAddress(address_));
146     NotifyChildStateToParentState(HFP_AG_AUDIO_STATE_CONNECTED, HFP_AG_AUDIO_STATE_DISCONNECTED, reason);
147 }
148 
StartConnectionTimer() const149 void HfpAgStateMachine::StartConnectionTimer() const
150 {
151     connTimer_->Start(CONNECTION_TIMEOUT_MS);
152     LOG_INFO("[HFP AG]%{public}s():Start connection timer!", __FUNCTION__);
153 }
154 
StopConnectionTimer() const155 void HfpAgStateMachine::StopConnectionTimer() const
156 {
157     connTimer_->Stop();
158     LOG_INFO("[HFP AG]%{public}s():Stop connection timer!", __FUNCTION__);
159 }
160 
IsRemoving() const161 bool HfpAgStateMachine::IsRemoving() const
162 {
163     return isRemoving_;
164 }
165 
SetRemoving(bool isRemoving)166 void HfpAgStateMachine::SetRemoving(bool isRemoving)
167 {
168     isRemoving_ = isRemoving;
169 }
170 
ConnectionTimeout() const171 void HfpAgStateMachine::ConnectionTimeout() const
172 {
173     HfpAgMessage event(HFP_AG_CONNECTION_TIMEOUT_EVT);
174     event.dev_ = address_;
175     HfpAgService::GetService()->PostEvent(event);
176 }
177 
ProcessKeyPressed(const RawAddress & device,const int & callState) const178 void HfpAgStateMachine::ProcessKeyPressed(const RawAddress &device, const int &callState) const
179 {
180     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
181     HfpAgSystemInterface& mSystemInterface = HfpAgSystemInterface::GetInstance();
182     if (mSystemInterface.IsRinging()) {
183         mSystemInterface.AnswerCall(device.GetAddress());
184     } else if (mSystemInterface.IsInCall()) {
185         if (GetStateInt() == HfpAgAudioState::HFP_AG_AUDIO_STATE_DISCONNECTED) {
186             if (!HfpAgService::GetService()->SetActiveDevice(device)) {
187                 HILOGI("[HFP AG][failed to set active device to][%{public}s]", GET_ENCRYPT_ADDR(device));
188             }
189         } else {
190             mSystemInterface.HangupCall(device.GetAddress());
191         }
192     } else if (GetStateInt() != HfpAgAudioState::HFP_AG_AUDIO_STATE_DISCONNECTED) {
193         profile_.ReleaseAudioConnection();
194     } else {
195         if (callState == HFP_AG_CALL_STATE_DIALING) {
196             LOG_INFO("[HFP AG]%{public}s():already dialling!", __FUNCTION__);
197             return;
198         }
199         std::string dialNumber = mSystemInterface.GetLastDialNumber();
200         if (dialNumber.empty()) {
201             LOG_INFO("[HFP AG]%{public}s():last dial number null!", __FUNCTION__);
202             return;
203         }
204         mSystemInterface.DialOutCall(device.GetAddress(), dialNumber);
205     }
206 }
207 
Entry()208 void HfpAgDisconnected::Entry()
209 {
210     stateMachine_.ProcessDeferredMessage();
211 
212     if (isReentry_) {
213         stateMachine_.SetRemoving(true);
214         profile_.RemoveStateMachine();
215         stateMachine_.NotifyStateTransitions();
216     }
217 }
218 
Exit()219 void HfpAgDisconnected::Exit()
220 {
221     isReentry_ = true;
222 }
223 
Dispatch(const utility::Message & msg)224 bool HfpAgDisconnected::Dispatch(const utility::Message &msg)
225 {
226     HfpAgMessage &event = (HfpAgMessage &)msg;
227     LOG_INFO("[HFP AG]%{public}s():[Disconnected][%{public}s]", __FUNCTION__,
228         HfpAgStateMachine::GetEventName(event.what_).c_str());
229     switch (event.what_) {
230         case HFP_AG_CONNECT_EVT:
231             profile_.DoServiceDiscovery(HFP_AG_INITIATOR);
232             Transition(HfpAgStateMachine::CONNECTING);
233             break;
234         case HFP_AG_CONNECT_REQUEST_EVT:
235             profile_.DoServiceDiscovery(HFP_AG_ACCEPTOR, event.arg1_);
236             Transition(HfpAgStateMachine::CONNECTING);
237             break;
238         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
239             profile_.RejectAudioConnection();
240             break;
241         default:
242             break;
243     }
244     return true;
245 }
246 
Entry()247 void HfpAgConnecting::Entry()
248 {
249     stateMachine_.NotifyStateTransitions();
250     stateMachine_.StartConnectionTimer();
251     AdapterConfig::GetInstance()->GetValue(HSP_AG_STATE_SECTION_NAME, HSP_AG_STATE_PROPERY_NAME, hspState_);
252 }
253 
Exit()254 void HfpAgConnecting::Exit()
255 {
256     stateMachine_.StopConnectionTimer();
257 }
258 
Dispatch(const utility::Message & msg)259 bool HfpAgConnecting::Dispatch(const utility::Message &msg)
260 {
261     HfpAgMessage &event = (HfpAgMessage &)msg;
262     switch (event.what_) {
263         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
264             profile_.ProcessAudioConnectRequest();
265             break;
266         case HFP_AG_AUDIO_CONNECTED_EVT:
267         case HFP_AG_AUDIO_DISCONNECTED_EVT:
268         case HFP_AG_CONNECT_EVT:
269             stateMachine_.AddDeferredMessage(event);
270             break;
271         case HFP_AG_DISCONNECT_EVT:
272             Transition(HfpAgStateMachine::DISCONNECTED);
273             break;
274         case HFP_AG_SDP_DISCOVERY_RESULT_SUCCESS:
275             if (profile_.ServiceDiscoveryResult() != HFP_AG_SUCCESS) {
276                 Transition(HfpAgStateMachine::DISCONNECTED);
277             }
278             break;
279         case HFP_AG_SDP_DISCOVERY_RESULT_FAIL:
280             Transition(HfpAgStateMachine::DISCONNECTED);
281             break;
282         case HFP_AG_DISCONNECTED_EVT:
283             profile_.RemoveRemoteScnLoging();
284             Transition(HfpAgStateMachine::DISCONNECTED);
285             break;
286         case HFP_AG_CONNECT_FAILED_EVT:
287             profile_.RemoveRemoteScnLoging();
288             Transition(HfpAgStateMachine::DISCONNECTED);
289             break;
290         case HFP_AG_DATA_AVAILABLE_EVT:
291             profile_.ReadData();
292             break;
293         case HFP_AG_SLC_ESTABLISHED_EVT:
294             profile_.ProcessSlcEstablished();
295             Transition(HfpAgStateMachine::CONNECTED);
296             break;
297         case HFP_AG_CONNECTED_EVT:
298             if (hspState_ == HSP_AG_STATE_HSP) {
299                 Transition(HfpAgStateMachine::CONNECTED);
300             }
301             break;
302         case HFP_AG_CONTROL_OTHER_MODULES_EVT:
303             eventProcessor_.ExecuteEventProcess(event);
304             break;
305         case HFP_AG_CONNECTION_TIMEOUT_EVT:
306             Transition(HfpAgStateMachine::DISCONNECTED);
307             break;
308         default:
309             break;
310     }
311     return true;
312 }
313 
Entry()314 void HfpAgDisconnecting::Entry()
315 {
316     stateMachine_.ProcessDeferredMessage();
317     stateMachine_.NotifyStateTransitions();
318     stateMachine_.StartConnectionTimer();
319 }
320 
Exit()321 void HfpAgDisconnecting::Exit()
322 {
323     stateMachine_.StopConnectionTimer();
324 }
325 
Dispatch(const utility::Message & msg)326 bool HfpAgDisconnecting::Dispatch(const utility::Message &msg)
327 {
328     HfpAgMessage &event = (HfpAgMessage &)msg;
329     LOG_INFO("[HFP AG]%{public}s():[Disconnecting][%{public}s]", __FUNCTION__,
330         HfpAgStateMachine::GetEventName(event.what_).c_str());
331     switch (event.what_) {
332         case HFP_AG_CONNECT_EVT:
333             stateMachine_.AddDeferredMessage(event);
334             break;
335         case HFP_AG_DISCONNECTED_EVT:
336             IPowerManager::GetInstance().StatusUpdate(
337                 RequestStatus::CONNECT_OFF, PROFILE_NAME_HFP_AG, RawAddress(event.dev_));
338             profile_.RemoveRemoteScnLoging();
339             Transition(HfpAgStateMachine::DISCONNECTED);
340             break;
341         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
342             profile_.RejectAudioConnection();
343             break;
344         case HFP_AG_CONNECTION_TIMEOUT_EVT:
345             Transition(HfpAgStateMachine::CONNECTED);
346             break;
347         default:
348             break;
349     }
350     return true;
351 }
352 
Entry()353 void HfpAgConnected::Entry()
354 {
355     stateMachine_.ProcessDeferredMessage();
356 
357     HfpAgMessage event(HFP_AG_CONTROL_OTHER_MODULES_EVT);
358     event.type_ = HFP_AG_MSG_TYPE_QUERY_AG_INDICATOR;
359     eventProcessor_.ExecuteEventProcess(event);
360 
361     stateMachine_.NotifyStateTransitions();
362 }
363 
Dispatch(const utility::Message & msg)364 bool HfpAgConnected::Dispatch(const utility::Message &msg)
365 {
366     HfpAgMessage &event = (HfpAgMessage &)msg;
367     LOG_INFO("[HFP AG]%{public}s():[Connected][%{public}s]", __FUNCTION__,
368         HfpAgStateMachine::GetEventName(event.what_).c_str());
369     switch (event.what_) {
370         case HFP_AG_CONNECT_AUDIO_EVT:
371             profile_.SetupCodecConnection();
372             Transition(HfpAgStateMachine::AUDIO_CONNECTING);
373             break;
374         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
375             if (profile_.ProcessAudioConnectRequest()) {
376                 Transition(HfpAgStateMachine::AUDIO_CONNECTING);
377             }
378             break;
379         case HFP_AG_AUDIO_CONNECTING_EVT:
380             Transition(HfpAgStateMachine::AUDIO_CONNECTING);
381             break;
382         case HFP_AG_AUDIO_CONNECTED_EVT:
383             IPowerManager::GetInstance().StatusUpdate(
384                 RequestStatus::SCO_ON, PROFILE_NAME_HFP_AG, RawAddress(event.dev_));
385             Transition(HfpAgStateMachine::AUDIO_CONNECTED);
386             break;
387         case HFP_AG_DISCONNECT_EVT:
388             profile_.ReleaseDataConnection();
389             Transition(HfpAgStateMachine::DISCONNECTING);
390             break;
391         case HFP_AG_DISCONNECTED_EVT:
392             IPowerManager::GetInstance().StatusUpdate(
393                 RequestStatus::CONNECT_OFF, PROFILE_NAME_HFP_AG, RawAddress(event.dev_));
394             profile_.RemoveRemoteScnLoging();
395             Transition(HfpAgStateMachine::DISCONNECTED);
396             break;
397         case HFP_AG_DATA_AVAILABLE_EVT:
398             profile_.ReadData();
399             break;
400         case HFP_AG_CONTROL_OTHER_MODULES_EVT:
401             if (event.type_ == HFP_AG_MSG_TYPE_DIAL_CALL) {
402                 profile_.SendResultCode(HFP_AG_RESULT_OK);
403             }
404             eventProcessor_.ExecuteEventProcess(event);
405             break;
406         case HFP_AG_OPEN_VOICE_RECOGNITION_EVT:
407             profile_.ActivateVoiceRecognition();
408             break;
409         case HFP_AG_CLOSE_VOICE_RECOGNITION_EVT:
410             profile_.DeactivateVoiceRecognition();
411             break;
412         case HFP_AG_PROCESS_CKPD_EVT:
413             stateMachine_.ProcessKeyPressed(RawAddress(event.dev_), callState_);
414             break;
415         case HFP_AG_VOICE_RECOGNITION_RESULT_EVT:
416             ProcessVoiceRecognitionResult(event.arg1_);
417             break;
418         case HFP_AG_VOICE_RECOGNITION_TIME_OUT_EVT:
419             profile_.SendResultCode(HFP_AG_RESULT_ERROR);
420             break;
421         case HFP_AG_CALL_STATE_CHANGE:
422             callState_ = event.state_.callState;
423             ProcessPhoneStateChange(event);
424             break;
425         case HFP_AG_CALL_STATE_CHANGE_MOCK:
426             event.type_ = HFP_AG_CALL_STATE_CHANGE_MOCK;
427             eventProcessor_.ExecuteEventProcess(event);
428             break;
429         case HFP_AG_SEND_CCLC_RESPONSE:
430         case HFP_AG_RESPONSE_CLCC_TIME_OUT_EVT:
431             ProcessResponseClcc(event);
432             break;
433         case HFP_AG_NOTIFY_SERVICE_STATE:
434             profile_.ReportRegistrationStatus(event.arg1_);
435             break;
436         case HFP_AG_NOTIFY_ROAM_STATE:
437             profile_.ReportRoamingState(event.arg1_);
438             break;
439         case HFP_AG_NOTIFY_SIGNAL_STRENGTH:
440             profile_.ReportSignalStrength(event.arg1_);
441             break;
442         case HFP_AG_NOTIFY_BATTERY_LEVEL:
443             profile_.ReportBatteryLevel(event.arg1_);
444             break;
445         case HFP_AG_DIALING_OUT_RESULT:
446             profile_.SendResultCode(event.arg1_);
447             break;
448         case HFP_AG_SET_INBAND_RING_TONE_EVT:
449             profile_.SetInbandRingTone(event.arg1_);
450             break;
451         case HFP_AG_RING_TIMEOUT_EVT:
452             profile_.SendRingAndClip();
453             break;
454         case HFP_AG_NOTIFY_INDICATOR_EVT:
455             eventProcessor_.ExecuteEventProcess(event);
456             break;
457         case HFP_AG_RESPONE_OK_EVT:
458             ProcessResponesOK();
459             break;
460         case HFP_AG_SEND_INCOMING_EVT:
461             profile_.NotifyIncomingCallWaiting(event.arg1_, event.str_);
462             LOG_INFO(" incoming call");
463             break;
464         case HFP_AG_SEND_CALL_SETUP_EVT:
465             LOG_INFO(" incoming call set up");
466             profile_.ReportCallsetupStatus(event.arg1_);
467             break;
468         case HFP_AG_SEND_CALL_HELD_EVT:
469             profile_.ReportCallheldStatus(event.arg1_);
470             break;
471         case HFP_AG_SEND_CALL_STATE_EVT:
472             profile_.ReportCallStatus(event.arg1_);
473             break;
474         case HFP_AG_GET_VOICE_NUMBER:
475             event.type_ = HFP_AG_GET_VOICE_NUMBER;
476             eventProcessor_.ExecuteEventProcess(event);
477             break;
478         case HFP_AG_SEND_BINP_EVT:
479             profile_.SendBinp(event.str_);
480             break;
481         case HFP_AG_GET_BTRH_EVT:
482         case HFP_AG_SET_BTRH_EVT:
483             eventProcessor_.ExecuteEventProcess(event);
484             break;
485         case HFP_AG_SEND_RESPONSE_HOLD_STATE:
486             profile_.ReportResponseHoldStatus(event.arg1_, -1);
487             break;
488         case HFP_AG_SEND_BTRH_EVT:
489             profile_.ReportResponseHoldStatus(event.arg1_, event.arg3_);
490             break;
491         case HFP_AG_SEND_NO_CARRIER:
492             profile_.SendResultCode(HFP_AG_RESULT_NO_CARRIER);
493             break;
494         case HFP_AG_START_MOCK:
495             profile_.startMock(event.arg1_);
496             break;
497         case HFP_AG_MOCK_RING:
498             profile_.SendResultCode(HFP_AG_RESULT_RING);
499             break;
500         case HFP_AG_MOCK_CLIP:
501             profile_.NotifyCallingLineIdentification(CALL_TYPE_DEFAULT, event.str_);
502             break;
503         default:
504             break;
505     }
506     return true;
507 }
508 
ProcessVoiceRecognitionResult(int result)509 void HfpAgConnected::ProcessVoiceRecognitionResult(int result)
510 {
511     if (result == 1) {
512         profile_.SendResultCode(HFP_AG_RESULT_OK);
513 
514         auto address = stateMachine_.GetDeviceAddr();
515         if (HfpAgProfile::IsAudioConnected(address) == false) {
516             HfpAgMessage msg(HFP_AG_CONNECT_AUDIO_EVT);
517             msg.dev_ = address;
518             HfpAgService::GetService()->PostEvent(msg);
519         }
520     } else {
521         profile_.SendResultCode(HFP_AG_RESULT_ERROR);
522     }
523 }
524 
ProcessPhoneStateChange(const HfpAgMessage & event) const525 void HfpAgConnected::ProcessPhoneStateChange(const HfpAgMessage &event) const
526 {
527     profile_.PhoneStateChange(event.state_);
528 }
529 
ProcessResponseClcc(const HfpAgMessage & event) const530 void HfpAgConnected::ProcessResponseClcc(const HfpAgMessage &event) const
531 {
532     profile_.ReportCurrentCallList(event.call_);
533 }
534 
ProcessResponesOK() const535 void HfpAgConnected::ProcessResponesOK() const
536 {
537     profile_.ResponesOK();
538 }
539 
Entry()540 void HfpAgAudioConnecting::Entry()
541 {
542     stateMachine_.ProcessDeferredMessage();
543     stateMachine_.NotifyStateTransitions();
544     stateMachine_.StartConnectionTimer();
545 }
546 
Exit()547 void HfpAgAudioConnecting::Exit()
548 {
549     stateMachine_.StopConnectionTimer();
550 }
551 
Dispatch(const utility::Message & msg)552 bool HfpAgAudioConnecting::Dispatch(const utility::Message &msg)
553 {
554     HfpAgMessage &event = (HfpAgMessage &)msg;
555     LOG_INFO("[HFP AG]%{public}s():[AudioConnecting][%{public}s]", __FUNCTION__,
556         HfpAgStateMachine::GetEventName(event.what_).c_str());
557     switch (event.what_) {
558         case HFP_AG_CONNECT_AUDIO_EVT:
559         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
560         case HFP_AG_AUDIO_CONNECTING_EVT:
561             break;
562         case HFP_AG_DISCONNECT_EVT:
563         case HFP_AG_DISCONNECT_AUDIO_EVT:
564             stateMachine_.AddDeferredMessage(event);
565             break;
566         case HFP_AG_RETRY_CONNECT_AUDIO_EVT:
567         case HFP_AG_CODEC_NEGOTIATED_EVT:
568             profile_.EstablishAudioConnection();
569             break;
570         case HFP_AG_SETUP_CODEC_CVSD:
571             profile_.SetupCodecCvsd();
572             break;
573         case HFP_AG_CODEC_NEGOTIATION_FAILED:
574             profile_.SetupCodecConnection();
575             break;
576         case HFP_AG_AUDIO_CONNECTED_EVT:
577             IPowerManager::GetInstance().StatusUpdate(
578                 RequestStatus::SCO_ON, PROFILE_NAME_HFP_AG, RawAddress(event.dev_));
579             Transition(HfpAgStateMachine::AUDIO_CONNECTED);
580             break;
581         case HFP_AG_AUDIO_CONNECT_FAILED_EVT:
582         case HFP_AG_CONNECTION_TIMEOUT_EVT:
583         case HFP_AG_AUDIO_DISCONNECTED_EVT:
584             stateMachine_.NotifyChildStateToParentState(HFP_AG_AUDIO_STATE_CONNECTING, HFP_AG_AUDIO_STATE_DISCONNECTED);
585             Transition(HfpAgStateMachine::CONNECTED);
586             break;
587         case HFP_AG_DISCONNECTED_EVT:
588             stateMachine_.AddDeferredMessage(event);
589             stateMachine_.NotifyChildStateToParentState(HFP_AG_AUDIO_STATE_CONNECTING, HFP_AG_AUDIO_STATE_DISCONNECTED);
590             Transition(HfpAgStateMachine::CONNECTED);
591             break;
592         default:
593             return false;
594     }
595     return true;
596 }
597 
Entry()598 void HfpAgAudioDisconnecting::Entry()
599 {
600     stateMachine_.NotifyStateTransitions();
601     stateMachine_.StartConnectionTimer();
602 }
603 
Exit()604 void HfpAgAudioDisconnecting::Exit()
605 {
606     stateMachine_.StopConnectionTimer();
607 }
608 
Dispatch(const utility::Message & msg)609 bool HfpAgAudioDisconnecting::Dispatch(const utility::Message &msg)
610 {
611     HfpAgMessage &event = (HfpAgMessage &)msg;
612     LOG_INFO("[HFP AG]%{public}s():[AudioDisconnecting][%{public}s]", __FUNCTION__,
613         HfpAgStateMachine::GetEventName(event.what_).c_str());
614     switch (event.what_) {
615         case HFP_AG_DISCONNECT_EVT:
616         case HFP_AG_CONNECT_AUDIO_EVT:
617         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
618         case HFP_AG_DISCONNECTED_EVT:
619             stateMachine_.AddDeferredMessage(event);
620             break;
621         case HFP_AG_AUDIO_CONNECTING_EVT:
622         case HFP_AG_DISCONNECT_AUDIO_EVT:
623         case HFP_AG_AUDIO_DISCONNECTING_EVT:
624         case HFP_AG_AUDIO_CONNECTED_EVT:
625         case HFP_AG_AUDIO_CONNECT_FAILED_EVT:
626             break;
627         case HFP_AG_AUDIO_DISCONNECTED_EVT:
628             stateMachine_.ProcessAudioDisconnected(HFP_AG_SCO_LOCAL_USER_TERMINATED);
629             Transition(HfpAgStateMachine::CONNECTED);
630             break;
631         case HFP_AG_AUDIO_DISCONNECT_FAILED_EVT:
632         case HFP_AG_CONNECTION_TIMEOUT_EVT:
633             stateMachine_.NotifyChildStateToParentState(HFP_AG_AUDIO_STATE_DISCONNECTING, HFP_AG_AUDIO_STATE_CONNECTED);
634             Transition(HfpAgStateMachine::AUDIO_CONNECTED);
635             break;
636         default:
637             return false;
638     }
639     return true;
640 }
641 
Entry()642 void HfpAgAudioConnected::Entry()
643 {
644     stateMachine_.ProcessDeferredMessage();
645     stateMachine_.NotifyStateTransitions();
646     profile_.PostAudioConnectionEstablishment();
647 }
648 
Dispatch(const utility::Message & msg)649 bool HfpAgAudioConnected::Dispatch(const utility::Message &msg)
650 {
651     HfpAgMessage &event = (HfpAgMessage &)msg;
652     LOG_INFO("[HFP AG]%{public}s():[AudioConnected][%{public}s]", __FUNCTION__,
653         HfpAgStateMachine::GetEventName(event.what_).c_str());
654     switch (event.what_) {
655         case HFP_AG_DISCONNECT_EVT:
656             ProcessDisconnect(event);
657             break;
658         case HFP_AG_DISCONNECTED_EVT:
659             stateMachine_.AddDeferredMessage(event);
660             break;
661         case HFP_AG_CONNECT_AUDIO_EVT:
662         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
663         case HFP_AG_AUDIO_CONNECTING_EVT:
664         case HFP_AG_AUDIO_CONNECTED_EVT:
665             break;
666         case HFP_AG_DISCONNECT_AUDIO_EVT:
667             profile_.ReleaseAudioConnection();
668             break;
669         case HFP_AG_AUDIO_DISCONNECTED_EVT:
670             stateMachine_.ProcessAudioDisconnected(HFP_AG_SCO_REMOTE_USER_TERMINATED);
671             Transition(HfpAgStateMachine::CONNECTED);
672             break;
673         case HFP_AG_AUDIO_DISCONNECTING_EVT:
674             Transition(HfpAgStateMachine::AUDIO_DISCONNECTING);
675             break;
676         case HFP_AG_SET_VOLUME_EVT:
677             ProcessSetVolume(event);
678             break;
679         default:
680             return false;
681     }
682     return true;
683 }
684 
ProcessDisconnect(const HfpAgMessage & event)685 void HfpAgAudioConnected::ProcessDisconnect(const HfpAgMessage &event)
686 {
687     profile_.ReleaseAudioConnection();
688     stateMachine_.AddDeferredMessage(event);
689 }
690 
ProcessSetVolume(const HfpAgMessage & event)691 void HfpAgAudioConnected::ProcessSetVolume(const HfpAgMessage &event)
692 {
693     if (event.arg1_ == HFP_AG_VOLUME_TYPE_SPK) {
694         profile_.SetSpeakerVolume(event.arg3_);
695     } else if (event.arg1_ == HFP_AG_VOLUME_TYPE_MIC) {
696         profile_.SetMicrophoneGain(event.arg3_);
697     } else {
698         LOG_ERROR("the error type:%{public}d", event.arg1_);
699     }
700 }
701 
GetEventName(int what)702 std::string HfpAgStateMachine::GetEventName(int what)
703 {
704     switch (what) {
705         case HFP_AG_INVALID_EVT:
706             return "HFP_AG_INVALID_EVT";
707         case HFP_AG_SERVICE_STARTUP_EVT:
708             return "HFP_AG_SERVICE_STARTUP_EVT";
709         case HFP_AG_SERVICE_SHUTDOWN_EVT:
710             return "HFP_AG_SERVICE_SHUTDOWN_EVT";
711         case HFP_AG_CONNECT_EVT:
712             return "HFP_AG_CONNECT_EVT";
713         case HFP_AG_DISCONNECT_EVT:
714             return "HFP_AG_DISCONNECT_EVT";
715         case HFP_AG_PROCESS_CKPD_EVT:
716             return "HFP_AG_PROCESS_CKPD_EVT";
717         case HFP_AG_CONNECT_AUDIO_EVT:
718             return "HFP_AG_CONNECT_AUDIO_EVT";
719         case HFP_AG_DISCONNECT_AUDIO_EVT:
720             return "HFP_AG_DISCONNECT_AUDIO_EVT";
721         case HFP_AG_RETRY_CONNECT_AUDIO_EVT:
722             return "HFP_AG_RETRY_CONNECT_AUDIO_EVT";
723         case HFP_AG_CONNECTION_TIMEOUT_EVT:
724             return "HFP_AG_CONNECTION_TIMEOUT_EVT";
725         case HFP_AG_DISCONNECT_TIMEOUT_EVT:
726             return "HFP_AG_DISCONNECT_TIMEOUT_EVT";
727         case HFP_AG_CONNECT_AUDIO_TIMEOUT_EVT:
728             return "HFP_AG_CONNECT_AUDIO_TIMEOUT_EVT";
729         case HFP_AG_DISCONNECT_AUDIO_TIMEOUT_EVT:
730             return "HFP_AG_DISCONNECT_AUDIO_TIMEOUT_EVT";
731         case HFP_AG_OPEN_VOICE_RECOGNITION_EVT:
732             return "HFP_AG_OPEN_VOICE_RECOGNITION_EVT";
733         case HFP_AG_CLOSE_VOICE_RECOGNITION_EVT:
734             return "HFP_AG_CLOSE_VOICE_RECOGNITION_EVT";
735         case HFP_AG_VOICE_RECOGNITION_RESULT_EVT:
736             return "HFP_AG_VOICE_RECOGNITION_RESULT_EVT";
737         case HFP_AG_SET_MICROPHONE_GAIN_EVT:
738             return "HFP_AG_SET_MICROPHONE_GAIN_EVT";
739         case HFP_AG_SET_VOLUME_EVT:
740             return "HFP_AG_SET_VOLUME_EVT";
741         case HFP_AG_SET_INBAND_RING_TONE_EVT:
742             return "HFP_AG_SET_INBAND_RING_TONE_EVT";
743         case HFP_AG_SEND_SUBSCRIBER_NUMBER_EVT:
744             return "HFP_AG_SEND_SUBSCRIBER_NUMBER_EVT";
745         case HFP_AG_SEND_NETWORK_OPERATOR_EVT:
746             return "HFP_AG_SEND_NETWORK_OPERATOR_EVT";
747         case HFP_AG_CONTROL_OTHER_MODULES_EVT:
748             return "HFP_AG_CONTROL_OTHER_MODULES_EVT";
749         case HFP_AG_DIALING_OUT_RESULT:
750             return "HFP_AG_DIALING_OUT_RESULT";
751         case HFP_AG_CALL_STATE_CHANGE:
752             return "HFP_AG_CALL_STATE_CHANGE";
753         case HFP_AG_SEND_CCLC_RESPONSE:
754             return "HFP_AG_SEND_CCLC_RESPONSE";
755         case HFP_AG_NOTIFY_SERVICE_STATE:
756             return "HFP_AG_NOTIFY_SERVICE_STATE";
757         case HFP_AG_NOTIFY_ROAM_STATE:
758             return "HFP_AG_NOTIFY_ROAM_STATE";
759         case HFP_AG_NOTIFY_SIGNAL_STRENGTH:
760             return "HFP_AG_NOTIFY_SIGNAL_STRENGTH";
761         case HFP_AG_NOTIFY_BATTERY_LEVEL:
762             return "HFP_AG_NOTIFY_BATTERY_LEVEL";
763         case HFP_AG_SDP_DISCOVERY_RESULT_SUCCESS:
764             return "HFP_AG_SDP_DISCOVERY_RESULT_SUCCESS";
765         case HFP_AG_SDP_DISCOVERY_RESULT_FAIL:
766             return "HFP_AG_SDP_DISCOVERY_RESULT_FAIL";
767         case HFP_AG_CONNECT_REQUEST_EVT:
768             return "HFP_AG_CONNECT_REQUEST_EVT";
769         case HFP_AG_CONNECTED_EVT:
770             return "HFP_AG_CONNECTED_EVT";
771         case HFP_AG_DISCONNECTED_EVT:
772             return "HFP_AG_DISCONNECTED_EVT";
773         case HFP_AG_CONNECT_FAILED_EVT:
774             return "HFP_AG_CONNECT_FAILED_EVT";
775         case HFP_AG_DISCONNECT_FAILED_EVT:
776             return "HFP_AG_DISCONNECT_FAILED_EVT";
777         case HFP_AG_DATA_AVAILABLE_EVT:
778             return "HFP_AG_DATA_AVAILABLE_EVT";
779         case HFP_AG_CODEC_NEGOTIATION_FAILED:
780             return "HFP_AG_CODEC_NEGOTIATION_FAILED";
781         case HFP_AG_SETUP_CODEC_CVSD:
782             return "HFP_AG_SETUP_CODEC_CVSD";
783         case HFP_AG_SLC_ESTABLISHED_EVT:
784             return "HFP_AG_SLC_ESTABLISHED_EVT";
785         case HFP_AG_CODEC_NEGOTIATED_EVT:
786             return "HFP_AG_CODEC_NEGOTIATED_EVT";
787         case HFP_AG_AUDIO_CONNECT_REQUEST_EVT:
788             return "HFP_AG_AUDIO_CONNECT_REQUEST_EVT";
789         case HFP_AG_AUDIO_CONNECTING_EVT:
790             return "HFP_AG_AUDIO_CONNECTING_EVT";
791         case HFP_AG_AUDIO_DISCONNECTING_EVT:
792             return "HFP_AG_AUDIO_DISCONNECTING_EVT";
793         case HFP_AG_AUDIO_CONNECTED_EVT:
794             return "HFP_AG_AUDIO_CONNECTED_EVT";
795         case HFP_AG_AUDIO_DISCONNECTED_EVT:
796             return "HFP_AG_AUDIO_DISCONNECTED_EVT";
797         case HFP_AG_AUDIO_CONNECT_FAILED_EVT:
798             return "HFP_AG_AUDIO_CONNECT_FAILED_EVT";
799         case HFP_AG_AUDIO_DISCONNECT_FAILED_EVT:
800             return "HFP_AG_AUDIO_DISCONNECT_FAILED_EVT";
801         case HFP_AG_RESPONSE_CLCC_TIME_OUT_EVT:
802             return "HFP_AG_RESPONSE_CLCC_TIME_OUT_EVT";
803         case HFP_AG_DIAL_TIME_OUT_EVT:
804             return "HFP_AG_DIAL_TIME_OUT_EVT";
805         case HFP_AG_RING_TIMEOUT_EVT:
806             return "HFP_AG_RING_TIMEOUT_EVT";
807         default:
808             return "Unknown";
809     }
810 }
811 }  // namespace bluetooth
812 }  // namespace OHOS
813