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