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