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_ag_service.h"
17 
18 #include "adapter_config.h"
19 #include "bluetooth_errorcode.h"
20 #include "class_creator.h"
21 #include "adapter_manager.h"
22 #include "hfp_ag_defines.h"
23 #include "hfp_ag_system_interface.h"
24 #include "log_util.h"
25 #include "profile_service_manager.h"
26 #include "stub/telephone_service.h"
27 
28 namespace OHOS {
29 namespace bluetooth {
HfpAgService()30 HfpAgService::HfpAgService() : utility::Context(PROFILE_NAME_HFP_AG, "1.7.1")
31 {
32     LOG_INFO("[HFP AG]ProfileService:%{public}s Create", Name().c_str());
33 }
34 
~HfpAgService()35 HfpAgService::~HfpAgService()
36 {
37     LOG_INFO("[HFP AG]ProfileService:%{public}s Release", Name().c_str());
38 }
39 
GetContext()40 utility::Context *HfpAgService::GetContext()
41 {
42     return this;
43 }
44 
GetService()45 HfpAgService *HfpAgService::GetService()
46 {
47     auto servManager = IProfileManager::GetInstance();
48     return static_cast<HfpAgService *>(servManager->GetProfileService(PROFILE_NAME_HFP_AG));
49 }
50 
Enable()51 void HfpAgService::Enable()
52 {
53     LOG_INFO("[HFP AG]%{public}s():==========<enter>==========", __FUNCTION__);
54     HfpAgMessage event(HFP_AG_SERVICE_STARTUP_EVT);
55     PostEvent(event);
56 }
57 
Disable()58 void HfpAgService::Disable()
59 {
60     LOG_INFO("[HFP AG]%{public}s():==========<enter>==========", __FUNCTION__);
61     HfpAgMessage event(HFP_AG_SERVICE_SHUTDOWN_EVT);
62     PostEvent(event);
63 }
64 
StartUp()65 void HfpAgService::StartUp()
66 {
67     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
68     if (isStarted_ == true) {
69         GetContext()->OnEnable(PROFILE_NAME_HFP_AG, true);
70         LOG_WARN("[HFP AG]%{public}s():HfpAgService has already been started before.", __FUNCTION__);
71         return;
72     }
73 
74     maxConnectedNum_ = GetMaxConnectionDevicesNum();
75     HfpAgSystemEventProcesser::Start();
76     int ret = HfpAgProfile::RegisterService();
77     GetContext()->OnEnable(PROFILE_NAME_HFP_AG, ret ? false : true);
78     if (ret == 0) {
79         isStarted_ = true;
80         LOG_INFO("[HFP AG]%{public}s():HfpAgService started", __FUNCTION__);
81     }
82 }
83 
ShutDown()84 void HfpAgService::ShutDown()
85 {
86     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
87     if (isStarted_ == false) {
88         GetContext()->OnDisable(PROFILE_NAME_HFP_AG, true);
89         LOG_WARN("[HFP AG]%{public}s():HfpAgService has already been shutdown before.", __FUNCTION__);
90         return;
91     }
92 
93     isShuttingDown_ = true;
94     bool isDisconnected = false;
95     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
96         if ((it->second != nullptr) && (it->second->GetStateInt() > HFP_AG_STATE_DISCONNECTED)) {
97             Disconnect(RawAddress(it->first));
98             isDisconnected = true;
99         }
100     }
101 
102     if (!isDisconnected) {
103         ShutDownDone(true);
104     }
105 }
106 
ShutDownDone(bool isAllDisconnected)107 void HfpAgService::ShutDownDone(bool isAllDisconnected)
108 {
109     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
110     if (!isAllDisconnected) {
111         for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
112             if ((it->second != nullptr) && (it->second->GetStateInt() > HFP_AG_STATE_DISCONNECTED)) {
113                 return;
114             }
115         }
116     }
117 
118     stateMachines_.clear();
119     HfpAgSystemEventProcesser::Stop();
120     HfpAgProfile::SetActiveDevice(NULL_ADDRESS);
121 
122     isVrOpened_ = false;
123     isInbandRinging_ = false;
124     queryClccAddress_ = NULL_ADDRESS;
125     maxConnectedNum_ = MAX_DEFAULT_CONNECTIONS_NUM;
126 
127     if (dialingOutTimeout_ != nullptr) {
128         dialingOutTimeout_->Stop();
129         dialingOutTimeout_ = nullptr;
130     }
131 
132     if (ResponseClccTimeout_ != nullptr) {
133         ResponseClccTimeout_->Stop();
134         ResponseClccTimeout_ = nullptr;
135     }
136     if (voiceRecognitionTimeout_ != nullptr) {
137         voiceRecognitionTimeout_->Stop();
138         voiceRecognitionTimeout_ = nullptr;
139     }
140 
141     int ret = HfpAgProfile::DeregisterService();
142     GetContext()->OnDisable(PROFILE_NAME_HFP_AG, ret ? false : true);
143     if (ret == 0) {
144         isStarted_ = false;
145         LOG_INFO("[HFP AG]%{public}s():HfpAgService shutdown", __FUNCTION__);
146     }
147     isShuttingDown_ = false;
148 }
149 
Connect(const RawAddress & device)150 int HfpAgService::Connect(const RawAddress &device)
151 {
152     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
153     std::lock_guard<std::recursive_mutex> lk(mutex_);
154     auto classicService = IAdapterManager::GetInstance()->GetClassicAdapterInterface();
155     if (!classicService || !(classicService->IsHfpCodSupported(device))) {
156         LOG_ERROR("[HFP AG]%{public}s():Not Support HFP!", __FUNCTION__);
157         return Bluetooth::BT_ERR_INTERNAL_ERROR;
158     }
159 
160     std::string address = device.GetAddress();
161     auto it = stateMachines_.find(address);
162     if ((it != stateMachines_.end()) && (it->second != nullptr)) {
163         int state = it->second->GetStateInt();
164         if ((state >= HFP_AG_STATE_CONNECTED) || (state == HFP_AG_STATE_CONNECTING)) {
165             LOG_INFO("[HFP AG]%{public}s():state:%{public}d", __FUNCTION__, state);
166             return Bluetooth::BT_ERR_INTERNAL_ERROR;
167         }
168     }
169 
170     int size = GetConnectedDeviceNum();
171     if (size >= maxConnectedNum_) {
172         LOG_INFO("[HFP AG]%{public}s():Max connection has reached!", __FUNCTION__);
173         return Bluetooth::BT_ERR_INTERNAL_ERROR;
174     }
175     HfpAgMessage event(HFP_AG_CONNECT_EVT);
176     event.dev_ = address;
177     PostEvent(event);
178     return HFP_AG_SUCCESS;
179 }
180 
Disconnect(const RawAddress & device)181 int HfpAgService::Disconnect(const RawAddress &device)
182 {
183     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
184     std::lock_guard<std::recursive_mutex> lk(mutex_);
185     std::string address = device.GetAddress();
186     auto it = stateMachines_.find(address);
187     if (it == stateMachines_.end() || it->second == nullptr) {
188         return Bluetooth::BT_ERR_INTERNAL_ERROR;
189     }
190 
191     int slcState = it->second->GetStateInt();
192     if ((slcState != HFP_AG_STATE_CONNECTING) && (slcState < HFP_AG_STATE_CONNECTED)) {
193         return Bluetooth::BT_ERR_INTERNAL_ERROR;
194     }
195 
196     HfpAgMessage event(HFP_AG_DISCONNECT_EVT);
197     event.dev_ = address;
198     PostEvent(event);
199     return HFP_AG_SUCCESS;
200 }
201 
GetConnectDevices()202 std::list<RawAddress> HfpAgService::GetConnectDevices()
203 {
204     std::lock_guard<std::recursive_mutex> lk(mutex_);
205     std::list<RawAddress> devList;
206     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
207         if ((it->second != nullptr) && (it->second->GetStateInt() >= HFP_AG_STATE_CONNECTED)) {
208             devList.push_back(RawAddress(it->first));
209         }
210     }
211     return devList;
212 }
213 
GetConnectState()214 int HfpAgService::GetConnectState()
215 {
216     std::lock_guard<std::recursive_mutex> lk(mutex_);
217     int result = 0;
218     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
219         if (it->second == nullptr) {
220             result |= PROFILE_STATE_DISCONNECTED;
221         } else if (it->second->GetStateInt() >= HFP_AG_STATE_CONNECTED) {
222             result |= PROFILE_STATE_CONNECTED;
223         } else if (it->second->GetStateInt() == HFP_AG_STATE_CONNECTING) {
224             result |= PROFILE_STATE_CONNECTING;
225         } else if (it->second->GetStateInt() == HFP_AG_STATE_DISCONNECTING) {
226             result |= PROFILE_STATE_DISCONNECTING;
227         } else if (it->second->GetStateInt() == HFP_AG_STATE_DISCONNECTED) {
228             result |= PROFILE_STATE_DISCONNECTED;
229         }
230     }
231     return result;
232 }
233 
GetDeviceState(const RawAddress & device)234 int HfpAgService::GetDeviceState(const RawAddress &device)
235 {
236     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
237     std::lock_guard<std::recursive_mutex> lk(mutex_);
238     std::string address = device.GetAddress();
239     auto it = stateMachines_.find(address);
240     if (it == stateMachines_.end() || it->second == nullptr) {
241         LOG_INFO("[HFP AG]%{public}s():the statemachine is not available", __FUNCTION__);
242         return stateMap_.at(HFP_AG_STATE_DISCONNECTED);
243     }
244 
245     if (it->second->GetStateInt() >= HFP_AG_STATE_CONNECTED) {
246         return stateMap_.at(HFP_AG_STATE_CONNECTED);
247     } else {
248         return stateMap_.at(it->second->GetStateInt());
249     }
250 }
251 
GetMaxConnectNum()252 int HfpAgService::GetMaxConnectNum()
253 {
254     std::lock_guard<std::recursive_mutex> lk(mutex_);
255     return maxConnectedNum_;
256 }
257 
PostEvent(const HfpAgMessage & event)258 void HfpAgService::PostEvent(const HfpAgMessage &event)
259 {
260     GetDispatcher()->PostTask(std::bind(&HfpAgService::ProcessEvent, this, event));
261 }
262 
ProcessEvent(const HfpAgMessage & event)263 void HfpAgService::ProcessEvent(const HfpAgMessage &event)
264 {
265     std::lock_guard<std::recursive_mutex> lk(mutex_);
266     HILOGI("addr: %{public}s, event_no: %{public}d", GetEncryptAddr(event.dev_).c_str(), event.what_);
267     switch (event.what_) {
268         case HFP_AG_SERVICE_STARTUP_EVT:
269             StartUp();
270             break;
271         case HFP_AG_SERVICE_SHUTDOWN_EVT:
272             ShutDown();
273             break;
274         case HFP_AG_CONNECT_EVT:
275         case HFP_AG_CONNECT_REQUEST_EVT:
276             ProcessConnectEvent(event);
277             break;
278         case HFP_AG_REMOVE_STATE_MACHINE_EVT:
279             ProcessRemoveStateMachine(event.dev_);
280             break;
281         case HFP_AG_VOICE_RECOGNITION_TIME_OUT_EVT:
282             ProcessVoiceRecognitionTimeOut(event);
283             break;
284         case HFP_AG_RESPONSE_CLCC_TIME_OUT_EVT:
285             ProcessResponseClccTimeOut(event);
286             break;
287         case HFP_AG_DIAL_TIME_OUT_EVT:
288             ProcessDialOutTimeOut();
289             break;
290         case HFP_AG_SET_VOLUME_EVT:
291         case HFP_AG_NOTIFY_SERVICE_STATE:
292         case HFP_AG_NOTIFY_ROAM_STATE:
293         case HFP_AG_NOTIFY_SIGNAL_STRENGTH:
294         case HFP_AG_NOTIFY_BATTERY_LEVEL:
295         case HFP_AG_CALL_STATE_CHANGE:
296         case HFP_AG_CALL_STATE_CHANGE_MOCK:
297         case HFP_AG_SEND_CCLC_RESPONSE:
298         case HFP_AG_DIALING_OUT_RESULT:
299         case HFP_AG_SET_INBAND_RING_TONE_EVT:
300         case HFP_AG_SEND_INCOMING_EVT:
301         case HFP_AG_SEND_CALL_SETUP_EVT:
302         case HFP_AG_SEND_BINP_EVT:
303         case HFP_AG_GET_BTRH_EVT:
304         case HFP_AG_SET_BTRH_EVT:
305         case HFP_AG_SEND_RESPONSE_HOLD_STATE:
306         case HFP_AG_SEND_BTRH_EVT:
307         case HFP_AG_SEND_NO_CARRIER:
308         case HFP_AG_START_MOCK:
309         case HFP_AG_SEND_CALL_HELD_EVT:
310             SendEventToEachStateMachine(event);
311             break;
312         default:
313             ProcessDefaultEvent(event);
314             break;
315     }
316 }
317 
GetDevicesByStates(std::vector<int> states)318 std::vector<RawAddress> HfpAgService::GetDevicesByStates(std::vector<int> states)
319 {
320     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
321     std::lock_guard<std::recursive_mutex> lk(mutex_);
322     std::vector<RawAddress> devices;
323     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
324         RawAddress device(it->first);
325         for (size_t i = 0; i < states.size(); i++) {
326             if (GetDeviceState(device) == states[i]) {
327                 devices.push_back(device);
328                 break;
329             }
330         }
331     }
332     return devices;
333 }
334 
ConnectSco()335 bool HfpAgService::ConnectSco()
336 {
337     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
338     std::lock_guard<std::recursive_mutex> lk(mutex_);
339     std::string activeDevice = HfpAgProfile::GetActiveDevice();
340     if (activeDevice == NULL_ADDRESS) {
341         LOG_DEBUG("[HFP AG]%{public}s():The active device is null!", __FUNCTION__);
342         return false;
343     }
344 
345     if (IsConnected(activeDevice) == false) {
346         return false;
347     }
348 
349     if (IsAudioConnected()) {
350         LOG_INFO("[HFP AG]%{public}s():Sco is not idle!", __FUNCTION__);
351         return false;
352     }
353 
354     HfpAgMessage event(HFP_AG_CONNECT_AUDIO_EVT);
355     event.dev_ = activeDevice;
356     PostEvent(event);
357     return true;
358 }
359 
DisconnectSco()360 bool HfpAgService::DisconnectSco()
361 {
362     std::lock_guard<std::recursive_mutex> lk(mutex_);
363     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
364     bool ret = false;
365     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
366         if ((it->second != nullptr) && (it->second->GetStateInt() > HFP_AG_AUDIO_STATE_DISCONNECTED) &&
367             (DisconnectSingleSco(it->first))) {
368             ret = true;
369         }
370     }
371 
372     if (!ret) {
373         LOG_DEBUG("[HFP AG]%{public}s(): No audio connection exist!!!", __FUNCTION__);
374     }
375     return ret;
376 }
377 
DisconnectSingleSco(const std::string & address)378 bool HfpAgService::DisconnectSingleSco(const std::string &address)
379 {
380     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
381     auto it = stateMachines_.find(address);
382     if (it == stateMachines_.end() || it->second == nullptr) {
383         HILOGE("[HFP AG] Invalid Device address:%{public}s", GetEncryptAddr(address).c_str());
384         return false;
385     }
386 
387     if (it->second->GetStateInt() == HFP_AG_AUDIO_STATE_DISCONNECTED) {
388         HILOGE("[HFP AG] Sco is already disconnected on specific device! address:%{public}s, state[%{public}d]",
389             GetEncryptAddr(address).c_str(), it->second->GetStateInt());
390         return false;
391     }
392 
393     HfpAgMessage event(HFP_AG_DISCONNECT_AUDIO_EVT);
394     event.dev_ = address;
395     PostEvent(event);
396     return true;
397 }
398 
GetScoState(const RawAddress & device)399 int HfpAgService::GetScoState(const RawAddress &device)
400 {
401     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
402     std::lock_guard<std::recursive_mutex> lk(mutex_);
403     std::string address = device.GetAddress();
404     auto it = stateMachines_.find(address);
405     if (it == stateMachines_.end() || it->second == nullptr) {
406         LOG_INFO("[HFP AG]%{public}s():the statemachine is not available.", __FUNCTION__);
407         return HFP_AG_AUDIO_STATE_DISCONNECTED;
408     }
409 
410     if (it->second->GetStateInt() <= HFP_AG_AUDIO_STATE_DISCONNECTED) {
411         return HFP_AG_AUDIO_STATE_DISCONNECTED;
412     } else {
413         return it->second->GetStateInt();
414     }
415 }
416 
IsAudioConnected() const417 bool HfpAgService::IsAudioConnected() const
418 {
419     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
420     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
421         if (it->second != nullptr) {
422             auto audioState = it->second->GetStateInt();
423             if (audioState > HFP_AG_AUDIO_STATE_DISCONNECTED) {
424                 return true;
425             }
426         }
427     }
428     return false;
429 }
430 
IsAudioIdle() const431 bool HfpAgService::IsAudioIdle() const
432 {
433     if (isVrOpened_) {
434         return false;
435     }
436 
437     const HfpAgSystemInterface &systemInterface = HfpAgSystemInterface::GetInstance();
438     if (systemInterface.IsInCall()) {
439         return false;
440     }
441 
442     if (systemInterface.IsRinging()) {
443         return false;
444     }
445 
446     return true;
447 }
448 
SendEventToEachStateMachine(const HfpAgMessage & event) const449 void HfpAgService::SendEventToEachStateMachine(const HfpAgMessage &event) const
450 {
451     HfpAgMessage curEvent = event;
452     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
453         if (it->second != nullptr) {
454             curEvent.dev_ = it->first;
455             it->second->ProcessMessage(curEvent);
456         }
457     }
458 }
459 
UpdateAgIndicators() const460 void HfpAgService::UpdateAgIndicators() const
461 {
462     HfpAgMessage evt(HFP_AG_NOTIFY_INDICATOR_EVT);
463     evt.type_ = HFP_AG_NOTIFY_INDICATOR_EVT;
464     for (auto it = stateMachines_.begin(); it != stateMachines_.end(); ++it) {
465         if (it->second != nullptr) {
466             evt.dev_ = it->first;
467             it->second->ProcessMessage(evt);
468         }
469     }
470 }
471 
UpdateMockCallList(int callState,const std::string & number,int type)472 void HfpAgService::UpdateMockCallList(int callState, const std::string &number, int type)
473 {
474     HfpAgMessage curEvent(HFP_AG_CALL_STATE_CHANGE_MOCK);
475     curEvent.state_.callState = callState;
476     curEvent.state_.number = number;
477     curEvent.state_.type = type;
478     PostEvent(curEvent);
479     MockCall call;
480     call.callstate = callState;
481     call.number = number;
482     call.type = CALL_TYPE_DEFAULT;
483     int sameindex = -1;
484     LOG_INFO("HFP AG MOCK moko changed number = %{public}s, state = %{public}d", number.c_str(), callState);
485 
486     std::lock_guard<std::recursive_mutex> lk(mutex_);
487     for (int i = 0; i < callList_.size(); i++) {
488         if (strcmp(callList_[i].number.c_str(), number.c_str()) == 0) {
489             sameindex = i;
490         }
491     }
492     if (sameindex != -1) {
493         callList_.erase(callList_.begin() + sameindex);
494     }
495     callList_.push_back(call);
496 }
497 
PhoneStateChanged(Bluetooth::BluetoothPhoneState & phoneState)498 void HfpAgService::PhoneStateChanged(Bluetooth::BluetoothPhoneState &phoneState)
499 {
500     LOG_INFO("[HFP AG]%{public}s(): ==========<start>==========", __FUNCTION__);
501     int numActive = phoneState.GetActiveNum();
502     int numHeld = phoneState.GetHeldNum();
503     int callState = phoneState.GetCallState();
504     std::string number = phoneState.GetNumber();
505     int type = phoneState.GetCallType();
506     if (mockState_ == HFP_AG_MOCK) {
507         UpdateMockCallList(callState, number, type);
508         return;
509     }
510     std::lock_guard<std::recursive_mutex> lk(mutex_);
511     if (dialingOutTimeout_ != nullptr) {
512         if ((callState == HFP_AG_CALL_STATE_ACTIVE) || (callState == HFP_AG_CALL_STATE_IDLE)) {
513             dialingOutTimeout_->Stop();
514             dialingOutTimeout_ = nullptr;
515         } else if (callState == HFP_AG_CALL_STATE_DIALING) {
516             dialingOutTimeout_->Stop();
517             dialingOutTimeout_ = nullptr;
518             HfpAgMessage event(HFP_AG_DIALING_OUT_RESULT, HFP_AG_RESULT_OK);
519             PostEvent(event);
520         }
521     }
522 
523     if ((numActive > 0) || (numHeld > 0) || (callState != HFP_AG_CALL_STATE_IDLE)) {
524         if (isVrOpened_) {
525             LOG_INFO("[HFP AG]%{public}s():close the voice recognition", __FUNCTION__);
526             CloseVoiceRecognition(RawAddress(HfpAgProfile::GetActiveDevice()));
527         }
528     }
529 
530     HfpAgSystemInterface::GetInstance().SetActiveCallNumber(numActive);
531     HfpAgSystemInterface::GetInstance().SetHeldCallNumber(numHeld);
532     HfpAgSystemInterface::GetInstance().SetCallState(callState);
533 
534     HfpAgMessage curEvent(HFP_AG_CALL_STATE_CHANGE);
535     curEvent.state_ = {numActive, numHeld, callState, number, type, phoneState.GetName()};
536     PostEvent(curEvent);
537     UpdateAgIndicators();
538 }
539 
ClccResponse(int index,int direction,int status,int mode,bool mpty,const std::string & number,int type)540 void HfpAgService::ClccResponse(
541     int index, int direction, int status, int mode, bool mpty, const std::string &number, int type)
542 {
543     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
544     std::lock_guard<std::recursive_mutex> lk(mutex_);
545     if (ResponseClccTimeout_ != nullptr) {
546         ResponseClccTimeout_->Stop();
547         queryClccAddress_ = NULL_ADDRESS;
548         ResponseClccTimeout_ = nullptr;
549     }
550 
551     HfpAgMessage curEvent(HFP_AG_SEND_CCLC_RESPONSE);
552     curEvent.call_.index = index;
553     curEvent.call_.dir = direction;
554     curEvent.call_.state = status;
555     curEvent.call_.mode = mode;
556     curEvent.call_.mpty = mpty;
557     curEvent.call_.type = type;
558     curEvent.call_.number = number;
559     PostEvent(curEvent);
560 }
561 
SendOpenVoiceEvent(const std::string & address,bool isRequestByHf)562 void HfpAgService::SendOpenVoiceEvent(const std::string &address, bool isRequestByHf)
563 {
564     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
565     if (isRequestByHf) {
566         HfpAgMessage evt(HFP_AG_VOICE_RECOGNITION_RESULT_EVT, 1);
567         evt.dev_ = address;
568         PostEvent(evt);
569     } else {
570         HfpAgMessage evt(HFP_AG_OPEN_VOICE_RECOGNITION_EVT);
571         evt.dev_ = address;
572         PostEvent(evt);
573     }
574     isVrOpened_ = true;
575 }
576 
OpenVoiceRecognition(const RawAddress & device)577 bool HfpAgService::OpenVoiceRecognition(const RawAddress &device)
578 {
579     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
580     std::lock_guard<std::recursive_mutex> lk(mutex_);
581     std::string address = device.GetAddress();
582     if (IsVoiceRecognitionAvailable(address) == false) {
583         return false;
584     }
585 
586     if (voiceRecognitionTimeout_ != nullptr) {
587         // VR is opening by handsfree unit, send result to handsfree unit
588         voiceRecognitionTimeout_->Stop();
589         voiceRecognitionTimeout_ = nullptr;
590         SendOpenVoiceEvent(address, true);
591     } else {
592         // VR is opening by audio gateway, notify handsfree unit
593         SendOpenVoiceEvent(address, false);
594     }
595 
596     return true;
597 }
598 
CloseVoiceRecognition(const RawAddress & device)599 bool HfpAgService::CloseVoiceRecognition(const RawAddress &device)
600 {
601     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
602     std::lock_guard<std::recursive_mutex> lk(mutex_);
603     if (!isVrOpened_) {
604         LOG_INFO("[HFP AG]%{public}s():The VR is not opened!", __FUNCTION__);
605         return false;
606     }
607 
608     std::string address = device.GetAddress();
609     if (IsConnected(address) == false) {
610         return false;
611     }
612 
613     if (IsActiveDevice(address) == false) {
614         return false;
615     }
616 
617     SendCloseVoiceEvent(address);
618     return true;
619 }
620 
SendCloseVoiceEvent(const std::string & address)621 void HfpAgService::SendCloseVoiceEvent(const std::string &address)
622 {
623     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
624     HfpAgMessage evt1(HFP_AG_CLOSE_VOICE_RECOGNITION_EVT);
625     evt1.dev_ = address;
626     PostEvent(evt1);
627 
628     HfpAgMessage evt2(HFP_AG_DISCONNECT_AUDIO_EVT);
629     evt2.dev_ = address;
630     PostEvent(evt2);
631 
632     isVrOpened_ = false;
633 }
634 
SendMockCmd(const HfpAgMessage & event)635 void HfpAgService::SendMockCmd(const HfpAgMessage &event)
636 {
637     SendEventToEachStateMachine(event);
638 }
639 
SetActiveDevice(const RawAddress & device)640 bool HfpAgService::SetActiveDevice(const RawAddress &device)
641 {
642     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
643     std::lock_guard<std::recursive_mutex> lk(mutex_);
644     std::string address = device.GetAddress();
645     if (address == NULL_ADDRESS) {
646         ClearActiveDevice();
647         return true;
648     }
649 
650     if (IsConnected(address) == false) {
651         return false;
652     }
653 
654     if (IsActiveDevice(address) == false) {
655         ModifyActiveDevice(address);
656     }
657 
658     return true;
659 }
660 
IntoMock(int state)661 bool HfpAgService::IntoMock(int state)
662 {
663     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
664     mockState_ = state;
665     HfpAgMessage evt(HFP_AG_START_MOCK);
666     evt.arg1_ = state;
667     PostEvent(evt);
668     if (state == HFP_AG_MOCK_DEFAULT) {
669         callList_.clear();
670     }
671     return true;
672 }
673 
SendNoCarrier(const RawAddress & device)674 bool HfpAgService::SendNoCarrier(const RawAddress &device)
675 {
676     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
677     std::lock_guard<std::recursive_mutex> lk(mutex_);
678     std::string address = device.GetAddress();
679     HfpAgMessage evt(HFP_AG_SEND_NO_CARRIER);
680     evt.dev_ = address;
681     PostEvent(evt);
682     return true;
683 }
684 
GetMockState()685 int HfpAgService::GetMockState()
686 {
687     return mockState_;
688 }
689 
GetCallList()690 std::vector<MockCall> HfpAgService::GetCallList()
691 {
692     return callList_;
693 }
694 
ClearActiveDevice()695 void HfpAgService::ClearActiveDevice()
696 {
697     std::string preActiveDevice = HfpAgProfile::GetActiveDevice();
698     if (isVrOpened_) {
699         HfpAgMessage evt(HFP_AG_CLOSE_VOICE_RECOGNITION_EVT);
700         evt.dev_ = preActiveDevice;
701         PostEvent(evt);
702     }
703     DisconnectSingleSco(preActiveDevice);
704     HfpAgProfile::SetActiveDevice(NULL_ADDRESS);
705     NotifyCurrentActiveDevice(RawAddress(NULL_ADDRESS));
706 }
707 
IsInbandRinging()708 bool HfpAgService::IsInbandRinging()
709 {
710     std::lock_guard<std::recursive_mutex> lk(mutex_);
711     return isInbandRinging_;
712 }
713 
IsIncall()714 bool HfpAgService::IsIncall()
715 {
716     const HfpAgSystemInterface &systemInterface = HfpAgSystemInterface::GetInstance();
717     return (systemInterface.IsInCall() || (systemInterface.IsRinging() && IsInbandRinging()));
718 }
719 
GetActiveDevice()720 std::string HfpAgService::GetActiveDevice()
721 {
722     LOG_INFO("[HFP AG]%{public}s():==========<start>==========", __FUNCTION__);
723     std::lock_guard<std::recursive_mutex> lk(mutex_);
724     return HfpAgProfile::GetActiveDevice();
725 }
726 
NotifyAgIndicatorStateChanged(int what,int state)727 void HfpAgService::NotifyAgIndicatorStateChanged(int what, int state)
728 {
729     HfpAgMessage curEvent(what, state);
730     PostEvent(curEvent);
731 }
732 
NotifyAgIncomingStateChanged(int what,std::string number,int type)733 void HfpAgService::NotifyAgIncomingStateChanged(int what, std::string number, int type)
734 {
735     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
736     HfpAgMessage curEvent(what, type);
737     curEvent.str_ = number;
738     PostEvent(curEvent);
739 }
740 
NotifyAgResponseHoldStateChanged(int what,int state)741 void HfpAgService::NotifyAgResponseHoldStateChanged(int what, int state)
742 {
743     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
744     HfpAgMessage curEvent(what, state);
745     PostEvent(curEvent);
746 }
747 
SendBinpNumber(std::string number)748 void HfpAgService::SendBinpNumber(std::string number)
749 {
750     HfpAgMessage curEvent(HFP_AG_SEND_BINP_EVT);
751     curEvent.str_ = number;
752     PostEvent(curEvent);
753 }
754 
RegisterObserver(HfpAgServiceObserver & observer)755 void HfpAgService::RegisterObserver(HfpAgServiceObserver &observer)
756 {
757     std::lock_guard<std::recursive_mutex> lk(mutex_);
758     std::list<HfpAgServiceObserver *>::iterator iter;
759     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
760         if (*iter == &observer) {
761             LOG_INFO("Already registered!");
762             return;
763         }
764     }
765     observers_.push_back(&observer);
766 }
767 
DeregisterObserver(HfpAgServiceObserver & observer)768 void HfpAgService::DeregisterObserver(HfpAgServiceObserver &observer)
769 {
770     std::lock_guard<std::recursive_mutex> lk(mutex_);
771     std::list<HfpAgServiceObserver *>::iterator iter;
772     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
773         if (*iter == &observer) {
774             break;
775         }
776     }
777 
778     if (iter != observers_.end()) {
779         observers_.erase(iter);
780     }
781     return;
782 }
783 
NotifySlcStateChanged(const RawAddress & device,int toState)784 void HfpAgService::NotifySlcStateChanged(const RawAddress &device, int toState)
785 {
786     HILOGI("[HFP AG] device:%{public}s, toState:%{public}d", GET_ENCRYPT_ADDR(device), toState);
787     std::list<HfpAgServiceObserver *>::iterator iter;
788     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
789         (*iter)->OnConnectionStateChanged(device, stateMap_.at(toState));
790     }
791 }
792 
NotifyAudioStateChanged(const RawAddress & device,int toState,int reason)793 void HfpAgService::NotifyAudioStateChanged(const RawAddress &device, int toState, int reason)
794 {
795     HILOGI("[HFP AG] device:%{public}s, toState:%{public}d, reason:%{public}d",
796         GET_ENCRYPT_ADDR(device), toState, reason);
797     std::list<HfpAgServiceObserver *>::iterator iter;
798     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
799         (*iter)->OnScoStateChanged(device, toState, reason);
800     }
801 }
802 
NotifyCurrentActiveDevice(const RawAddress & device)803 void HfpAgService::NotifyCurrentActiveDevice(const RawAddress &device)
804 {
805     LOG_INFO("[HFP AG]%{public}s():", __FUNCTION__);
806     std::list<HfpAgServiceObserver *>::iterator iter;
807     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
808         (*iter)->OnActiveDeviceChanged(device);
809     }
810 }
811 
NotifyHfEnhancedDriverSafety(const RawAddress & device,int indValue)812 void HfpAgService::NotifyHfEnhancedDriverSafety(const RawAddress &device, int indValue)
813 {
814     LOG_INFO("[HFP AG]%{public}s():", __FUNCTION__);
815     std::list<HfpAgServiceObserver *>::iterator iter;
816     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
817         (*iter)->OnHfEnhancedDriverSafetyChanged(device, indValue);
818     }
819 }
820 
NotifyHfBatteryLevel(const RawAddress & device,int indValue)821 void HfpAgService::NotifyHfBatteryLevel(const RawAddress &device, int indValue)
822 {
823     LOG_INFO("[HFP AG]%{public}s():", __FUNCTION__);
824     std::list<HfpAgServiceObserver *>::iterator iter;
825     for (iter = observers_.begin(); iter != observers_.end(); ++iter) {
826         (*iter)->OnHfBatteryLevelChanged(device, indValue);
827     }
828 }
829 
DialOutCallByHf(const std::string & address)830 bool HfpAgService::DialOutCallByHf(const std::string &address)
831 {
832     if (mockState_ == HFP_AG_MOCK) {
833         return true;
834     }
835     if (dialingOutTimeout_ != nullptr) {
836         LOG_ERROR("[HFP AG]%{public}s():already dialing out!", __FUNCTION__);
837         return false;
838     }
839 
840     if (!SetActiveDevice(RawAddress(address))) {
841         HILOGE("[HFP AG] It's failed to set active device to %{public}s", GetEncryptAddr(address).c_str());
842         return false;
843     }
844 
845     dialingOutTimeout_ =
846         std::make_unique<utility::Timer>(std::bind(&bluetooth::HfpAgService::DialOutCallTimeOut, this));
847     dialingOutTimeout_->Start(DIALING_OUT_TIMEOUT_TIME);
848     LOG_INFO("[HFP AG]%{public}s():start dial timer!", __FUNCTION__);
849     return true;
850 }
851 
DialOutCallTimeOut()852 void HfpAgService::DialOutCallTimeOut()
853 {
854     HfpAgMessage event(HFP_AG_DIAL_TIME_OUT_EVT);
855     PostEvent(event);
856 }
857 
OpenVoiceRecognitionByHf(const std::string & address)858 bool HfpAgService::OpenVoiceRecognitionByHf(const std::string &address)
859 {
860     // VR opening
861     if (voiceRecognitionTimeout_ != nullptr) {
862         LOG_ERROR("[HFP AG]%{public}s():voice recognition is opening", __FUNCTION__);
863         return false;
864     }
865 
866     // VR opened or in call
867     if (!IsAudioIdle()) {
868         LOG_INFO("[HFP AG]%{public}s():sco is not idle!", __FUNCTION__);
869         return false;
870     }
871 
872     if (!SetActiveDevice(RawAddress(address))) {
873         LOG_ERROR("[HFP AG]%{public}s():It's failed to set active device!", __FUNCTION__);
874         return false;
875     }
876 
877     voiceRecognitionTimeout_ =
878         std::make_unique<utility::Timer>(std::bind(&bluetooth::HfpAgService::VoiceRecognitionTimeOut, this));
879     voiceRecognitionTimeout_->Start(VOICE_RECOGNITION_TIMEOUT_TIME);
880     LOG_INFO("[HFP AG]%{public}s():start open voice recognition timer!", __FUNCTION__);
881     return true;
882 }
883 
CloseVoiceRecognitionByHf(const std::string & address)884 bool HfpAgService::CloseVoiceRecognitionByHf(const std::string &address)
885 {
886     if (IsActiveDevice(address) == false) {
887         return false;
888     }
889 
890     // VR not opening or opened
891     if (!isVrOpened_ && (voiceRecognitionTimeout_ == nullptr)) {
892         LOG_ERROR("[HFP AG]%{public}s():voice recognition is not opening or opened!", __FUNCTION__);
893         return false;
894     }
895 
896     // VR opening
897     if (voiceRecognitionTimeout_ != nullptr) {
898         voiceRecognitionTimeout_->Stop();
899         voiceRecognitionTimeout_ = nullptr;
900     }
901 
902     // VR opened
903     if (isVrOpened_) {
904         DisconnectSingleSco(address);
905         isVrOpened_ = false;
906     }
907 
908     const HfpAgSystemInterface &systemInterface = HfpAgSystemInterface::GetInstance();
909     systemInterface.StopVoiceRecogition(address);
910     return true;
911 }
912 
VoiceRecognitionTimeOut()913 void HfpAgService::VoiceRecognitionTimeOut()
914 {
915     HfpAgMessage event(HFP_AG_VOICE_RECOGNITION_TIME_OUT_EVT);
916     PostEvent(event);
917 }
918 
SetResponseClccTimer(const std::string & address)919 void HfpAgService::SetResponseClccTimer(const std::string &address)
920 {
921     if (ResponseClccTimeout_ != nullptr) {
922         ResponseClccTimeout_->Stop();
923         queryClccAddress_ = NULL_ADDRESS;
924         ResponseClccTimeout_ = nullptr;
925     }
926 
927     ResponseClccTimeout_ =
928         std::make_unique<utility::Timer>(std::bind(&bluetooth::HfpAgService::ResponseClccTimeOut, this));
929     ResponseClccTimeout_->Start(RESPONSE_CLCC_TIMEOUT_TIME);
930     queryClccAddress_ = address;
931     LOG_INFO("[HFP AG]%{public}s():start clcc timer!", __FUNCTION__);
932 }
933 
ResponseClccTimeOut()934 void HfpAgService::ResponseClccTimeOut()
935 {
936     HfpAgMessage event(HFP_AG_RESPONSE_CLCC_TIME_OUT_EVT);
937     PostEvent(event);
938 }
939 
SlcStateChanged(const std::string & address,int toState)940 void HfpAgService::SlcStateChanged(const std::string &address, int toState)
941 {
942     if (toState == HFP_AG_STATE_DISCONNECTED) {
943         if (HfpAgProfile::GetActiveDevice() == address) {
944             SetActiveDevice(RawAddress(NULL_ADDRESS));
945         }
946     }
947 }
948 
ScoStateChanged(const std::string & address,int fromState,int toState)949 void HfpAgService::ScoStateChanged(const std::string &address, int fromState, int toState)
950 {
951     if (toState == HFP_AG_AUDIO_STATE_DISCONNECTED) {
952         if (voiceRecognitionTimeout_) {
953             if (!CloseVoiceRecognitionByHf(address)) {
954                 LOG_ERROR("[HFP AG]%{public}s():Failed to close the voice recognition!", __FUNCTION__);
955             }
956         }
957     }
958 }
959 
GetConnectedDeviceNum() const960 int HfpAgService::GetConnectedDeviceNum() const
961 {
962     int size = 0;
963     for (auto iter = stateMachines_.begin(); iter != stateMachines_.end(); ++iter) {
964         if (iter->second != nullptr) {
965             auto connectionState = iter->second->GetStateInt();
966             if ((connectionState == HFP_AG_STATE_CONNECTING) || (connectionState >= HFP_AG_STATE_CONNECTED)) {
967                 size++;
968             }
969         }
970     }
971     return size;
972 }
973 
GetMaxConnectionDevicesNum() const974 int HfpAgService::GetMaxConnectionDevicesNum() const
975 {
976     int number = MAX_DEFAULT_CONNECTIONS_NUM;
977     if (!AdapterConfig::GetInstance()->GetValue(SECTION_HFP_AG_SERVICE, PROPERTY_MAX_CONNECTED_DEVICES, number)) {
978         LOG_INFO("[HFP HF]%{public}s():It's failed to get the max connection number", __FUNCTION__);
979     }
980     return number;
981 }
982 
NotifyRegistrationStatusChanged(int status)983 void HfpAgService::NotifyRegistrationStatusChanged(int status)
984 {
985     HfpAgSystemInterface::GetInstance().OnSubscriptionStateChanged(status);
986 }
987 
NotifySignalStrengthChanged(int signalStrength)988 void HfpAgService::NotifySignalStrengthChanged(int signalStrength)
989 {
990     HfpAgSystemInterface::GetInstance().OnSignalStrengthChanged(signalStrength);
991 }
992 
NotifyRoamingStatusChanged(int status)993 void HfpAgService::NotifyRoamingStatusChanged(int status)
994 {
995     HfpAgSystemInterface::GetInstance().OnRoamStateChanged(status);
996 }
997 
NotifyBatteryLevelChanged(int batteryLevel)998 void HfpAgService::NotifyBatteryLevelChanged(int batteryLevel)
999 {
1000     HfpAgSystemInterface::GetInstance().OnBatteryLevel(batteryLevel);
1001 }
1002 
NotifyVolumeChanged(int type,int volume)1003 void HfpAgService::NotifyVolumeChanged(int type, int volume)
1004 {
1005     HfpAgMessage event(HFP_AG_SET_VOLUME_EVT, type);
1006     event.arg3_ = volume;
1007     PostEvent(event);
1008 }
1009 
ProcessConnectEvent(const HfpAgMessage & event)1010 void HfpAgService::ProcessConnectEvent(const HfpAgMessage &event)
1011 {
1012     if (GetConnectedDeviceNum() < maxConnectedNum_) {
1013         auto it = stateMachines_.find(event.dev_);
1014         if (it != stateMachines_.end() && it->second != nullptr && it->second->IsRemoving()) {
1015             // peer device may send connect request before we remove statemachine for last connection.
1016             // so post this connect request, process it after we remove statemachine completely.
1017             PostEvent(event);
1018         } else if (it == stateMachines_.end() || it->second == nullptr) {
1019             stateMachines_[event.dev_] = std::make_unique<HfpAgStateMachine>(event.dev_);
1020             stateMachines_[event.dev_]->Init();
1021             stateMachines_[event.dev_]->ProcessMessage(event);
1022         } else {
1023             it->second->ProcessMessage(event);
1024         }
1025     }
1026 }
1027 
ProcessRemoveStateMachine(const std::string & address)1028 void HfpAgService::ProcessRemoveStateMachine(const std::string &address)
1029 {
1030     stateMachines_.insert_or_assign(address, nullptr);
1031     if (isShuttingDown_) {
1032         ShutDownDone(false);
1033     }
1034 }
1035 
ProcessDefaultEvent(const HfpAgMessage & event) const1036 void HfpAgService::ProcessDefaultEvent(const HfpAgMessage &event) const
1037 {
1038     auto it = stateMachines_.find(event.dev_);
1039     if ((it != stateMachines_.end()) && (it->second != nullptr)) {
1040         it->second->ProcessMessage(event);
1041     } else {
1042         HILOGI("addr: %{public}s", GetEncryptAddr(event.dev_).c_str());
1043     }
1044 }
1045 
ProcessVoiceRecognitionTimeOut(const HfpAgMessage & event)1046 void HfpAgService::ProcessVoiceRecognitionTimeOut(const HfpAgMessage &event)
1047 {
1048     if (voiceRecognitionTimeout_ != nullptr) {
1049         voiceRecognitionTimeout_ = nullptr;
1050     }
1051 
1052     SendEventToEachStateMachine(event);
1053 }
1054 
ProcessResponseClccTimeOut(const HfpAgMessage & event)1055 void HfpAgService::ProcessResponseClccTimeOut(const HfpAgMessage &event)
1056 {
1057     if (ResponseClccTimeout_ != nullptr) {
1058         if (queryClccAddress_ != event.dev_) {
1059             return;
1060         } else {
1061             queryClccAddress_ = NULL_ADDRESS;
1062             ResponseClccTimeout_ = nullptr;
1063         }
1064     }
1065 
1066     SendEventToEachStateMachine(event);
1067 }
1068 
ProcessDialOutTimeOut()1069 void HfpAgService::ProcessDialOutTimeOut()
1070 {
1071     if (dialingOutTimeout_ != nullptr) {
1072         dialingOutTimeout_ = nullptr;
1073     }
1074 
1075     HfpAgMessage event(HFP_AG_DIALING_OUT_RESULT, HFP_AG_RESULT_ERROR);
1076     PostEvent(event);
1077 }
1078 
IsVoiceRecognitionAvailable(const std::string & address) const1079 bool HfpAgService::IsVoiceRecognitionAvailable(const std::string &address) const
1080 {
1081     if (IsConnected(address) == false) {
1082         return false;
1083     }
1084 
1085     if (IsActiveDevice(address) == false) {
1086         return false;
1087     }
1088 
1089     if (IsAudioIdle() == false) {
1090         LOG_INFO("[HFP AG]%{public}s():sco is not idle!", __FUNCTION__);
1091         return false;
1092     }
1093     return true;
1094 }
1095 
SetInbandRing(bool action)1096 void HfpAgService::SetInbandRing(bool action)
1097 {
1098     std::lock_guard<std::recursive_mutex> lk(mutex_);
1099     isInbandRinging_ = action;
1100     HfpAgMessage curEvent(HFP_AG_SET_INBAND_RING_TONE_EVT, action);
1101     PostEvent(curEvent);
1102 }
1103 
ResponesOK(const std::string & address)1104 void HfpAgService::ResponesOK(const std::string &address)
1105 {
1106     HfpAgMessage event(HFP_AG_RESPONE_OK_EVT);
1107     event.dev_ = address;
1108     PostEvent(event);
1109 }
1110 
IsConnected(const std::string & address) const1111 bool HfpAgService::IsConnected(const std::string &address) const
1112 {
1113     auto it = stateMachines_.find(address);
1114     if (it == stateMachines_.end() || it->second == nullptr) {
1115         HILOGE("[HFP AG] Invalid Device address:%{public}s", GetEncryptAddr(address).c_str());
1116         return false;
1117     }
1118     if (it->second->GetStateInt() < HFP_AG_STATE_CONNECTED) {
1119         HILOGE("[HFP AG] Device not connected! address:%{public}s, state[%{public}d]",
1120             GetEncryptAddr(address).c_str(), it->second->GetStateInt());
1121         return false;
1122     }
1123     return true;
1124 }
1125 
IsActiveDevice(const std::string & address) const1126 bool HfpAgService::IsActiveDevice(const std::string &address) const
1127 {
1128     std::string activeDevice = HfpAgProfile::GetActiveDevice();
1129     if (activeDevice == address) {
1130         return true;
1131     } else {
1132         HILOGE("[HFP AG] Current Device is not active device, address:%{public}s, activeDevice:%{public}s",
1133             GetEncryptAddr(address).c_str(), GetEncryptAddr(activeDevice).c_str());
1134         return false;
1135     }
1136 }
1137 
ModifyActiveDevice(const std::string & newAddress)1138 void HfpAgService::ModifyActiveDevice(const std::string &newAddress)
1139 {
1140     std::string preActiveDevice = HfpAgProfile::GetActiveDevice();
1141     HILOGI("[HFP AG] preActiveDevice address:%{public}s, activeDevice newAddress:%{public}s",
1142         GetEncryptAddr(preActiveDevice).c_str(), GetEncryptAddr(newAddress).c_str());
1143 
1144     HfpAgProfile::SetActiveDevice(newAddress);
1145     if (IsIncall()) {
1146         DisconnectSingleSco(preActiveDevice);
1147         HfpAgMessage event(HFP_AG_CONNECT_AUDIO_EVT);
1148         event.dev_ = newAddress;
1149         PostEvent(event);
1150     } else if (isVrOpened_) {
1151         SendCloseVoiceEvent(preActiveDevice);
1152     }
1153 
1154     NotifyCurrentActiveDevice(RawAddress(newAddress));
1155 }
1156 
1157 REGISTER_CLASS_CREATOR(HfpAgService);
1158 }  // namespace bluetooth
1159 }  // namespace OHOS
1160