1 /*
2  * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "hfp_hf_statemachine.h"
17 
18 #include "hfp_hf_data_connection_server.h"
19 #include "hfp_hf_service.h"
20 #include "power_manager.h"
21 #include "audio_system_manager.h"
22 
23 namespace OHOS {
24 namespace bluetooth {
HfpHfStateMachine(const std::string & address)25 HfpHfStateMachine::HfpHfStateMachine(const std::string &address)
26     : address_(address), profile_(address)
27 {}
28 
Init()29 void HfpHfStateMachine::Init()
30 {
31     profile_.Init();
32     calls_ = std::make_unique<HfpHfCallManager>(address_);
33     connTimer_ = std::make_unique<utility::Timer>(std::bind(&bluetooth::HfpHfStateMachine::ConnectionTimeout, this));
34 
35     std::unique_ptr<utility::StateMachine::State> disconnectedState =
36         std::make_unique<HfpHfDisconnected>(DISCONNECTED, *this, profile_);
37     std::unique_ptr<utility::StateMachine::State> connectingState =
38         std::make_unique<HfpHfConnecting>(CONNECTING, *this, profile_);
39     std::unique_ptr<utility::StateMachine::State> disconnectingState =
40         std::make_unique<HfpHfDisconnecting>(DISCONNECTING, *this, profile_);
41     std::unique_ptr<utility::StateMachine::State> connectedState =
42         std::make_unique<HfpHfConnected>(CONNECTED, *this, profile_);
43     std::unique_ptr<utility::StateMachine::State> audioConnecting =
44         std::make_unique<HfpHfAudioConnecting>(AUDIO_CONNECTING, *this, profile_, *connectedState);
45     std::unique_ptr<utility::StateMachine::State> audioDisconnecting =
46         std::make_unique<HfpHfAudioDisconnecting>(AUDIO_DISCONNECTING, *this, profile_, *connectedState);
47     std::unique_ptr<utility::StateMachine::State> audioConnected =
48         std::make_unique<HfpHfAudioConnected>(AUDIO_CONNECTED, *this, profile_, *connectedState);
49 
50     Move(disconnectedState);
51     Move(connectingState);
52     Move(disconnectingState);
53     Move(audioConnecting);
54     Move(audioDisconnecting);
55     Move(audioConnected);
56     Move(connectedState);   // Add parenet state at last
57 
58     InitState(DISCONNECTED);
59 }
60 
Entry()61 void HfpHfDisconnected::Entry()
62 {
63     stateMachine_.ProcessDeferredMessage();
64 
65     if (isReentry_) {
66         stateMachine_.SetRemoving(true);
67         profile_.RemoveStateMachine();
68         stateMachine_.NotifyStateTransitions();
69     }
70 }
71 
Exit()72 void HfpHfDisconnected::Exit()
73 {
74     isReentry_ = true;
75 }
76 
Dispatch(const utility::Message & msg)77 bool HfpHfDisconnected::Dispatch(const utility::Message &msg)
78 {
79     HfpHfMessage &event = (HfpHfMessage &)msg;
80     LOG_DEBUG("[HFP HF]%{public}s():[Disconnected][%{public}s]",
81         __FUNCTION__, HfpHfStateMachine::GetEventName(event.what_).c_str());
82     switch (event.what_) {
83         case HFP_HF_CONNECT_EVT:
84             profile_.DoServiceDiscovery(HFP_HF_INITIATOR);
85             Transition(HfpHfStateMachine::CONNECTING);
86             break;
87         case HFP_HF_CONNECT_REQUEST_EVT:
88             profile_.AcceptDataConnection(event.arg1_);
89             Transition(HfpHfStateMachine::CONNECTING);
90             break;
91         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
92             profile_.RejectAudioConnection();
93             break;
94         default:
95             break;
96     }
97     return true;
98 }
99 
Entry()100 void HfpHfConnecting::Entry()
101 {
102     stateMachine_.ProcessDeferredMessage();
103     stateMachine_.NotifyStateTransitions();
104     stateMachine_.StartConnectionTimer();
105 }
Exit()106 void HfpHfConnecting::Exit()
107 {
108     stateMachine_.StopConnectionTimer();
109 }
110 
Dispatch(const utility::Message & msg)111 bool HfpHfConnecting::Dispatch(const utility::Message &msg)
112 {
113     HfpHfMessage &event = (HfpHfMessage &)msg;
114     LOG_DEBUG("[HFP HF]%{public}s():[Connecting][%{public}s]",
115         __FUNCTION__, HfpHfStateMachine::GetEventName(event.what_).c_str());
116     switch (event.what_) {
117         case HFP_HF_SDP_DISCOVERY_RESULT_SUCCESS:
118             if (profile_.ServiceDiscoveryResult() != HFP_HF_SUCCESS) {
119                 Transition(HfpHfStateMachine::DISCONNECTED);
120             }
121             break;
122         case HFP_HF_SDP_DISCOVERY_RESULT_FAIL:
123             Transition(HfpHfStateMachine::DISCONNECTED);
124             break;
125         case HFP_HF_CONNECT_EVT:
126         case HFP_HF_DISCONNECT_EVT:
127             stateMachine_.AddDeferredMessage(event);
128             break;
129         case HFP_HF_DATA_AVAILABLE_EVT:
130             profile_.ReadData();
131             break;
132         case HFP_HF_CONNECTED_EVT:
133             profile_.EstablishServiceLevelConnection();
134             break;
135         case HFP_HF_DISCONNECTED_EVT:
136             profile_.RemoveRemoteScnLoging();
137             Transition(HfpHfStateMachine::DISCONNECTED);
138             break;
139         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
140             profile_.ProcessAudioConnectRequest();
141             break;
142         case HFP_HF_AUDIO_CONNECTED_EVT:
143         case HFP_HF_AUDIO_DISCONNECTED_EVT:
144             stateMachine_.AddDeferredMessage(event);
145             break;
146         case HFP_HF_CONNECT_FAILED_EVT:
147             profile_.RemoveRemoteScnLoging();
148             Transition(HfpHfStateMachine::DISCONNECTED);
149             break;
150         case HFP_HF_SLC_ESTABLISHED_EVT:
151             profile_.ProcessSlcEstablished();
152             Transition(HfpHfStateMachine::CONNECTED);
153             break;
154         case HFP_HF_BATTERY_LEVEL_CHANGED_EVT:
155             profile_.ReportBatteryLevel(event.arg1_);
156             break;
157         case HFP_HF_ENHANCED_DRIVER_SAFETY_CHANGED_EVT:
158             profile_.ReportDriverSafety(event.arg1_);
159             break;
160         case HFP_HF_INTERACTIVE_EVT:
161             stateMachine_.AddDeferredMessage(event);
162             break;
163         case HFP_HF_CONNECTION_TIMEOUT_EVT:
164             Transition(HfpHfStateMachine::DISCONNECTED);
165             break;
166         default:
167             break;
168     }
169     return true;
170 }
171 
Entry()172 void HfpHfDisconnecting::Entry()
173 {
174     stateMachine_.ProcessDeferredMessage();
175     stateMachine_.NotifyStateTransitions();
176     stateMachine_.StartConnectionTimer();
177 }
178 
Exit()179 void HfpHfDisconnecting::Exit()
180 {
181     stateMachine_.StopConnectionTimer();
182 }
183 
Dispatch(const utility::Message & msg)184 bool HfpHfDisconnecting::Dispatch(const utility::Message &msg)
185 {
186     HfpHfMessage &event = (HfpHfMessage &)msg;
187     LOG_DEBUG("[HFP HF]%{public}s():[Disconnecting][%{public}s]", __FUNCTION__,
188         HfpHfStateMachine::GetEventName(event.what_).c_str());
189     switch (event.what_) {
190         case HFP_HF_CONNECT_EVT:
191             stateMachine_.AddDeferredMessage(event);
192             break;
193         case HFP_HF_DISCONNECTED_EVT:
194             IPowerManager::GetInstance().StatusUpdate(
195                 RequestStatus::CONNECT_OFF, PROFILE_NAME_HFP_HF, RawAddress(event.dev_));
196             profile_.RemoveRemoteScnLoging();
197             Transition(HfpHfStateMachine::DISCONNECTED);
198             break;
199         case HFP_HF_DISCONNECT_FAILED_EVT:
200         case HFP_HF_CONNECTION_TIMEOUT_EVT:
201             Transition(HfpHfStateMachine::CONNECTED);
202             break;
203         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
204             profile_.RejectAudioConnection();
205             break;
206         default:
207             break;
208     }
209     return true;
210 }
211 
Entry()212 void HfpHfConnected::Entry()
213 {
214     stateMachine_.ProcessDeferredMessage();
215     stateMachine_.NotifyStateTransitions();
216 }
217 
Dispatch(const utility::Message & msg)218 bool HfpHfConnected::Dispatch(const utility::Message &msg)
219 {
220     HfpHfMessage &event = (HfpHfMessage &)msg;
221     LOG_DEBUG("[HFP HF]%{public}s():[Connected][%{public}s]",
222         __FUNCTION__, HfpHfStateMachine::GetEventName(event.what_).c_str());
223     switch (event.what_) {
224         case HFP_HF_CONNECT_AUDIO_EVT:
225         case HFP_HF_RETRY_CONNECT_AUDIO_EVT:
226             profile_.SetupCodecConnection();
227             Transition(HfpHfStateMachine::AUDIO_CONNECTING);
228             break;
229         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
230             profile_.ProcessAudioConnectRequest();
231             Transition(HfpHfStateMachine::AUDIO_CONNECTING);
232             break;
233         case HFP_HF_AUDIO_CONNECTING_EVT:
234             Transition(HfpHfStateMachine::AUDIO_CONNECTING);
235             break;
236         case HFP_HF_AUDIO_CONNECTED_EVT:
237             IPowerManager::GetInstance().StatusUpdate(
238                 RequestStatus::SCO_ON, PROFILE_NAME_HFP_HF, RawAddress(event.dev_));
239             Transition(HfpHfStateMachine::AUDIO_CONNECTED);
240             break;
241         case HFP_HF_DISCONNECT_EVT:
242             profile_.ReleaseDataConnection();
243             Transition(HfpHfStateMachine::DISCONNECTING);
244             break;
245         case HFP_HF_DISCONNECTED_EVT:
246             IPowerManager::GetInstance().StatusUpdate(
247                 RequestStatus::CONNECT_OFF, PROFILE_NAME_HFP_HF, RawAddress(event.dev_));
248             profile_.RemoveRemoteScnLoging();
249             Transition(HfpHfStateMachine::DISCONNECTED);
250             break;
251         case HFP_HF_DATA_AVAILABLE_EVT:
252             profile_.ReadData();
253             break;
254         case HFP_HF_INTERACTIVE_EVT:
255             stateMachine_.ProcessInteractiveEvent(event);
256             break;
257         case HFP_HF_SEND_DTMF_EVT:
258             profile_.SendDtmf(event.arg1_);
259             break;
260         case HFP_HF_SET_VOLUME_EVT:
261             profile_.SetHfVolume(event.arg1_, event.arg3_);
262             break;
263         case HFP_HF_ACCEPT_CALL_EVT:
264             stateMachine_.ProcessAcceptCall(event.arg1_);
265             break;
266         case HFP_HF_HOLD_CALL_EVT:
267             stateMachine_.ProcessHoldCall();
268             break;
269         case HFP_HF_REJECT_CALL_EVT:
270             stateMachine_.ProcessRejectCall();
271             break;
272         case HFP_HF_SEND_KEY_PRESSED:
273             stateMachine_.PrecessSendKeyPressed();
274             break;
275         case HFP_HF_HANDLE_INCOMING_CALL_EVT:
276             stateMachine_.ProcessHandleIncomingCall(event.arg1_);
277             break;
278         case HFP_HF_HANDLE_MULTI_CALL_EVT:
279             stateMachine_.ProcessHandleMultiCall(event.arg1_, event.arg3_);
280             break;
281         case HFP_HF_DIAL_LAST_NUMBER:
282             stateMachine_.ProcessDialLastNumber();
283             break;
284         case HFP_HF_DIAL_MEMORY:
285             stateMachine_.ProcessDialMemory(event.arg1_);
286             break;
287         case HFP_HF_SEND_VOICE_TAG:
288             stateMachine_.ProcessSendVoiceTag(event.arg1_);
289             break;
290         case HFP_HF_FINISH_CALL_EVT:
291             stateMachine_.ProcessFinishCall(event);
292             break;
293         case HFP_HF_DIAL_CALL_EVT:
294             stateMachine_.ProcessDialCall(event);
295             break;
296         case HFP_HF_OPEN_VOICE_RECOGNITION_EVT:
297             stateMachine_.ProcessOpenVoiceRecognition();
298             break;
299         case HFP_HF_CLOSE_VOICE_RECOGNITION_EVT:
300             stateMachine_.ProcessCloseVoiceRecognition();
301             break;
302         case HFP_HF_BATTERY_LEVEL_CHANGED_EVT:
303             profile_.ReportBatteryLevel(event.arg1_);
304             break;
305         case HFP_HF_ENHANCED_DRIVER_SAFETY_CHANGED_EVT:
306             profile_.ReportDriverSafety(event.arg1_);
307             break;
308         case HFP_HF_SEND_AT_COMMAND_EVT:
309             profile_.SendAtCommand(event.arg1_, event.str_);
310             break;
311         default:
312             break;
313     }
314     return true;
315 }
316 
Entry()317 void HfpHfAudioConnecting::Entry()
318 {
319     stateMachine_.ProcessDeferredMessage();
320     stateMachine_.NotifyStateTransitions();
321     stateMachine_.StartConnectionTimer();
322 }
323 
Exit()324 void HfpHfAudioConnecting::Exit()
325 {
326     stateMachine_.StopConnectionTimer();
327 }
328 
Dispatch(const utility::Message & msg)329 bool HfpHfAudioConnecting::Dispatch(const utility::Message &msg)
330 {
331     HfpHfMessage &event = (HfpHfMessage &)msg;
332     LOG_DEBUG("[HFP HF]%{public}s():[AudioConnecting][%{public}s]", __FUNCTION__,
333         HfpHfStateMachine::GetEventName(event.what_).c_str());
334     switch (event.what_) {
335         case HFP_HF_CONNECT_AUDIO_EVT:
336         case HFP_HF_AUDIO_CONNECTING_EVT:
337             break;
338         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
339             profile_.ProcessAudioConnReqInAudioConnecting();
340             break;
341         case HFP_HF_DISCONNECT_AUDIO_EVT:
342         case HFP_HF_DISCONNECT_EVT:
343             stateMachine_.AddDeferredMessage(event);
344             break;
345         case HFP_HF_AUDIO_CONNECTED_EVT:
346             IPowerManager::GetInstance().StatusUpdate(
347                 RequestStatus::SCO_ON, PROFILE_NAME_HFP_HF, RawAddress(event.dev_));
348             profile_.RestorCodecSetupRole();
349             Transition(HfpHfStateMachine::AUDIO_CONNECTED);
350             break;
351         case HFP_HF_AUDIO_CONNECT_FAILED_EVT:
352         case HFP_HF_CONNECTION_TIMEOUT_EVT:
353         case HFP_HF_AUDIO_DISCONNECTED_EVT:
354             profile_.RestorCodecSetupRole();
355             stateMachine_.NotifyChildStateToParentState(HFP_HF_AUDIO_STATE_CONNECTING, HFP_HF_AUDIO_STATE_DISCONNECTED);
356             Transition(HfpHfStateMachine::CONNECTED);
357             break;
358         case HFP_HF_DISCONNECTED_EVT:
359             stateMachine_.AddDeferredMessage(event);
360             stateMachine_.NotifyChildStateToParentState(HFP_HF_AUDIO_STATE_CONNECTING, HFP_HF_AUDIO_STATE_DISCONNECTED);
361             Transition(HfpHfStateMachine::CONNECTED);
362             break;
363         default:
364             return false;
365     }
366     return true;
367 }
368 
Entry()369 void HfpHfAudioDisconnecting::Entry()
370 {
371     stateMachine_.NotifyStateTransitions();
372     stateMachine_.StartConnectionTimer();
373 }
374 
Exit()375 void HfpHfAudioDisconnecting::Exit()
376 {
377     stateMachine_.StopConnectionTimer();
378 }
379 
Dispatch(const utility::Message & msg)380 bool HfpHfAudioDisconnecting::Dispatch(const utility::Message &msg)
381 {
382     HfpHfMessage &event = (HfpHfMessage &)msg;
383     LOG_DEBUG("[HFP HF]%{public}s():[AudioConnected][%{public}s]", __FUNCTION__,
384         HfpHfStateMachine::GetEventName(event.what_).c_str());
385     switch (event.what_) {
386         case HFP_HF_DISCONNECT_EVT:
387         case HFP_HF_CONNECT_AUDIO_EVT:
388         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
389         case HFP_HF_DISCONNECTED_EVT:
390             stateMachine_.AddDeferredMessage(event);
391             break;
392         case HFP_HF_AUDIO_CONNECTING_EVT:
393         case HFP_HF_DISCONNECT_AUDIO_EVT:
394         case HFP_HF_AUDIO_DISCONNECTING_EVT:
395         case HFP_HF_AUDIO_CONNECTED_EVT:
396         case HFP_HF_AUDIO_CONNECT_FAILED_EVT:
397             break;
398         case HFP_HF_AUDIO_DISCONNECTED_EVT:
399             stateMachine_.ProcessAudioDisconnected();
400             Transition(HfpHfStateMachine::CONNECTED);
401             break;
402         case HFP_HF_AUDIO_DISCONNECT_FAILED_EVT:
403         case HFP_HF_CONNECTION_TIMEOUT_EVT:
404             stateMachine_.NotifyChildStateToParentState(HFP_HF_AUDIO_STATE_DISCONNECTING, HFP_HF_AUDIO_STATE_CONNECTED);
405             Transition(HfpHfStateMachine::AUDIO_CONNECTED);
406             break;
407         default:
408             return false;
409     }
410     return true;
411 }
412 
Entry()413 void HfpHfAudioConnected::Entry()
414 {
415     stateMachine_.ProcessDeferredMessage();
416     stateMachine_.NotifyStateTransitions();
417 }
418 
Dispatch(const utility::Message & msg)419 bool HfpHfAudioConnected::Dispatch(const utility::Message &msg)
420 {
421     HfpHfMessage &event = (HfpHfMessage &)msg;
422     LOG_DEBUG("[HFP HF]%{public}s():[AudioConnected][%{public}s]", __FUNCTION__,
423         HfpHfStateMachine::GetEventName(event.what_).c_str());
424     switch (event.what_) {
425         case HFP_HF_DISCONNECT_EVT:
426             ProcessDisconnect(event);
427             break;
428         case HFP_HF_DISCONNECTED_EVT:
429             stateMachine_.AddDeferredMessage(event);
430             break;
431         case HFP_HF_CONNECT_AUDIO_EVT:
432         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
433         case HFP_HF_AUDIO_CONNECTING_EVT:
434         case HFP_HF_AUDIO_CONNECTED_EVT:
435             break;
436         case HFP_HF_AUDIO_DISCONNECTING_EVT:
437             Transition(HfpHfStateMachine::AUDIO_DISCONNECTING);
438             break;
439         case HFP_HF_DISCONNECT_AUDIO_EVT:
440             profile_.ReleaseAudioConnection();
441             break;
442         case HFP_HF_AUDIO_DISCONNECTED_EVT:
443             stateMachine_.ProcessAudioDisconnected();
444             Transition(HfpHfStateMachine::CONNECTED);
445             break;
446         default:
447             return false;
448     }
449     return true;
450 }
451 
ProcessDisconnect(const HfpHfMessage & event)452 void HfpHfAudioConnected::ProcessDisconnect(const HfpHfMessage &event)
453 {
454     profile_.ReleaseAudioConnection();
455     stateMachine_.routeHfAudio(false);
456     stateMachine_.AddDeferredMessage(event);
457 }
458 
ProcessFinishCall(const HfpHfMessage & event)459 void HfpHfStateMachine::ProcessFinishCall(const HfpHfMessage &event)
460 {
461     if ((calls_->GetCallByState(HFP_HF_CALL_STATE_ACTIVE) != nullptr) ||
462         (calls_->GetCallByState(HFP_HF_CALL_STATE_DIALING) != nullptr) ||
463         (calls_->GetCallByState(HFP_HF_CALL_STATE_ALERTING) != nullptr)) {
464         LOG_DEBUG("[HFP HF]%{public}s():Finish active or dialing or alerting call", __FUNCTION__);
465         if (!profile_.SendChup()) {
466             LOG_ERROR("[HFP HF]%{public}s():Send CHUP failed", __FUNCTION__);
467         }
468     } else if (calls_->GetCallByState(HFP_HF_CALL_STATE_HELD) != nullptr) {
469         LOG_DEBUG("[HFP HF]%{public}s():Finish hold call", __FUNCTION__);
470         if (!profile_.SendChld(HFP_HF_CHLD_ACTION_0)) {
471             LOG_ERROR("[HFP HF]%{public}s():Send CHLD 0 failed", __FUNCTION__);
472         }
473     } else {
474         LOG_DEBUG("[HFP HF]%{public}s():no call to finish", __FUNCTION__);
475     }
476     return;
477 }
478 
ProcessDialCall(const HfpHfMessage & event)479 void HfpHfStateMachine::ProcessDialCall(const HfpHfMessage &event)
480 {
481     profile_.DialOutCall(event.calls_.GetNumber());
482 }
483 
ProcessOpenVoiceRecognition()484 void HfpHfStateMachine::ProcessOpenVoiceRecognition()
485 {
486     if (GetOpenVoiceRecognitionState() == HFP_HF_VR_STATE_CLOSED) {
487         if (!profile_.OpenVoiceRecognition()) {
488             LOG_ERROR("[HFP HF]%{public}s():can't open the voice recognition!", __FUNCTION__);
489         }
490     }
491 }
492 
ProcessCloseVoiceRecognition()493 void HfpHfStateMachine::ProcessCloseVoiceRecognition()
494 {
495     if (GetOpenVoiceRecognitionState() == HFP_HF_VR_STATE_OPENED) {
496         if (!profile_.CloseVoiceRecognition()) {
497             LOG_ERROR("[HFP HF]%{public}s():can't close the voice recognition!", __FUNCTION__);
498         }
499     }
500 }
501 
ProcessRejectCall()502 void HfpHfStateMachine::ProcessRejectCall()
503 {
504     if (calls_->GetCallByState(HFP_HF_CALL_STATE_INCOMING) != nullptr) {
505         LOG_DEBUG("[HFP HF]%{public}s():Reject incoming call", __FUNCTION__);
506         if (!profile_.SendChup()) {
507             LOG_ERROR("[HFP HF]%{public}s():Send CHUP failed", __FUNCTION__);
508         }
509     } else if ((calls_->GetCallByState(HFP_HF_CALL_STATE_HELD) != nullptr) ||
510                (calls_->GetCallByState(HFP_HF_CALL_STATE_WAITING) != nullptr)) {
511         LOG_DEBUG("[HFP HF]%{public}s():Reject held or waiting call", __FUNCTION__);
512         if (!profile_.SendChld(HFP_HF_CHLD_ACTION_0)) {
513             LOG_ERROR("[HFP HF]%{public}s():Send CHLD 0 failed", __FUNCTION__);
514         }
515     } else {
516         LOG_DEBUG("[HFP HF]%{public}s():No call to reject", __FUNCTION__);
517     }
518     return;
519 }
520 
PrecessSendKeyPressed()521 void HfpHfStateMachine::PrecessSendKeyPressed()
522 {
523     LOG_INFO("[HFP HF]%{public}s():enter", __FUNCTION__);
524     if (!profile_.SendKeyPressed()) {
525         LOG_ERROR("[HFP HF]%{public}s():PrecessSendKeyPressed failed", __FUNCTION__);
526     }
527 }
528 
ProcessHandleIncomingCall(int flag)529 void HfpHfStateMachine::ProcessHandleIncomingCall(int flag)
530 {
531     HILOGI("[HFP HF]:handle incoming call flag = %{public}d", flag);
532     if (calls_->GetCallByState(HFP_HF_CALL_STATE_INCOMING) != nullptr) {
533         if (flag != static_cast<int>(HfpHfHandleIncomingCalAction::HFP_HF_HOLD_INCOMING_ACTION)) {
534             HILOGE("[HFP HF]:No incoming call hold");
535         }
536         if (profile_.SendBtrh(flag)) {
537             HILOGE("[HFP HF]:Send BTRH = %{public}d failed", flag);
538         }
539     } else if (calls_->GetCallByState(HFP_HF_CALL_STATE_RESPONSE_HELD) != nullptr) {
540         if (!profile_.SendBtrh(flag)) {
541             HILOGE("[HFP HF]:Send BTRH = %{public}d failed", flag);
542         }
543     } else {
544         HILOGI("[HFP HF]:No call handle");
545     }
546     return;
547 }
548 
ProcessHandleMultiCall(int flag,int index)549 void HfpHfStateMachine::ProcessHandleMultiCall(int flag, int index)
550 {
551     HILOGI("[HFP HF]:enter flag = %{public}d, index = %{public}d", flag, index);
552     if (!profile_.SendChld(flag, index)) {
553             HILOGE("[HFP HF]:Send CHLD failed");
554     }
555 }
556 
ProcessDialLastNumber()557 void HfpHfStateMachine::ProcessDialLastNumber()
558 {
559     HILOGI("[HFP HF]:enter");
560     if (!profile_.CallLastDialedNumber()) {
561             HILOGE("[HFP HF]:ProcessDialLastNumber failed");
562     }
563 }
564 
ProcessDialMemory(int index)565 void HfpHfStateMachine::ProcessDialMemory(int index)
566 {
567     HILOGI("[HFP HF]:enter index = %{public}d", index);
568     if (!profile_.DialMemory(index)) {
569             HILOGE("[HFP HF]:ProcessDialMemory failed");
570     }
571 }
572 
ProcessSendVoiceTag(int index)573 void HfpHfStateMachine::ProcessSendVoiceTag(int index)
574 {
575     LOG_INFO("[HFP HF]%{public}s():enter index = %{public}d", __FUNCTION__, index);
576     if (!profile_.SendVoiceTag(index)) {
577             LOG_ERROR("[HFP HF]%{public}s():ProcessSendVoiceTag failed", __FUNCTION__);
578     }
579 }
580 
ProcessHoldCall()581 void HfpHfStateMachine::ProcessHoldCall()
582 {
583     if (calls_->GetCallByState(HFP_HF_CALL_STATE_ACTIVE) != nullptr) {
584         LOG_DEBUG("[HFP HF]%{public}s():Hold active call", __FUNCTION__);
585         if (!profile_.SendChld(HFP_HF_CHLD_ACTION_2)) {
586             LOG_ERROR("[HFP HF]%{public}s():Send CHLD 2 failed", __FUNCTION__);
587         }
588     } else {
589         LOG_DEBUG("[HFP HF]%{public}s():No call to hold", __FUNCTION__);
590     }
591     return;
592 }
593 
ProcessAcceptCall(int flag)594 void HfpHfStateMachine::ProcessAcceptCall(int flag)
595 {
596     if (calls_->GetCallByState(HFP_HF_CALL_STATE_INCOMING) != nullptr) {
597         if (flag != HFP_HF_ACCEPT_CALL_ACTION_NONE) {
598             return;
599         }
600 
601         LOG_DEBUG("[HFP HF]%{public}s():Accept incoming call", __FUNCTION__);
602         if (!profile_.SendAta()) {
603             LOG_ERROR("[HFP HF]%{public}s():Send ATA failed", __FUNCTION__);
604         }
605     } else if (calls_->GetCallByState(HFP_HF_CALL_STATE_WAITING) != nullptr) {
606         if ((calls_->GetCallByState(HFP_HF_CALL_STATE_ACTIVE) == nullptr) && (flag != HFP_HF_ACCEPT_CALL_ACTION_NONE)) {
607             return;
608         }
609 
610         int action;
611         if ((flag == HFP_HF_ACCEPT_CALL_ACTION_NONE) || (flag == HFP_HF_ACCEPT_CALL_ACTION_HOLD)) {
612             action = HFP_HF_CHLD_ACTION_2;
613         } else if (flag == HFP_HF_ACCEPT_CALL_ACTION_FINISH) {
614             action = HFP_HF_CHLD_ACTION_1;
615         } else {
616             LOG_ERROR("[HFP HF]%{public}s():Invalid flag[%{public}d]", __FUNCTION__, flag);
617             return;
618         }
619 
620         LOG_DEBUG("[HFP HF]%{public}s():Accept waiting call", __FUNCTION__);
621         if (!profile_.SendChld(action)) {
622             LOG_ERROR("[HFP HF]%{public}s():Send CHLD[%{public}d] failed", __FUNCTION__, action);
623         }
624     } else if (calls_->GetCallByState(HFP_HF_CALL_STATE_HELD) != nullptr) {
625         int action = HFP_HF_CHLD_ACTION_2;
626         if (flag == HFP_HF_ACCEPT_CALL_ACTION_FINISH) {
627             action = HFP_HF_CHLD_ACTION_1;
628         } else if ((flag == HFP_HF_ACCEPT_CALL_ACTION_NONE) || (flag == HFP_HF_ACCEPT_CALL_ACTION_HOLD)) {
629             action = HFP_HF_CHLD_ACTION_2;
630         } else if (calls_->GetCallByState(HFP_HF_CALL_STATE_ACTIVE) != nullptr) {
631             action = HFP_HF_CHLD_ACTION_3;
632         }
633 
634         LOG_DEBUG("[HFP HF]%{public}s():Accept held call", __FUNCTION__);
635         if (!profile_.SendChld(action)) {
636             LOG_ERROR("[HFP HF]%{public}s():Send CHLD[%{public}d] failed", __FUNCTION__, action);
637         }
638     } else {
639         LOG_DEBUG("[HFP HF]%{public}s():No call to accept", __FUNCTION__);
640     }
641 
642     if (flag == HFP_HF_ACCEPT_CALL_ACTION_HOLD) {
643         routeHfAudio(true);
644     }
645     return;
646 }
647 
ProcessInteractiveEvent(const HfpHfMessage & event)648 void HfpHfStateMachine::ProcessInteractiveEvent(const HfpHfMessage &event)
649 {
650     LOG_DEBUG("[HFP HF]%{public}s():[%{public}s]", __FUNCTION__, GetInteractiveEventType(event.type_).c_str());
651     switch (event.type_) {
652         case HFP_HF_TYPE_NETWORK_STATE:
653             ProcessNetworkStateEvent(event);
654             break;
655         case HFP_HF_TYPE_NETWORK_ROAM:
656             ProcessNetworkRoamEvent(event);
657             break;
658         case HFP_HF_TYPE_NETWORK_SIGNAL:
659             ProcessNetworkSignalEvent(event);
660             break;
661         case HFP_HF_TYPE_BATTERY_LEVEL:
662             ProcessBatteryLevelEvent(event);
663             break;
664         case HFP_HF_TYPE_CURRENT_OPERATOR:
665             ProcessOperatorEvent(event);
666             break;
667         case HFP_HF_TYPE_CALL_STATE:
668         case HFP_HF_TYPE_CALL_SETUP_STATE:
669         case HFP_HF_TYPE_CALL_HELD_STATE:
670         case HFP_HF_TYPE_HOLD_RESULT:
671         case HFP_HF_TYPE_CALLING_LINE_IDENTIFICATION:
672         case HFP_HF_TYPE_CALL_WAITING:
673             ProcessCallIndicatorEvent(event);
674             break;
675         case HFP_HF_TYPE_CURRENT_CALLS:
676             ProcessCurrentCallEvent(event);
677             break;
678         case HFP_HF_TYPE_SET_VOLUME:
679             ProcessSetVolumeEvent(event);
680             break;
681         case HFP_HF_TYPE_SUBSCRIBER_NUMBER:
682             ProcessSubscriberNumberEvent(event);
683             break;
684         case HFP_HF_TYPE_INBAND_RING:
685             ProcessInbandRingEvent(event);
686             break;
687         case HFP_HF_TYPE_QUERY_CURRENT_CALLS_DONE:
688             calls_->UpdateCallDone();
689             break;
690         case HFP_HF_TYPE_VOICE_RECOGNITION_CHANGED:
691             ProcessVrChangedEvent(event);
692             break;
693         case HFP_HF_TYPE_OPEN_VR_RESULT:
694             ProcessOpenVrResultEvent(event);
695             break;
696         case HFP_HF_TYPE_CLOSE_VR_RESULT:
697             ProcessCloseVrResultEvent(event);
698             break;
699         default:
700             break;
701     }
702 }
703 
NotifyStateTransitions()704 void HfpHfStateMachine::NotifyStateTransitions()
705 {
706     HfpHfService *service = HfpHfService::GetService();
707     int toState = GetDeviceStateInt();
708     if (service != nullptr) {
709         RawAddress device(address_);
710         if ((preState_ != toState) && (preState_ <= HFP_HF_STATE_CONNECTED) && (toState <= HFP_HF_STATE_CONNECTED)) {
711             service->NotifyStateChanged(device, toState);
712         }
713 
714         if ((preState_ != toState) && (preState_ >= HFP_HF_AUDIO_STATE_DISCONNECTED) &&
715             (toState >= HFP_HF_AUDIO_STATE_DISCONNECTED)) {
716             service->NotifyScoStateChanged(device, toState);
717         }
718     }
719 
720     if (toState == HFP_HF_AUDIO_STATE_CONNECTED) {
721         SyncScoEvents(toState);
722     }
723 
724     preState_ = toState;
725 }
726 
NotifyChildStateToParentState(int fromState,int toState)727 void HfpHfStateMachine::NotifyChildStateToParentState(int fromState, int toState)
728 {
729     HfpHfService *service = HfpHfService::GetService();
730     if (service != nullptr) {
731         if ((fromState != toState) && (fromState >= HFP_HF_AUDIO_STATE_DISCONNECTED) &&
732             (toState >= HFP_HF_AUDIO_STATE_DISCONNECTED)) {
733             RawAddress device(address_);
734             service->NotifyScoStateChanged(device, toState);
735         }
736     }
737 
738     if (toState == HFP_HF_AUDIO_STATE_DISCONNECTED) {
739         SyncScoEvents(toState);
740     }
741 
742     preState_ = toState;
743     ProcessDeferredMessage();
744 }
745 
ProcessAudioDisconnected()746 void HfpHfStateMachine::ProcessAudioDisconnected()
747 {
748     IPowerManager::GetInstance().StatusUpdate(RequestStatus::SCO_OFF, PROFILE_NAME_HFP_HF, RawAddress(address_));
749     NotifyChildStateToParentState(HFP_HF_AUDIO_STATE_CONNECTED, HFP_HF_AUDIO_STATE_DISCONNECTED);
750 }
751 
SyncScoEvents(int state)752 void HfpHfStateMachine::SyncScoEvents(int state)
753 {
754     if (state == HFP_HF_AUDIO_STATE_CONNECTED) {
755         int spkVolume = OHOS::AudioStandard::AudioSystemManager::GetInstance()->GetVolume(
756             OHOS::AudioStandard::STREAM_VOICE_CALL);
757         int micVolume = OHOS::AudioStandard::AudioSystemManager::GetInstance()->GetVolume(
758             OHOS::AudioStandard::STREAM_VOICE_CALL);
759         profile_.SetHfVolume(spkVolume, HFP_HF_VOLUME_TYPE_SPK);
760         profile_.SetHfVolume(micVolume, HFP_HF_VOLUME_TYPE_MIC);
761 
762         routeHfAudio(true);
763         OHOS::AudioStandard::AudioSystemManager::GetInstance()->SetAudioParameter(
764             "hfp_volume", std::to_string(spkVolume));
765     }
766 
767     if (state == HFP_HF_AUDIO_STATE_DISCONNECTED) {
768         routeHfAudio(false);
769         if (voiceRecognitionStatus_ == HFP_HF_VR_STATE_OPENED) {
770             NotifyVoiceRecognitionStatusChanged(HFP_HF_VR_STATE_CLOSED);
771         }
772     }
773 }
774 
GetOpenVoiceRecognitionState() const775 int HfpHfStateMachine::GetOpenVoiceRecognitionState() const
776 {
777     return voiceRecognitionStatus_;
778 }
779 
GetIsInbandRing() const780 bool HfpHfStateMachine::GetIsInbandRing() const
781 {
782     return isInBandRing_;
783 }
784 
GetVolume() const785 int HfpHfStateMachine::GetVolume() const
786 {
787     return volume_;
788 }
789 
GetDeviceStateInt() const790 int HfpHfStateMachine::GetDeviceStateInt() const
791 {
792     return static_cast<const HfpHfState*>(GetState())->GetStateInt();
793 }
794 
GetCurrentCallList()795 std::vector<HandsFreeUnitCalls> HfpHfStateMachine::GetCurrentCallList()
796 {
797     return calls_->GetCurrentCalls();
798 }
799 
AddDeferredMessage(const HfpHfMessage & msg)800 void HfpHfStateMachine::AddDeferredMessage(const HfpHfMessage &msg)
801 {
802     deferMsgs_.push_back(msg);
803 }
804 
ProcessDeferredMessage()805 void HfpHfStateMachine::ProcessDeferredMessage()
806 {
807     auto size = deferMsgs_.size();
808     while (size-- > 0 && !deferMsgs_.empty()) {
809         HfpHfMessage event = deferMsgs_.front();
810         deferMsgs_.pop_front();
811         HfpHfService::GetService()->PostEvent(event);
812     }
813 }
814 
StartConnectionTimer() const815 void HfpHfStateMachine::StartConnectionTimer() const
816 {
817     connTimer_->Start(CONNECTION_TIMEOUT_MS);
818     LOG_INFO("[HFP HF]%{public}s():Start connection timer!", __FUNCTION__);
819 }
820 
StopConnectionTimer() const821 void HfpHfStateMachine::StopConnectionTimer() const
822 {
823     connTimer_->Stop();
824     LOG_INFO("[HFP HF]%{public}s():Stop connection timer!", __FUNCTION__);
825 }
826 
ConnectionTimeout() const827 void HfpHfStateMachine::ConnectionTimeout() const
828 {
829     HfpHfMessage event(HFP_HF_CONNECTION_TIMEOUT_EVT);
830     event.dev_ = address_;
831     HfpHfService::GetService()->PostEvent(event);
832 }
833 
IsRemoving() const834 bool HfpHfStateMachine::IsRemoving() const
835 {
836     return isRemoving_;
837 }
838 
SetRemoving(bool isRemoving)839 void HfpHfStateMachine::SetRemoving(bool isRemoving)
840 {
841     isRemoving_ = isRemoving;
842 }
843 
ProcessNetworkStateEvent(const HfpHfMessage & event)844 void HfpHfStateMachine::ProcessNetworkStateEvent(const HfpHfMessage &event)
845 {
846     HfpHfService *service = HfpHfService::GetService();
847     RawAddress rawAddress(address_);
848     if (networkState_ != event.arg1_) {
849         networkState_ = event.arg1_;
850         service->NotifyRegistrationStatusChanged(rawAddress, networkState_);
851     }
852 
853     if (networkState_ == HFP_HF_NETWORK_STATE_AVAILABLE) {
854         if (!profile_.QueryOperatorName(true)) {
855             LOG_ERROR("[HFP HF]%{public}s():can't query the operator name!", __FUNCTION__);
856         }
857     }
858 }
ProcessNetworkRoamEvent(const HfpHfMessage & event)859 void HfpHfStateMachine::ProcessNetworkRoamEvent(const HfpHfMessage &event)
860 {
861     HfpHfService *service = HfpHfService::GetService();
862     RawAddress rawAddress(address_);
863     if (networkTRoam_ != event.arg1_) {
864         networkTRoam_ = event.arg1_;
865         service->NotifyRoamingStatusChanged(rawAddress, networkTRoam_);
866     }
867 }
ProcessNetworkSignalEvent(const HfpHfMessage & event)868 void HfpHfStateMachine::ProcessNetworkSignalEvent(const HfpHfMessage &event)
869 {
870     HfpHfService *service = HfpHfService::GetService();
871     RawAddress rawAddress(address_);
872     if (networkSignal_ != event.arg1_) {
873         networkSignal_ = event.arg1_;
874         service->NotifySignalStrengthChanged(rawAddress, networkSignal_);
875     }
876 }
ProcessBatteryLevelEvent(const HfpHfMessage & event)877 void HfpHfStateMachine::ProcessBatteryLevelEvent(const HfpHfMessage &event)
878 {
879     HfpHfService *service = HfpHfService::GetService();
880     RawAddress rawAddress(address_);
881     if (batteryLevel_ != event.arg1_) {
882         batteryLevel_ = event.arg1_;
883         service->NotifyBatteryLevelChanged(rawAddress, batteryLevel_);
884     }
885 }
886 
ProcessOperatorEvent(const HfpHfMessage & event)887 void HfpHfStateMachine::ProcessOperatorEvent(const HfpHfMessage &event)
888 {
889     HfpHfService *service = HfpHfService::GetService();
890     RawAddress rawAddress(address_);
891     if (operatorName_ != event.str_) {
892         operatorName_ = event.str_;
893         service->NotifyOperatorSelectionChanged(rawAddress, operatorName_);
894     }
895 }
896 
ProcessCallIndicatorEvent(const HfpHfMessage & event)897 void HfpHfStateMachine::ProcessCallIndicatorEvent(const HfpHfMessage &event)
898 {
899     if (!profile_.QueryCurrentCalls()) {
900         LOG_ERROR("[HFP HF]%{public}s():can't query the current calls!", __FUNCTION__);
901     }
902 }
903 
ProcessCurrentCallEvent(const HfpHfMessage & event) const904 void HfpHfStateMachine::ProcessCurrentCallEvent(const HfpHfMessage &event) const
905 {
906     HandsFreeUnitCalls call(address_,
907         event.call_.index,
908         event.call_.status,
909         event.call_.number,
910         (event.call_.mprty == HFP_HF_MPTY_TYPE_MULTI),
911         (event.call_.dir == HFP_HF_DIRECTION_TYPE_OUTGOING),
912         isInBandRing_);
913     calls_->UpdateCall(call);
914 }
915 
ProcessSetVolumeEvent(const HfpHfMessage & event) const916 void HfpHfStateMachine::ProcessSetVolumeEvent(const HfpHfMessage &event) const
917 {
918     if (event.arg1_ == HFP_HF_VOLUME_TYPE_SPK) {
919         OHOS::AudioStandard::AudioSystemManager::GetInstance()->SetVolume(
920             OHOS::AudioStandard::STREAM_VOICE_CALL, event.arg3_);
921     } else if (event.arg1_ == HFP_HF_VOLUME_TYPE_MIC) {
922         OHOS::AudioStandard::AudioSystemManager::GetInstance()->SetMicrophoneMute(event.arg3_ == 0);
923     } else {
924         LOG_ERROR("[HFP HF]%{public}s():the error volume type!", __FUNCTION__);
925     }
926 }
927 
ProcessSubscriberNumberEvent(const HfpHfMessage & event)928 void HfpHfStateMachine::ProcessSubscriberNumberEvent(const HfpHfMessage &event)
929 {
930     HfpHfService *service = HfpHfService::GetService();
931     RawAddress rawAddress(address_);
932     if (subscriberNumber_ != event.str_) {
933         subscriberNumber_ = event.str_;
934         if (service != nullptr) {
935             service->NotifySubscriberNumberChanged(rawAddress, subscriberNumber_);
936         } else {
937             LOG_DEBUG("[HFP HF]%{public}s():service is null.", __FUNCTION__);
938         }
939     }
940 }
ProcessInbandRingEvent(const HfpHfMessage & event)941 void HfpHfStateMachine::ProcessInbandRingEvent(const HfpHfMessage &event)
942 {
943     HfpHfService *service = HfpHfService::GetService();
944     RawAddress rawAddress(address_);
945     bool ring = (event.arg1_ == 0) ? false : true;
946     bool isFirstTime = (event.arg3_ == 0) ? false : true;
947     if (isInBandRing_ != ring || isFirstTime == true) {
948         isInBandRing_ = ring;
949         service->NotifyInBandRingTone(rawAddress, event.arg1_);
950     }
951 }
952 
NotifyVoiceRecognitionStatusChanged(int status)953 void HfpHfStateMachine::NotifyVoiceRecognitionStatusChanged(int status)
954 {
955     if (status == voiceRecognitionStatus_) {
956         return;
957     }
958     voiceRecognitionStatus_ = status;
959     HfpHfService *service = HfpHfService::GetService();
960     if (service != nullptr) {
961         RawAddress device(address_);
962         service->NotifyVoiceRecognitionStatusChanged(device, voiceRecognitionStatus_);
963     }
964 }
965 
routeHfAudio(bool state)966 void HfpHfStateMachine::routeHfAudio(bool state)
967 {
968     if (state) {
969         if (!isAudioRouted_) {
970             OHOS::AudioStandard::AudioSystemManager::GetInstance()->SetAudioParameter("hfp_enable", "true");
971         }
972     } else {
973         OHOS::AudioStandard::AudioSystemManager::GetInstance()->SetAudioParameter("hfp_enable", "false");
974     }
975     isAudioRouted_ = state;
976 }
977 
ProcessVrChangedEvent(const HfpHfMessage & event)978 void HfpHfStateMachine::ProcessVrChangedEvent(const HfpHfMessage &event)
979 {
980     NotifyVoiceRecognitionStatusChanged(event.arg1_);
981 }
982 
ProcessOpenVrResultEvent(const HfpHfMessage & event)983 void HfpHfStateMachine::ProcessOpenVrResultEvent(const HfpHfMessage &event)
984 {
985     int status = voiceRecognitionStatus_;
986     if (event.arg1_ == HFP_HF_AT_RESULT_OK) {
987         status = HFP_HF_VR_STATE_OPENED;
988     }
989 
990     NotifyVoiceRecognitionStatusChanged(status);
991 }
992 
ProcessCloseVrResultEvent(const HfpHfMessage & event)993 void HfpHfStateMachine::ProcessCloseVrResultEvent(const HfpHfMessage &event)
994 {
995     int status = voiceRecognitionStatus_;
996     if (event.arg1_ == HFP_HF_AT_RESULT_OK) {
997         status = HFP_HF_VR_STATE_CLOSED;
998     }
999 
1000     NotifyVoiceRecognitionStatusChanged(status);
1001 }
1002 
GetEventName(int what)1003 std::string HfpHfStateMachine::GetEventName(int what)
1004 {
1005     switch (what) {
1006         case HFP_HF_INVALID_EVT:
1007             return "HFP_HF_INVALID_EVT";
1008         case HFP_HF_SERVICE_STARTUP_EVT:
1009             return "HFP_HF_SERVICE_STARTUP_EVT";
1010         case HFP_HF_SERVICE_SHUTDOWN_EVT:
1011             return "HFP_HF_SERVICE_SHUTDOWN_EVT";
1012         case HFP_HF_CONNECT_EVT:
1013             return "HFP_HF_CONNECT_EVT";
1014         case HFP_HF_DISCONNECT_EVT:
1015             return "HFP_HF_DISCONNECT_EVT";
1016         case HFP_HF_CONNECT_AUDIO_EVT:
1017             return "HFP_HF_CONNECT_AUDIO_EVT";
1018         case HFP_HF_DISCONNECT_AUDIO_EVT:
1019             return "HFP_HF_DISCONNECT_AUDIO_EVT";
1020         case HFP_HF_RETRY_CONNECT_AUDIO_EVT:
1021             return "HFP_HF_RETRY_CONNECT_AUDIO_EVT";
1022         case HFP_HF_REMOVE_STATE_MACHINE_EVT:
1023             return "HFP_HF_REMOVE_STATE_MACHINE_EVT";
1024         case HFP_HF_INTERACTIVE_EVT:
1025             return "HFP_HF_INTERACTIVE_EVT";
1026         case HFP_HF_CONNECTION_TIMEOUT_EVT:
1027             return "HFP_HF_CONNECTION_TIMEOUT_EVT";
1028         case HFP_HF_DISCONNECT_TIMEOUT_EVT:
1029             return "HFP_HF_DISCONNECT_TIMEOUT_EVT";
1030         case HFP_HF_CONNECT_AUDIO_TIMEOUT_EVT:
1031             return "HFP_HF_CONNECT_AUDIO_TIMEOUT_EVT";
1032         case HFP_HF_DISCONNECT_AUDIO_TIMEOUT_EVT:
1033             return "HFP_HF_DISCONNECT_AUDIO_TIMEOUT_EVT";
1034         case HFP_HF_SEND_DTMF_EVT:
1035             return "HFP_HF_SEND_DTMF_EVT";
1036         case HFP_HF_ACCEPT_CALL_EVT:
1037             return "HFP_HF_ACCEPT_CALL_EVT";
1038         case HFP_HF_HOLD_CALL_EVT:
1039             return "HFP_HF_HOLD_CALL_EVT";
1040         case HFP_HF_REJECT_CALL_EVT:
1041             return "HFP_HF_REJECT_CALL_EVT";
1042         case HFP_HF_HANDLE_INCOMING_CALL_EVT:
1043             return "HFP_HF_HANDLE_INCOMING_CALL_EVT";
1044         case HFP_HF_HANDLE_MULTI_CALL_EVT:
1045             return "HFP_HF_HANDLE_MULTI_CALL_EVT";
1046         case HFP_HF_DIAL_LAST_NUMBER:
1047             return "HFP_HF_DIAL_LAST_NUMBER";
1048         case HFP_HF_DIAL_MEMORY:
1049             return "HFP_HF_DIAL_MEMORY";
1050         case HFP_HF_FINISH_CALL_EVT:
1051             return "HFP_HF_FINISH_CALL_EVT";
1052         case HFP_HF_DIAL_CALL_EVT:
1053             return "HFP_HF_DIAL_CALL_EVT";
1054         case HFP_HF_OPEN_VOICE_RECOGNITION_EVT:
1055             return "HFP_HF_OPEN_VOICE_RECOGNITION_EVT";
1056         case HFP_HF_CLOSE_VOICE_RECOGNITION_EVT:
1057             return "HFP_HF_CLOSE_VOICE_RECOGNITION_EVT";
1058         case HFP_HF_SET_VOLUME_EVT:
1059             return "HFP_HF_SET_VOLUME_EVT";
1060         case HFP_HF_BATTERY_LEVEL_CHANGED_EVT:
1061             return "HFP_HF_BATTERY_LEVEL_CHANGED_EVT";
1062         case HFP_HF_ENHANCED_DRIVER_SAFETY_CHANGED_EVT:
1063             return "HFP_HF_ENHANCED_DRIVER_SAFETY_CHANGED_EVT";
1064         case HFP_HF_SDP_DISCOVERY_RESULT_SUCCESS:
1065             return "HFP_HF_SDP_DISCOVERY_RESULT_SUCCESS";
1066         case HFP_HF_SDP_DISCOVERY_RESULT_FAIL:
1067             return "HFP_HF_SDP_DISCOVERY_RESULT_FAIL";
1068         case HFP_HF_CONNECT_REQUEST_EVT:
1069             return "HFP_HF_CONNECT_REQUEST_EVT";
1070         case HFP_HF_CONNECTED_EVT:
1071             return "HFP_HF_CONNECTED_EVT";
1072         case HFP_HF_DISCONNECTED_EVT:
1073             return "HFP_HF_DISCONNECTED_EVT";
1074         case HFP_HF_CONNECT_FAILED_EVT:
1075             return "HFP_HF_CONNECT_FAILED_EVT";
1076         case HFP_HF_DISCONNECT_FAILED_EVT:
1077             return "HFP_HF_DISCONNECT_FAILED_EVT";
1078         case HFP_HF_DATA_AVAILABLE_EVT:
1079             return "HFP_HF_DATA_AVAILABLE_EVT";
1080         case HFP_HF_SLC_ESTABLISHED_EVT:
1081             return "HFP_HF_SLC_ESTABLISHED_EVT";
1082         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
1083             return "HFP_HF_AUDIO_CONNECT_REQUEST_EVT";
1084         case HFP_HF_AUDIO_CONNECTING_EVT:
1085             return "HFP_HF_AUDIO_CONNECTING_EVT";
1086         case HFP_HF_AUDIO_DISCONNECTING_EVT:
1087             return "HFP_HF_AUDIO_DISCONNECTING_EVT";
1088         case HFP_HF_AUDIO_CONNECTED_EVT:
1089             return "HFP_HF_AUDIO_CONNECTED_EVT";
1090         case HFP_HF_AUDIO_CONNECT_FAILED_EVT:
1091             return "HFP_HF_AUDIO_CONNECT_FAILED_EVT";
1092         case HFP_HF_AUDIO_DISCONNECTED_EVT:
1093             return "HFP_HF_AUDIO_DISCONNECTED_EVT";
1094         case HFP_HF_AUDIO_DISCONNECT_FAILED_EVT:
1095             return "HFP_HF_AUDIO_DISCONNECT_FAILED_EVT";
1096         case HFP_HF_SEND_AT_COMMAND_EVT:
1097             return "HFP_HF_SEND_AT_COMMAND_EVT";
1098         default:
1099             return "Unknown";
1100     }
1101 }
1102 
GetInteractiveEventType(int type) const1103 std::string HfpHfStateMachine::GetInteractiveEventType(int type) const
1104 {
1105     switch (type) {
1106         case HFP_HF_TYPE_NONE:
1107             return "HFP_HF_TYPE_NONE";
1108         case HFP_HF_TYPE_NETWORK_STATE:
1109             return "HFP_HF_TYPE_NETWORK_STATE";
1110         case HFP_HF_TYPE_NETWORK_ROAM:
1111             return "HFP_HF_TYPE_NETWORK_ROAM";
1112         case HFP_HF_TYPE_NETWORK_SIGNAL:
1113             return "HFP_HF_TYPE_NETWORK_SIGNAL";
1114         case HFP_HF_TYPE_BATTERY_LEVEL:
1115             return "HFP_HF_TYPE_BATTERY_LEVEL";
1116         case HFP_HF_TYPE_CURRENT_OPERATOR:
1117             return "HFP_HF_TYPE_CURRENT_OPERATOR";
1118         case HFP_HF_TYPE_CALL_STATE:
1119             return "HFP_HF_TYPE_CALL_STATE";
1120         case HFP_HF_TYPE_CALL_SETUP_STATE:
1121             return "HFP_HF_TYPE_CALL_SETUP_STATE";
1122         case HFP_HF_TYPE_CALL_HELD_STATE:
1123             return "HFP_HF_TYPE_CALL_HELD_STATE";
1124         case HFP_HF_TYPE_HOLD_RESULT:
1125             return "HFP_HF_TYPE_HOLD_RESULT";
1126         case HFP_HF_TYPE_CALLING_LINE_IDENTIFICATION:
1127             return "HFP_HF_TYPE_CALLING_LINE_IDENTIFICATION";
1128         case HFP_HF_TYPE_CALL_WAITING:
1129             return "HFP_HF_TYPE_CALL_WAITING";
1130         case HFP_HF_TYPE_CURRENT_CALLS:
1131             return "HFP_HF_TYPE_CURRENT_CALLS";
1132         case HFP_HF_TYPE_SET_VOLUME:
1133             return "HFP_HF_TYPE_SET_VOLUME";
1134         case HFP_HF_TYPE_AT_CMD_RESULT:
1135             return "HFP_HF_TYPE_AT_CMD_RESULT";
1136         case HFP_HF_TYPE_SUBSCRIBER_NUMBER:
1137             return "HFP_HF_TYPE_SUBSCRIBER_NUMBER";
1138         case HFP_HF_TYPE_INBAND_RING:
1139             return "HFP_HF_TYPE_INBAND_RING";
1140         case HFP_HF_TYPE_LAST_NUMBER:
1141             return "HFP_HF_TYPE_LAST_NUMBER";
1142         case HFP_HF_TYPE_RING_ALERT:
1143             return "HFP_HF_TYPE_RING_ALERT";
1144         case HFP_HF_TYPE_UNKNOWN:
1145             return "HFP_HF_TYPE_UNKNOWN";
1146         case HFP_HF_TYPE_QUERY_CURRENT_CALLS_DONE:
1147             return "HFP_HF_TYPE_QUERY_CURRENT_CALLS_DONE";
1148         case HFP_HF_SETUP_CODEC_CVSD:
1149             return "HFP_HF_SETUP_CODEC_CVSD";
1150         case HFP_HF_SLC_ESTABLISHED_EVT:
1151             return "HFP_HF_SLC_ESTABLISHED_EVT";
1152         case HFP_HF_AUDIO_CONNECT_REQUEST_EVT:
1153             return "HFP_HF_AUDIO_CONNECT_REQUEST_EVT";
1154         default:
1155             return "Unknown";
1156     }
1157 }
1158 }  // namespace bluetooth
1159 }  // namespace OHOS
1160