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_system_interface.h"
17 #include <string.h>
18 #include "hfp_ag_service.h"
19 #include "log.h"
20 #include "stub/telephone_service.h"
21 #include "telephony_observer_client.h"
22 #include "bluetooth_call_client.h"
23 #include "call_manager_client.h"
24 #include "core_service_client.h"
25 #include "iservice_registry.h"
26 #include "system_ability_definition.h"
27 #include "system_ability_status_change_stub.h"
28 
29 using namespace OHOS;
30 using namespace OHOS::Telephony;
31 namespace OHOS {
32 namespace bluetooth {
33 constexpr int32_t INVALID_SLOT_ID = -1;
34 
HfpAgSystemInterface()35 HfpAgSystemInterface::HfpAgSystemInterface()
36 {}
37 
GetInstance()38 HfpAgSystemInterface &HfpAgSystemInterface::GetInstance()
39 {
40     static HfpAgSystemInterface hfpAgSystemInterface;
41     return hfpAgSystemInterface;
42 }
43 
Start()44 void HfpAgSystemInterface::Start()
45 {
46     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
47     QueryAgIndicator();
48     RegisterObserver();
49     sptr<ISystemAbilityManager> samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
50     if (samgrProxy == nullptr) {
51         LOG_ERROR("[HFP AG] failed to get samgrProxy");
52         return;
53     }
54     statusChangeListener_ = new SystemAbilityStatusChange();
55     int32_t ret = samgrProxy->SubscribeSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID, statusChangeListener_);
56     if (ret != ERR_OK) {
57         LOG_ERROR("[HFP AG] subscribe systemAbilityId: telephone failed!");
58         return;
59     }
60     return;
61 }
62 
Stop()63 void HfpAgSystemInterface::Stop()
64 {
65     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
66     UnregisterObserver();
67     DelayedSingleton<BluetoothCallClient>::GetInstance()->UnInit();
68     slotId_ = 0;
69     serviceState_ = 0;
70     signalStrength_ = 0;
71     roamState_ = 0;
72     batteryLevel_ = 0;
73     activeNum_ = 0;
74     heldNum_ = 0;
75     subscriberNumber_ = "";
76     operatorName_ = "";
77     callState_ = HFP_AG_CALL_STATE_DISCONNECTED;
78     return;
79 }
80 
RegisterObserver()81 void HfpAgSystemInterface::RegisterObserver()
82 {
83     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
84     if (observer_ == nullptr) {
85         observer_ = new (std::nothrow) AgTelephonyObserver(*this);
86     }
87     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
88     if (slotId_ < 0) {
89         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
90         return;
91     }
92     TelephonyObserverClient::GetInstance().AddStateObserver(observer_, slotId_,
93         TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE | TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS,
94         true);
95 }
96 
UnregisterObserver()97 void HfpAgSystemInterface::UnregisterObserver()
98 {
99     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
100     if (observer_ == nullptr) {
101         return;
102     }
103     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
104     if (slotId_ < 0) {
105         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
106         return;
107     }
108     TelephonyObserverClient::GetInstance().RemoveStateObserver(slotId_,
109         TelephonyObserverBroker::OBSERVER_MASK_NETWORK_STATE | TelephonyObserverBroker::OBSERVER_MASK_SIGNAL_STRENGTHS);
110 }
111 
RejectCall(const std::string & address) const112 void HfpAgSystemInterface::RejectCall(const std::string &address) const
113 {
114     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
115     DelayedSingleton<BluetoothCallClient>::GetInstance()->RejectCall();
116 }
117 
DialOutCall(const std::string & address,const std::string & number) const118 void HfpAgSystemInterface::DialOutCall(const std::string &address, const std::string &number) const
119 {
120     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
121     AppExecFwk::PacMap extras;
122     std::u16string u16number = Str8ToStr16(number);
123     DelayedSingleton<CallManagerClient>::GetInstance()->DialCall(u16number, extras);
124 }
125 
HangupCall(const std::string & address) const126 void HfpAgSystemInterface::HangupCall(const std::string &address) const
127 {
128     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
129     HfpAgService *service = HfpAgService::GetService();
130     if (service->GetMockState() == HFP_AG_MOCK) {
131         HfpAgMessage evt(HFP_AG_SEND_CALL_STATE_EVT, HFP_AG_CALL_INACTIVE);
132         SendMockEvent(evt);
133         return;
134     }
135 
136     std::vector<CallAttributeInfo> callList;
137     int32_t slotId = INVALID_SLOT_ID;
138     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId);
139     bool isActiveCallHangUp = false;
140     if (slotId < 0) {
141         LOG_ERROR("[HFP AG]%{public}s():slotId_ is invalid",  __FUNCTION__);
142         return;
143     }
144     callList = DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCurrentCallList(slotId);
145     for (auto call : callList) {
146         std::string number = call.accountNumber;
147         LOG_INFO("[HFP AG]%{public}s():HangupCallnumbre = %{public}s, state = %{public}d id = %{public}d",
148             __FUNCTION__, number.c_str(), (int)call.callState, (int)call.callId);
149         if ((int)TelCallState::CALL_STATUS_ACTIVE == (int)call.callState) {
150             // Should use hangup(index)
151             DelayedSingleton<BluetoothCallClient>::GetInstance()->HangUpCall();
152             isActiveCallHangUp = true;
153         }
154     }
155 
156     if (!isActiveCallHangUp) {
157         DelayedSingleton<BluetoothCallClient>::GetInstance()->HangUpCall();
158         LOG_INFO(", HangUpCall ");
159     }
160     isActiveCallHangUp = false;
161 }
162 
AnswerCall(const std::string & address) const163 void HfpAgSystemInterface::AnswerCall(const std::string &address) const
164 {
165     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
166     DelayedSingleton<BluetoothCallClient>::GetInstance()->AnswerCall();
167 }
168 
SendDtmf(int dtmf,const std::string & address) const169 bool HfpAgSystemInterface::SendDtmf(int dtmf, const std::string &address) const
170 {
171     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
172     char str = dtmf + '0';
173     if (!DelayedSingleton<BluetoothCallClient>::GetInstance()->StartDtmf(str)) {
174         return false;
175     }
176     DelayedSingleton<BluetoothCallClient>::GetInstance()->StopDtmf();
177     return true;
178 }
179 
HoldCall(int chld) const180 bool HfpAgSystemInterface::HoldCall(int chld) const
181 {
182     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
183     return HandleChld(chld);
184 }
185 
GetNetworkOperator()186 std::string HfpAgSystemInterface::GetNetworkOperator()
187 {
188     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
189     if (slotId_ < 0) {
190         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
191     } else {
192         sptr<NetworkState> networkState = nullptr;
193         CoreServiceClient::GetInstance().GetNetworkState(slotId_, networkState);
194         if (networkState != nullptr) {
195             operatorName_ = networkState->GetLongOperatorName();
196             LOG_INFO("[HFP AG]%{public}s(): operatorName_ is %{public}s", __FUNCTION__, operatorName_.c_str());
197         } else {
198             LOG_INFO("[HFP AG]%{public}s(): networkState is nullptr", __FUNCTION__);
199         }
200     }
201     return operatorName_;
202 }
203 
GetSubscriberNumber()204 std::string HfpAgSystemInterface::GetSubscriberNumber()
205 {
206     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
207     if (slotId_ < 0) {
208         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
209     } else {
210         std::u16string telephoneNumber;
211         CoreServiceClient::GetInstance().GetSimTelephoneNumber(slotId_, telephoneNumber);
212         subscriberNumber_ = Str16ToStr8(telephoneNumber);
213         LOG_INFO("[HFP AG]%{public}s(): subscriberNumber_ is %{public}s",  __FUNCTION__, subscriberNumber_.c_str());
214     }
215     return subscriberNumber_;
216 }
217 
QueryCurrentCallsList(const std::string & address)218 bool HfpAgSystemInterface::QueryCurrentCallsList(const std::string &address)
219 {
220     LOG_INFO("[HFP AG]%{public}s(): enter",  __FUNCTION__);
221     std::vector<CallAttributeInfo> callList;
222     HfpAgService *service = HfpAgService::GetService();
223     if (service == nullptr) {
224         LOG_INFO("[HFP AG]%{public}s():no service",  __FUNCTION__);
225         return false;
226     }
227     if (service->GetMockState() == HFP_AG_MOCK) {
228         return HandleClccMock(address);
229     }
230     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
231     if (slotId_ < 0) {
232         LOG_ERROR("[HFP AG]%{public}s():slotId_ is invalid",  __FUNCTION__);
233         service->ResponesOK(address);
234         return false;
235     }
236     callList = DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCurrentCallList(slotId_);
237     int callIndex = 0;
238     for (auto call : callList) {
239         callIndex++;
240         std::string number = call.accountNumber;
241         bool conferenceState = false;
242         if (call.conferenceState != TelConferenceState::TEL_CONFERENCE_IDLE) {
243             conferenceState = true;
244         }
245         int dire = -1;
246         switch ((int)call.callDirection) {
247             case (int)CallDirection::CALL_DIRECTION_IN:
248                 dire = BT_CALL_DIRECTION_IN;
249                 break;
250             case (int)CallDirection::CALL_DIRECTION_OUT:
251                 dire = BT_CALL_DIRECTION_OUT;
252                 break;
253             default:
254                 dire = BT_CALL_DIRECTION_UNKNOW;
255                 break;
256         }
257         int calltype = -1;
258         if ((int)call.callType == (int)CallType::TYPE_CS) {
259             calltype = CALL_TYPE_DEFAULT;
260         } else {
261             calltype = (int)call.callType;
262         }
263 
264         service->ClccResponse(callIndex, dire, (int)call.callState, 0, conferenceState, number, calltype);
265             LOG_INFO("[HFP AG]%{public}s(): for number = %{public}s id = %{public}d state = %{public}d",
266                 __FUNCTION__, number.c_str(), callIndex, (int)call.callState);
267     }
268     callIndex = 0;
269     service->ResponesOK(address);
270     return true;
271 }
272 
QueryPhoneState() const273 void HfpAgSystemInterface::QueryPhoneState() const
274 {
275     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
276     DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCallState();
277     return;
278 }
279 
StartVoiceRecognition(const std::string & address) const280 bool HfpAgSystemInterface::StartVoiceRecognition(const std::string &address) const
281 {
282     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
283     return stub::TelephoneService::GetInstance()->StartVoiceRecognition(address);
284 }
285 
StopVoiceRecogition(const std::string & address) const286 bool HfpAgSystemInterface::StopVoiceRecogition(const std::string &address) const
287 {
288     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
289     return stub::TelephoneService::GetInstance()->StopVoiceRecogition(address);
290 }
291 
SetAudioParameters(const std::string & parameters) const292 bool HfpAgSystemInterface::SetAudioParameters(const std::string &parameters) const
293 {
294     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
295     return stub::TelephoneService::GetInstance()->SetAudioParameters(parameters);
296 }
297 
SetStreamVolume(int streamType,int volume,int flag) const298 void HfpAgSystemInterface::SetStreamVolume(int streamType, int volume, int flag) const
299 {
300     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
301     stub::TelephoneService::GetInstance()->SetStreamVolume(streamType, volume, flag);
302 }
303 
GetLastDialNumber()304 std::string HfpAgSystemInterface::GetLastDialNumber()
305 {
306     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
307     std::string number = stub::TelephoneService::GetInstance()->GetLastDialNumber();
308     return number;
309 }
310 
GetServiceState()311 int HfpAgSystemInterface::GetServiceState()
312 {
313     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
314     LOG_INFO("[HFP AG]%{public}s(): slotId_ is %{public}d",  __FUNCTION__, slotId_);
315     if (slotId_ < 0) {
316         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
317     } else {
318         sptr<NetworkState> networkState = nullptr;
319         CoreServiceClient::GetInstance().GetNetworkState(slotId_, networkState);
320         if (networkState != nullptr) {
321             serviceState_ = static_cast<std::underlying_type<RegServiceState>::type>(networkState->GetRegStatus());
322             LOG_DEBUG("[HFP AG]%{public}s(): serviceState_ is %{public}d", __FUNCTION__, serviceState_);
323         }
324     }
325     return serviceState_;
326 }
327 
GetSignalStrength()328 int HfpAgSystemInterface::GetSignalStrength()
329 {
330     LOG_INFO("[HFP AG]%{public}s(): slotId_ is %{public}d",  __FUNCTION__, slotId_);
331     if (slotId_ < 0) {
332         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
333     } else {
334         std::vector<sptr<SignalInformation>> signals;
335         if (CoreServiceClient::GetInstance().GetSignalInfoList(slotId_, signals) == 0 && !signals.empty()) {
336             signalStrength_ = signals[0]->GetSignalLevel();
337         } else {
338             signalStrength_ = 0;
339             LOG_INFO("[HFP AG]%{public}s(): GetSignalInfoList is empty",  __FUNCTION__);
340         }
341         LOG_INFO("[HFP AG]%{public}s(): signalStrength_ is %{public}d",  __FUNCTION__, signalStrength_);
342     }
343     return signalStrength_;
344 }
345 
GetRoamState()346 int HfpAgSystemInterface::GetRoamState()
347 {
348     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
349     LOG_INFO("[HFP AG]%{public}s(): slotId_ is %{public}d",  __FUNCTION__, slotId_);
350     if (slotId_ < 0) {
351         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
352     } else {
353         sptr<NetworkState> networkState = nullptr;
354         CoreServiceClient::GetInstance().GetNetworkState(slotId_, networkState);
355         if (networkState != nullptr) {
356             roamState_ = networkState->IsRoaming();
357             LOG_INFO("[HFP AG]%{public}s(): roamState_ is %{public}d", __FUNCTION__, roamState_);
358         }
359     }
360     return roamState_;
361 }
362 
GetBatteryLevel()363 int HfpAgSystemInterface::GetBatteryLevel()
364 {
365     return batteryLevel_;
366 }
367 
QueryAgIndicator()368 void HfpAgSystemInterface::QueryAgIndicator()
369 {
370     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
371     // No interface for querying battery level
372     batteryLevel_ = 0;
373     // query ag indicator for the other module.
374     serviceState_ = 0;
375     roamState_ = 0;
376     operatorName_ = "";
377     signalStrength_ = 0;
378     subscriberNumber_ = "";
379     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId_);
380     LOG_INFO("[HFP AG]%{public}s(): slotId_ is %{public}d",  __FUNCTION__, slotId_);
381     if (slotId_ < 0) {
382         LOG_INFO("[HFP AG]%{public}s(): slotId_ is invalid",  __FUNCTION__);
383     } else {
384         sptr<NetworkState> networkState = nullptr;
385         CoreServiceClient::GetInstance().GetNetworkState(slotId_, networkState);
386         if (networkState != nullptr) {
387             serviceState_ = static_cast<std::underlying_type<RegServiceState>::type>(networkState->GetRegStatus());
388             LOG_INFO("[HFP AG]%{public}s(): serviceState_ is %{public}d", __FUNCTION__, serviceState_);
389             roamState_ = networkState->IsRoaming();
390             LOG_INFO("[HFP AG]%{public}s(): roamState_ is %{public}d", __FUNCTION__, roamState_);
391             operatorName_ = networkState->GetLongOperatorName();
392             LOG_INFO("[HFP AG]%{public}s(): operatorName_ is %{public}s", __FUNCTION__, operatorName_.c_str());
393         } else {
394             LOG_INFO("[HFP AG]%{public}s(): networkState is nullptr", __FUNCTION__);
395         }
396         LOG_DEBUG("[HFP AG]%{public}s(): serviceState_ is %{public}d", __FUNCTION__, serviceState_);
397         std::vector<sptr<SignalInformation>> signals;
398         if (CoreServiceClient::GetInstance().GetSignalInfoList(slotId_, signals) == 0 && !signals.empty()) {
399             signalStrength_ = signals[0]->GetSignalLevel();
400         } else {
401             signalStrength_ = 0;
402             LOG_INFO("[HFP AG]%{public}s(): GetSignalInfoList is empty",  __FUNCTION__);
403         }
404         LOG_INFO("[HFP AG]%{public}s(): signalStrength_ is %{public}d",  __FUNCTION__, signalStrength_);
405 
406         std::u16string telephoneNumber;
407         CoreServiceClient::GetInstance().GetSimTelephoneNumber(slotId_, telephoneNumber);
408         subscriberNumber_ = Str16ToStr8(telephoneNumber);
409         LOG_INFO("[HFP AG]%{public}s(): subscriberNumber_ is %{public}s",  __FUNCTION__, subscriberNumber_.c_str());
410     }
411     SendServiceStateToService();
412     SendRoamStateToService();
413     SendSignalStrengthToService();
414     SendBatteryLevelToService();
415 
416     return;
417 }
418 
UpdateAgIndicator() const419 void HfpAgSystemInterface::UpdateAgIndicator() const
420 {
421     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
422     for (auto call : bluetoothCallList_) {
423         std::string number = call.number;
424         LOG_INFO("[HFP AG]%{public}s():for number = %{public}s state = %{public}d",
425             __FUNCTION__, number.c_str(), call.callstate);
426         if ((int)TelCallState::CALL_STATUS_WAITING == call.callstate && bluetoothCallList_.size() > 1) {
427             SendIncomingCallToService(number, CALL_TYPE_DEFAULT);
428             SendCallSetupToService((int)HfpCallSetupStatus::HFP_AG_CALLSETUP_INCOMING);
429         } else if ((int)TelCallState::CALL_STATUS_HOLDING == call.callstate) {
430             SendCallHeldToService(HFP_AG_CALLHELD_ACTIVE);
431         } else if ((int)TelCallState::CALL_STATUS_ACTIVE == call.callstate) {
432             if (call.precallstate == (int)TelCallState::CALL_STATUS_WAITING ||
433                 call.precallstate == (int)TelCallState::CALL_STATUS_INCOMING) {
434                 SendCallStateToService(HFP_AG_CALL_ACTIVE);
435             }
436         }
437     }
438 }
439 
GetCallWithState(int state) const440 int HfpAgSystemInterface::GetCallWithState(int state) const
441 {
442     int callid = -1;
443     for (auto call : bluetoothCallList_) {
444         if (call.callstate == state) {
445             callid = call.callid;
446         }
447     }
448     return callid;
449 }
450 
UpdateCallList()451 void HfpAgSystemInterface::UpdateCallList()
452 {
453     std::vector<CallAttributeInfo> callList;
454     int slotId = INVALID_SLOT_ID;
455     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId);
456     if (slotId < 0) {
457         LOG_ERROR("[HFP AG]%{public}s():slotId_ is invalid",  __FUNCTION__);
458     }
459     callList = DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCurrentCallList(slotId);
460     if (callList.size() == 0) {
461         bluetoothCallList_.clear();
462         return;
463     }
464     for (auto call : callList) {
465         int sameindex = -1;
466         int prestate = -1;
467         std::string number = call.accountNumber;
468         for (int i = 0; i < bluetoothCallList_.size(); i++) {
469             if (strcmp(bluetoothCallList_[i].number.c_str(), number.c_str()) == 0) {
470                 sameindex = i;
471             }
472         }
473         if (bluetoothCallList_.size() > callList.size()) {
474             prestate = bluetoothCallList_[sameindex].callstate;
475             bluetoothCallList_.clear();
476             sameindex = -1;
477         }
478         if (sameindex != -1) {
479             bluetoothCallList_[sameindex].precallstate = bluetoothCallList_[sameindex].callstate;
480             bluetoothCallList_[sameindex].callstate = (int)call.callState;
481         } else {
482             BluetoothCall btcall;
483             btcall.callstate = (int)call.callState;
484             btcall.number = call.accountNumber;
485             btcall.callid = call.callId;
486             btcall.precallstate = prestate;
487             bluetoothCallList_.push_back(btcall);
488         }
489     }
490 }
491 
GetVoiceNumber()492 void HfpAgSystemInterface::GetVoiceNumber()
493 {
494     HfpAgService *service = HfpAgService::GetService();
495     if (service == nullptr) {
496         LOG_ERROR("[HFP AG]%{public}s():service is nullptr", __FUNCTION__);
497     }
498     std::string number = "1234567";
499     // NEED TO GET VOICE TAG NUMBER, 1234567 JUST FOR TEST, INTERFACE NOT AVAIABLE NOW!
500     service->SendBinpNumber(number);
501 }
502 
GetResponseHoldState(std::string address)503 void HfpAgSystemInterface::GetResponseHoldState(std::string address)
504 {
505     LOG_INFO("[HFP AG]%{public}s(): enter",  __FUNCTION__);
506     std::vector<CallAttributeInfo> callList;
507     HfpAgService *service = HfpAgService::GetService();
508     if (service == nullptr) {
509         LOG_ERROR("[HFP AG]%{public}s():no service",  __FUNCTION__);
510     }
511     int slotId = INVALID_SLOT_ID;
512     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId);
513     if (slotId < 0) {
514         LOG_ERROR("[HFP AG]%{public}s():slotId_ is invalid",  __FUNCTION__);
515     }
516     callList = DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCurrentCallList(slotId);
517     bool hasHoldCall = false;
518     for (auto call : callList) {
519         std::string number = call.accountNumber;
520         if ((int)TelCallState::CALL_STATUS_HOLDING == (int)call.callState) {
521             hasHoldCall = true;
522         }
523     }
524 
525     if (hasHoldCall) {
526         SendResponseHoldStateToService(HFP_AG_RESPONSE_HOLD);
527     }
528     hasHoldCall = false;
529     service->ResponesOK(address);
530 }
531 
SetResponseHoldState(std::string address,int btrh)532 void HfpAgSystemInterface::SetResponseHoldState(std::string address, int btrh)
533 {
534     LOG_INFO("enter %{publis}s", __FUNCTION__);
535     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
536     std::vector<CallAttributeInfo> callList;
537     HfpAgService *service = HfpAgService::GetService();
538     if (service == nullptr) {
539         LOG_ERROR("[HFP AG]%{public}s():no service",  __FUNCTION__);
540     }
541     int slotId = INVALID_SLOT_ID;
542     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId);
543     if (slotId < 0) {
544         LOG_ERROR("[HFP AG]%{public}s():slotId_ is invalid",  __FUNCTION__);
545     }
546     callList = DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCurrentCallList(slotId);
547     for (auto call : callList) {
548         std::string number = call.accountNumber;
549         if (btrh == 1) {
550             if ((int)TelCallState::CALL_STATUS_INCOMING == (int)call.callState) {
551                 DelayedSingleton<BluetoothCallClient>::GetInstance()->HoldCall();
552                 SendResponseHoldStateToService(HFP_AG_RESPONSE_HOLD_ACCEPT);
553             }
554         }
555     }
556     service->ResponesOK(address);
557 }
558 
HandlePhoneStateMock(std::string number,int state,int type)559 void HfpAgSystemInterface::HandlePhoneStateMock(std::string number, int state, int type)
560 {
561     HfpAgService *service = HfpAgService::GetService();
562     if (service == nullptr) {
563         LOG_ERROR("[HFP AG]%{public}s():no service",  __FUNCTION__);
564         return;
565     }
566     callList_ = service->GetCallList();
567     int activenum = 0;
568     int holdnum = 0;
569     int endnum = 0;
570     int endcallindex = -1;
571     for (int j = 0; j < callList_.size(); j++) {
572         if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_INCOMING) {
573             HfpAgMessage evt1(HFP_AG_SEND_CALL_SETUP_EVT, (int)HfpCallSetupStatus::HFP_AG_CALLSETUP_INCOMING);
574             SendMockEvent(evt1);
575             HfpAgMessage evt(HFP_AG_MOCK_RING);
576             SendMockEvent(evt);
577             SendClip(callList_[j].number);
578         } else if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_WAITING) {
579             bool hasendcall = false;
580             for (auto call:callList_) {
581                 if (call.callstate == (int)TelCallState::CALL_STATUS_DISCONNECTING ||
582                     call.callstate == (int)TelCallState::CALL_STATUS_DISCONNECTED) {
583                     hasendcall = true;
584                 }
585             }
586             if (!hasendcall) {
587                 HfpAgMessage evt(HFP_AG_SEND_INCOMING_EVT, CALL_TYPE_DEFAULT);
588                 evt.str_ = callList_[j].number;
589                 SendMockEvent(evt);
590                 HfpAgMessage evt1(HFP_AG_SEND_CALL_SETUP_EVT, (int)HfpCallSetupStatus::HFP_AG_CALLSETUP_INCOMING);
591                 SendMockEvent(evt1);
592             }
593         } else if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_ACTIVE) {
594             bool hasoutgoingcall = false;
595             for (auto call : callList_) {
596                 if (call.callstate == (int)TelCallState::CALL_STATUS_ALERTING ||
597                     call.callstate == (int)TelCallState::CALL_STATUS_DIALING) {
598                     hasoutgoingcall = true;
599                 }
600             }
601             if (!hasoutgoingcall) {
602                 HfpAgMessage evt(HFP_AG_SEND_CALL_STATE_EVT, HFP_AG_CALL_ACTIVE);
603                 SendMockEvent(evt);
604                 HfpAgMessage evt1(HFP_AG_SEND_CALL_SETUP_EVT, (int)HfpCallSetupStatus::HFP_AG_CALLSETUP_NONE);
605                 SendMockEvent(evt1);
606             }
607             activenum++;
608         } else if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_DISCONNECTED ||
609                 callList_[j].callstate == (int)TelCallState::CALL_STATUS_DISCONNECTING) {
610             endcallindex = j;
611             endnum ++;
612             if (endnum < HFP_AG_CALL_NUM_TWO) {
613                 HfpAgMessage evt(HFP_AG_SEND_CALL_STATE_EVT, HFP_AG_CALL_INACTIVE);
614                 SendMockEvent(evt);
615             }
616         } else if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_HOLDING) {
617             HfpAgMessage evt(HFP_AG_SEND_CALL_HELD_EVT, 1);
618             SendMockEvent(evt);
619             holdnum++;
620         } else if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_DIALING) {
621             HfpAgMessage evt(HFP_AG_SEND_CALL_SETUP_EVT, HFP_AG_CALLSETUP_OUTGOING);
622             SendMockEvent(evt);
623         } else if (callList_[j].callstate == (int)TelCallState::CALL_STATUS_ALERTING) {
624             HfpAgMessage evt(HFP_AG_SEND_CALL_SETUP_EVT, HFP_AG_CALLSETUP_ALERTING);
625             SendMockEvent(evt);
626         }
627     }
628     if (endcallindex != -1) {
629         callList_.erase(callList_.begin() + endcallindex);
630         endcallindex = -1;
631     }
632     if (activenum > 1) {
633         HfpAgMessage evt(HFP_AG_SEND_CALL_HELD_EVT, 0);
634         SendMockEvent(evt);
635         LOG_INFO("HandlePhoneStateMock activenum = %{public}d", activenum);
636     } else if (activenum == 0 && holdnum == 0 && callList_.size() == 0) {
637         HfpAgMessage evt(HFP_AG_SEND_CALL_STATE_EVT, HFP_AG_CALL_INACTIVE);
638         SendMockEvent(evt);
639     }
640     activenum = 0;
641     holdnum = 0;
642     endnum = 0;
643 }
644 
HandleChldMock(int chld) const645 bool HfpAgSystemInterface::HandleChldMock(int chld) const
646 {
647     HfpAgMessage evtok(HFP_AG_RESPONE_OK_EVT);
648     SendMockEvent(evtok);
649     if (chld == ATCHLD_RELEASE_HOLD_ACCPET_OTHER) {
650         HfpAgMessage evt(HFP_AG_SEND_CALL_HELD_EVT, HFP_AG_CALL_NUM_TWO);
651         SendMockEvent(evt);
652         HfpAgMessage evt1(HFP_AG_SEND_CALL_STATE_EVT, HFP_AG_CALL_ACTIVE);
653         SendMockEvent(evt1);
654         HfpAgMessage evt2(HFP_AG_SEND_CALL_SETUP_EVT, 0);
655         SendMockEvent(evt2);
656         evt.arg1_ = 1;
657         SendMockEvent(evt);
658     } else if (chld == ATCHLD_ADD_CALL_TO_CONVERSATION) {
659         HfpAgMessage evt(HFP_AG_SEND_CALL_HELD_EVT, 0);
660         SendMockEvent(evt);
661         HfpAgMessage evt1(HFP_AG_SEND_CALL_STATE_EVT, HFP_AG_CALL_ACTIVE);
662         SendMockEvent(evt1);
663         HfpAgMessage evt2(HFP_AG_SEND_CALL_SETUP_EVT, 0);
664         SendMockEvent(evt2);
665     }
666     return true;
667 }
668 
669 
HandleClccMock(std::string address) const670 bool HfpAgSystemInterface::HandleClccMock(std::string address) const
671 {
672     HfpAgService *service = HfpAgService::GetService();
673     int callindex = 0;
674     for (auto mockcall : callList_) {
675         callindex++;
676         std::string number = mockcall.number;
677         bool conferenceState = false;
678         if (callList_.size() >1) {
679             conferenceState = true;
680         }
681         service->ClccResponse(callindex, BT_CALL_DIRECTION_IN, mockcall.callstate,
682             0, conferenceState, number, CALL_TYPE_DEFAULT);
683     }
684     callindex = 0;
685     service->ResponesOK(address);
686     return true;
687 }
688 
SendHfIndicator(const std::string & address,int indId,int indValue) const689 void HfpAgSystemInterface::SendHfIndicator(const std::string &address, int indId, int indValue) const
690 {
691     LOG_INFO("[HFP AG]%{public}s():enter",  __FUNCTION__);
692     RawAddress device(address);
693     HfpAgService *service = HfpAgService::GetService();
694     if (service == nullptr) {
695         LOG_ERROR("[HFP AG]%{public}s():service is nullptr", __FUNCTION__);
696     }
697     if (indId == HFP_AG_HF_INDICATOR_ENHANCED_DRIVER_SAFETY_ID) {
698         service->NotifyHfEnhancedDriverSafety(device, indValue);
699         stub::TelephoneService::GetInstance()->NotifyHfEnhancedDriverSafety(indValue);
700     } else if (indId == HFP_AG_HF_INDICATOR_BATTERY_LEVEL_ID) {
701         service->NotifyHfBatteryLevel(device, indValue);
702         stub::TelephoneService::GetInstance()->NotifyHfBatteryLevel(indValue);
703     } else {
704         LOG_INFO("[HFP AG]%{public}s():HF Indicator id:%{public}d", __FUNCTION__, indId);
705     }
706     return;
707 }
708 
SetActiveCallNumber(int number)709 void HfpAgSystemInterface::SetActiveCallNumber(int number)
710 {
711     activeNum_ = number;
712 }
713 
GetActiveCallNumber() const714 int HfpAgSystemInterface::GetActiveCallNumber() const
715 {
716     return activeNum_;
717 }
718 
SetHeldCallNumber(int number)719 void HfpAgSystemInterface::SetHeldCallNumber(int number)
720 {
721     heldNum_ = number;
722 }
723 
GetHeldCallNumber() const724 int HfpAgSystemInterface::GetHeldCallNumber() const
725 {
726     return heldNum_;
727 }
728 
SetCallState(int state)729 void HfpAgSystemInterface::SetCallState(int state)
730 {
731     callState_ = state;
732 }
733 
GetCallState() const734 int HfpAgSystemInterface::GetCallState() const
735 {
736     return callState_;
737 }
738 
SendServiceStateToService() const739 void HfpAgSystemInterface::SendServiceStateToService() const
740 {
741     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
742     HfpAgService *service = HfpAgService::GetService();
743     if (service != nullptr) {
744         service->NotifyAgIndicatorStateChanged(HFP_AG_NOTIFY_SERVICE_STATE, serviceState_);
745     } else {
746         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
747     }
748 }
749 
750 
SendIncomingCallToService(std::string number,int type) const751 void HfpAgSystemInterface::SendIncomingCallToService(std::string number, int type) const
752 {
753     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
754     HfpAgService *service = HfpAgService::GetService();
755     if (service != nullptr) {
756         service->NotifyAgIncomingStateChanged(HFP_AG_SEND_INCOMING_EVT, number, type);
757     } else {
758         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
759     }
760 }
761 
SendMockEvent(HfpAgMessage evt) const762 void HfpAgSystemInterface::SendMockEvent(HfpAgMessage evt) const
763 {
764     LOG_INFO("[HFP AG]%{public}s():",  __FUNCTION__);
765     HfpAgService *service = HfpAgService::GetService();
766     if (service != nullptr) {
767         service->SendMockCmd(evt);
768     } else {
769         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
770     }
771 }
772 
SendClip(std::string number) const773 void HfpAgSystemInterface::SendClip(std::string number) const
774 {
775     LOG_INFO("[HFP AG]%{public}s():",  __FUNCTION__);
776     HfpAgService *service = HfpAgService::GetService();
777     HfpAgMessage evt(HFP_AG_MOCK_CLIP);
778     evt.str_ = number;
779     if (service != nullptr) {
780         service->SendMockCmd(evt);
781     } else {
782         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
783     }
784 }
785 
SendCallSetupToService(int state) const786 void HfpAgSystemInterface::SendCallSetupToService(int state) const
787 {
788     LOG_INFO("[HFP AG]%{public}s():",  __FUNCTION__);
789     HfpAgService *service = HfpAgService::GetService();
790     if (service != nullptr) {
791         service->NotifyAgIndicatorStateChanged(HFP_AG_SEND_CALL_SETUP_EVT, state);
792     } else {
793         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
794     }
795 }
796 
SendCallHeldToService(int state) const797 void HfpAgSystemInterface::SendCallHeldToService(int state) const
798 {
799     LOG_INFO("[HFP AG]%{public}s():",  __FUNCTION__);
800     HfpAgService *service = HfpAgService::GetService();
801     if (service != nullptr) {
802         service->NotifyAgIndicatorStateChanged(HFP_AG_SEND_CALL_HELD_EVT, state);
803     } else {
804         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
805     }
806 }
807 
SendCallStateToService(int state) const808 void HfpAgSystemInterface::SendCallStateToService(int state) const
809 {
810     HfpAgService *service = HfpAgService::GetService();
811     if (service != nullptr) {
812         service->NotifyAgIndicatorStateChanged(HFP_AG_SEND_CALL_STATE_EVT, state);
813     } else {
814         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
815     }
816 }
817 
SendResponseHoldStateToService(int state) const818 void HfpAgSystemInterface::SendResponseHoldStateToService(int state) const
819 {
820     LOG_INFO("[HFP AG]%{public}s():",  __FUNCTION__);
821     HfpAgService *service = HfpAgService::GetService();
822     if (service != nullptr) {
823         service->NotifyAgResponseHoldStateChanged(HFP_AG_SEND_RESPONSE_HOLD_STATE, state);
824     } else {
825         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
826     }
827 }
828 
SendRoamStateToService() const829 void HfpAgSystemInterface::SendRoamStateToService() const
830 {
831     LOG_INFO("[HFP AG]%{public}s():",  __FUNCTION__);
832     HfpAgService *service = HfpAgService::GetService();
833     if (service != nullptr) {
834         service->NotifyAgIndicatorStateChanged(HFP_AG_NOTIFY_ROAM_STATE, roamState_);
835     } else {
836         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
837     }
838 }
839 
SendSignalStrengthToService() const840 void HfpAgSystemInterface::SendSignalStrengthToService() const
841 {
842     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
843     HfpAgService *service = HfpAgService::GetService();
844     if (service != nullptr) {
845         service->NotifyAgIndicatorStateChanged(HFP_AG_NOTIFY_SIGNAL_STRENGTH, signalStrength_);
846     } else {
847         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
848     }
849 }
850 
SendBatteryLevelToService() const851 void HfpAgSystemInterface::SendBatteryLevelToService() const
852 {
853     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
854     HfpAgService *service = HfpAgService::GetService();
855     if (service != nullptr) {
856         service->NotifyAgIndicatorStateChanged(HFP_AG_NOTIFY_BATTERY_LEVEL, batteryLevel_);
857     } else {
858         LOG_ERROR("[HFP AG]%{public}s():service is null!", __FUNCTION__);
859     }
860 }
861 
OnSubscriptionStateChanged(int state)862 void HfpAgSystemInterface::OnSubscriptionStateChanged(int state)
863 {
864     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
865     int preService = serviceState_;
866     serviceState_ = state;
867     if (preService != serviceState_) {
868         SendServiceStateToService();
869     }
870 }
871 
OnSignalStrengthChanged(int signal)872 void HfpAgSystemInterface::OnSignalStrengthChanged(int signal)
873 {
874     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
875     int preSignal = signalStrength_;
876     signalStrength_ = signal;
877     if (preSignal != signalStrength_) {
878         SendSignalStrengthToService();
879     }
880 }
881 
OnRoamStateChanged(int state)882 void HfpAgSystemInterface::OnRoamStateChanged(int state)
883 {
884     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
885     int preRoam = roamState_;
886     roamState_ = state;
887     if (preRoam != roamState_) {
888         SendRoamStateToService();
889     }
890 }
891 
OnBatteryLevel(int level)892 void HfpAgSystemInterface::OnBatteryLevel(int level)
893 {
894     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
895     int preBattery = batteryLevel_;
896     batteryLevel_ = level;
897     if (preBattery != batteryLevel_) {
898         SendBatteryLevelToService();
899     }
900 }
901 
IsInCall() const902 bool HfpAgSystemInterface::IsInCall() const
903 {
904     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
905     return ((activeNum_ > 0) || (heldNum_ > 0) ||
906             ((callState_ != HFP_AG_CALL_STATE_IDLE) && (callState_ != HFP_AG_CALL_STATE_INCOMING) &&
907                 (callState_ != HFP_AG_CALL_STATE_DISCONNECTED) && (callState_ != HFP_AG_CALL_STATE_DISCONNECTING)));
908 }
909 
IsRinging() const910 bool HfpAgSystemInterface::IsRinging() const
911 {
912     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
913     return (callState_ == HFP_AG_CALL_STATE_INCOMING);
914 }
915 
HandleChld(int chld) const916 bool HfpAgSystemInterface::HandleChld(int chld) const
917 {
918     HfpAgService *service = HfpAgService::GetService();
919     if (service->GetMockState() == HFP_AG_MOCK) {
920         return HandleChldMock(chld);
921     }
922     std::vector<CallAttributeInfo> callList;
923     int slotId = INVALID_SLOT_ID;
924     CoreServiceClient::GetInstance().GetPrimarySlotId(slotId);
925     if (slotId < 0) {
926         LOG_ERROR("[HFP AG]%{public}s():slotId_ is invalid",  __FUNCTION__);
927     }
928     callList = DelayedSingleton<BluetoothCallClient>::GetInstance()->GetCurrentCallList(slotId);
929     for (auto call : callList) {
930         std::string number = call.accountNumber;
931         LOG_INFO("[HFP AG]%{public}s():HandleChld for number = %{public}s state = %{public}d",
932             __FUNCTION__, number.c_str(), (int)call.callState);
933             if (chld == ATCHLD_RELEASE_ALL_HELD_CALLS) {
934                 if ((int)TelCallState::CALL_STATUS_HOLDING == (int)call.callState ||
935                     (int)TelCallState::CALL_STATUS_WAITING == (int)call.callState) {
936                     DelayedSingleton<BluetoothCallClient>::GetInstance()->HangUpCall();
937                 }
938             } else if (chld == ATCHLD_RELEASE_ACTIVE_ACCPET_OTHER) {
939                 if ((int)TelCallState::CALL_STATUS_WAITING == (int)call.callState &&
940                     (int)call.callDirection == (int)CallDirection::CALL_DIRECTION_IN) {
941                     DelayedSingleton<BluetoothCallClient>::GetInstance()->AnswerCall();
942                 } else if ((int)TelCallState::CALL_STATUS_ACTIVE == (int)call.callState) {
943                     DelayedSingleton<BluetoothCallClient>::GetInstance()->HangUpCall();
944                 } else if ((int)TelCallState::CALL_STATUS_HOLDING == (int)call.callState) {
945                     DelayedSingleton<BluetoothCallClient>::GetInstance()->HoldCall();
946                 }
947             } else if (chld == ATCHLD_RELEASE_HOLD_ACCPET_OTHER) {
948                 if ((int)TelCallState::CALL_STATUS_WAITING == (int)call.callState) {
949                     DelayedSingleton<BluetoothCallClient>::GetInstance()->AnswerCall();
950                 } else if ((int)TelCallState::CALL_STATUS_ACTIVE == (int)call.callState) {
951                     DelayedSingleton<BluetoothCallClient>::GetInstance()->HoldCall();
952                 }
953             } else if (chld == ATCHLD_ADD_CALL_TO_CONVERSATION) {
954                 if ((int)TelCallState::CALL_STATUS_WAITING == (int)call.callState) {
955                     DelayedSingleton<BluetoothCallClient>::GetInstance()->AnswerCall();
956                     DelayedSingleton<BluetoothCallClient>::GetInstance()->CombineConference();
957                 }
958             } else if (chld == ATCHLD_CONNECT_TWO_CALL) {
959                 DelayedSingleton<BluetoothCallClient>::GetInstance()->CombineConference();
960                 DelayedSingleton<BluetoothCallClient>::GetInstance()->HangUpCall();
961             }
962     }
963     return true;
964 }
965 
OnNetworkStateUpdated(int32_t slotId,const sptr<NetworkState> & networkState)966 void HfpAgSystemInterface::AgTelephonyObserver::OnNetworkStateUpdated(int32_t slotId,
967     const sptr<NetworkState> &networkState)
968 {
969     HILOGI("[HFP AG] slotId: %{public}d", slotId);
970     if (networkState == nullptr) {
971         HILOGE("[HFP AG] networkState is null");
972         return;
973     }
974     interface_.slotId_ = slotId;
975     interface_.operatorName_ = networkState->GetLongOperatorName();
976     interface_.OnSubscriptionStateChanged(static_cast<std::underlying_type<RegServiceState>::type>(
977         networkState->GetRegStatus()));
978     interface_.OnRoamStateChanged(networkState->IsRoaming());
979 }
980 
OnSignalInfoUpdated(int32_t slotId,const std::vector<sptr<SignalInformation>> & vec)981 void HfpAgSystemInterface::AgTelephonyObserver::OnSignalInfoUpdated(int32_t slotId,
982     const std::vector<sptr<SignalInformation>> &vec)
983 {
984     LOG_DEBUG("[HFP AG]%{public}s():enter",  __FUNCTION__);
985     interface_.slotId_ = slotId;
986     if (!vec.empty()) {
987         interface_.OnSignalStrengthChanged(vec[0]->GetSignalLevel());
988     }
989 }
990 
Str8ToStr16(const std::string & str) const991 inline std::u16string HfpAgSystemInterface::Str8ToStr16(const std::string& str) const
992 {
993     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
994     std::u16string result = convert.from_bytes(str);
995     return result;
996 }
997 
Str16ToStr8(const std::u16string & str) const998 inline std::string HfpAgSystemInterface::Str16ToStr8(const std::u16string& str) const
999 {
1000     std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
1001     std::string result = convert.to_bytes(str);
1002     return result;
1003 }
1004 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1005 void SystemAbilityStatusChange::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
1006 {
1007     HILOGI("OnAddSystemAbility systemAbilityId:%{public}d", systemAbilityId);
1008     switch (systemAbilityId) {
1009         case TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID:
1010             HILOGI("OnAddSystemAbility input service start");
1011             DelayedSingleton<BluetoothCallClient>::GetInstance()->Init();
1012             break;
1013         default:
1014             HILOGI("OnAddSystemAbility unhandled sysabilityId:%{public}d", systemAbilityId);
1015             break;
1016     }
1017     return;
1018 }
1019 
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1020 void SystemAbilityStatusChange::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
1021 {
1022     HILOGI("OnRemoveSystemAbility: start!");
1023     return;
1024 }
1025 }  // namespace bluetooth
1026 }  // namespace OHOS
1027