1 /*
2  * Copyright (C) 2021-2024 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 "call_control_manager.h"
17 #include "cpp/task_ext.h"
18 #include <securec.h>
19 #include "csignal"
20 #include <string_ex.h>
21 
22 #include "audio_control_manager.h"
23 #include "bluetooth_call_manager.h"
24 #include "call_ability_report_proxy.h"
25 #include "call_connect_ability.h"
26 #include "call_dialog.h"
27 #include "call_manager_errors.h"
28 #include "call_manager_hisysevent.h"
29 #include "call_number_utils.h"
30 #include "call_records_manager.h"
31 #include "call_state_report_proxy.h"
32 #include "cellular_call_connection.h"
33 #include "common_type.h"
34 #include "ims_call.h"
35 #include "iservice_registry.h"
36 #include "reject_call_sms.h"
37 #include "report_call_info_handler.h"
38 #include "satellite_call_control.h"
39 #include "telephony_log_wrapper.h"
40 #include "video_control_manager.h"
41 #include "audio_device_manager.h"
42 #include "distributed_call_manager.h"
43 #include "call_superprivacy_control_manager.h"
44 #include "call_voice_assistant_manager.h"
45 
46 namespace OHOS {
47 namespace Telephony {
48 bool CallControlManager::alarmSeted = false;
49 const uint64_t DISCONNECT_DELAY_TIME = 1000000;
50 static const int32_t SATCOMM_UID = 1096;
51 using namespace OHOS::EventFwk;
CallControlManager()52 CallControlManager::CallControlManager()
53     : callStateListenerPtr_(nullptr), CallRequestHandlerPtr_(nullptr), incomingCallWakeup_(nullptr),
54       missedCallNotification_(nullptr), callSettingManagerPtr_(nullptr)
55 {
56     dialSrcInfo_.callId = ERR_ID;
57     dialSrcInfo_.number = "";
58     extras_.Clear();
59     dialSrcInfo_.isDialing = false;
60 }
61 
~CallControlManager()62 CallControlManager::~CallControlManager()
63 {
64     if (statusChangeListener_ != nullptr) {
65         auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
66         if (samgrProxy != nullptr) {
67             samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_);
68             samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, pageStateChangeListener_);
69             samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, satcommEventListener_);
70             samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, superPrivacyEventListener_);
71             pageStateChangeListener_ = nullptr;
72             statusChangeListener_ = nullptr;
73             satcommEventListener_ = nullptr;
74             superPrivacyEventListener_ = nullptr;
75         }
76     }
77 }
78 
Init()79 bool CallControlManager::Init()
80 {
81     callStateListenerPtr_ = std::make_unique<CallStateListener>();
82     if (callStateListenerPtr_ == nullptr) {
83         TELEPHONY_LOGE("callStateListenerPtr_ is null");
84         return false;
85     }
86     CallRequestHandlerPtr_ = std::make_unique<CallRequestHandler>();
87     if (CallRequestHandlerPtr_ == nullptr) {
88         TELEPHONY_LOGE("CallRequestHandlerPtr_ is null");
89         return false;
90     }
91     CallRequestHandlerPtr_->Init();
92     incomingCallWakeup_ = std::make_shared<IncomingCallWakeup>();
93     if (incomingCallWakeup_ == nullptr) {
94         TELEPHONY_LOGE("incomingCallWakeup_ is null");
95         return false;
96     }
97     missedCallNotification_ = std::make_shared<MissedCallNotification>();
98     if (missedCallNotification_ == nullptr) {
99         TELEPHONY_LOGE("missedCallNotification_ is null");
100         return false;
101     }
102     callSettingManagerPtr_ = std::make_unique<CallSettingManager>();
103     if (callSettingManagerPtr_ == nullptr) {
104         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
105         return false;
106     }
107     if (BroadcastSubscriber() != TELEPHONY_SUCCESS) {
108         TELEPHONY_LOGE("BroadcastSubscriber failed!");
109         return false;
110     }
111     DelayedSingleton<AudioControlManager>::GetInstance()->Init();
112     CallStateObserve();
113     DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->RegisterSuperPrivacyMode();
114     DelayedSingleton<CallStateReportProxy>::GetInstance()->UpdateCallStateForVoIPOrRestart();
115     return true;
116 }
117 
ReportPhoneUEInSuperPrivacy(const std::string & eventName)118 void CallControlManager::ReportPhoneUEInSuperPrivacy(const std::string &eventName)
119 {
120     if (DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->GetCurrentIsSuperPrivacyMode()) {
121         CallManagerHisysevent::HiWriteBehaviorEventPhoneUE(
122             eventName, PNAMEID_KEY, KEY_CALL_MANAGER, PVERSIONID_KEY, "");
123     }
124 }
125 
DialCall(std::u16string & number,AppExecFwk::PacMap & extras)126 int32_t CallControlManager::DialCall(std::u16string &number, AppExecFwk::PacMap &extras)
127 {
128     sptr<CallBase> callObjectPtr = nullptr;
129     std::string accountNumber(Str16ToStr8(number));
130     int32_t ret = NumberLegalityCheck(accountNumber);
131     if (ret != TELEPHONY_SUCCESS) {
132         TELEPHONY_LOGE("Invalid number!");
133         return ret;
134     }
135     bool isEcc = false;
136     DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(
137         accountNumber, extras.GetIntValue("accountId"), isEcc);
138     if (isEcc) {
139         extras.PutIntValue("dialScene", (int32_t)DialScene::CALL_EMERGENCY);
140     }
141     ret = DelayedSingleton<SatelliteCallControl>::GetInstance()->IsSatelliteSwitchEnable();
142     if (ret == TELEPHONY_SUCCESS) {
143         ret = DelayedSingleton<SatelliteCallControl>::GetInstance()->IsAllowedSatelliteDialCall();
144         if (ret != TELEPHONY_SUCCESS) {
145             return ret;
146         } else {
147             extras.PutIntValue("callType", (int32_t)CallType::TYPE_SATELLITE);
148         }
149     }
150     ReportPhoneUEInSuperPrivacy(CALL_DIAL_IN_SUPER_PRIVACY);
151     ret = CanDial(number, extras, isEcc);
152     if (ret != TELEPHONY_SUCCESS) {
153         TELEPHONY_LOGE("dial policy result:%{public}d", ret);
154         return ret;
155     }
156     if (!IsSupportVideoCall(extras)) {
157         extras.PutIntValue("videoState", (int32_t)VideoStateType::TYPE_VOICE);
158     }
159     VideoStateType videoState = (VideoStateType)extras.GetIntValue("videoState");
160     if (videoState == VideoStateType::TYPE_VIDEO) {
161         extras.PutIntValue("callType", (int32_t)CallType::TYPE_IMS);
162     }
163     // temporarily save dial information
164     PackageDialInformation(extras, accountNumber, isEcc);
165     if (CallRequestHandlerPtr_ == nullptr) {
166         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
167         return TELEPHONY_ERR_LOCAL_PTR_NULL;
168     }
169     ret = CallRequestHandlerPtr_->DialCall();
170     if (ret != TELEPHONY_SUCCESS) {
171         TELEPHONY_LOGE("DialCall failed!");
172         return ret;
173     }
174     return TELEPHONY_SUCCESS;
175 }
176 
CanDial(std::u16string & number,AppExecFwk::PacMap & extras,bool isEcc)177 int32_t CallControlManager::CanDial(std::u16string &number, AppExecFwk::PacMap &extras, bool isEcc)
178 {
179     int32_t ret = DialPolicy(number, extras, isEcc);
180     if (ret != TELEPHONY_SUCCESS) {
181         TELEPHONY_LOGE("dial policy result:%{public}d", ret);
182         return ret;
183     }
184     ret = CanDialMulityCall(extras, isEcc);
185     if (ret != TELEPHONY_SUCCESS) {
186         TELEPHONY_LOGE("dial policy result:%{public}d", ret);
187         return ret;
188     }
189     return TELEPHONY_SUCCESS;
190 }
191 
PackageDialInformation(AppExecFwk::PacMap & extras,std::string accountNumber,bool isEcc)192 void CallControlManager::PackageDialInformation(AppExecFwk::PacMap &extras, std::string accountNumber, bool isEcc)
193 {
194     std::lock_guard<std::mutex> lock(mutex_);
195     dialSrcInfo_.callId = ERR_ID;
196     dialSrcInfo_.number = accountNumber;
197     dialSrcInfo_.isDialing = true;
198     dialSrcInfo_.isEcc = isEcc;
199     dialSrcInfo_.callType = (CallType)extras.GetIntValue("callType");
200     dialSrcInfo_.accountId = extras.GetIntValue("accountId");
201     dialSrcInfo_.dialType = (DialType)extras.GetIntValue("dialType");
202     dialSrcInfo_.videoState = (VideoStateType)extras.GetIntValue("videoState");
203     dialSrcInfo_.originalCallType = (int32_t)extras.GetIntValue("videoState");
204     dialSrcInfo_.bundleName = extras.GetStringValue("bundleName");
205     extras_.Clear();
206     extras_ = extras;
207 }
208 
AnswerCall(int32_t callId,int32_t videoState)209 int32_t CallControlManager::AnswerCall(int32_t callId, int32_t videoState)
210 {
211     sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
212     if (call == nullptr) {
213         TELEPHONY_LOGE("call is nullptr");
214         CallManagerHisysevent::WriteAnswerCallFaultEvent(
215             INVALID_PARAMETER, callId, videoState, TELEPHONY_ERR_LOCAL_PTR_NULL, "call is nullptr");
216         return TELEPHONY_ERR_LOCAL_PTR_NULL;
217     }
218     if (callId == INVALID_CALLID) {
219         callId = call->GetCallID();
220     }
221     call = GetOneCallObject(callId);
222     if (call == nullptr) {
223         TELEPHONY_LOGE("call is nullptr");
224         return TELEPHONY_ERR_LOCAL_PTR_NULL;
225     }
226     ReportPhoneUEInSuperPrivacy(CALL_ANSWER_IN_SUPER_PRIVACY);
227     bool isVoipCall = call->GetCallType() == CallType::TYPE_VOIP;
228     if (!isVoipCall && CurrentIsSuperPrivacyMode(callId, videoState)) {
229         return TELEPHONY_SUCCESS;
230     }
231     AnswerHandlerForSatelliteOrVideoCall(call, videoState);
232     TELEPHONY_LOGI("report answered state");
233     if (!isVoipCall) {
234         NotifyCallStateUpdated(call, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED);
235     }
236     CarrierAndVoipConflictProcess(callId, TelCallState::CALL_STATUS_ANSWERED);
237     if (VoIPCallState_ != CallStateToApp::CALL_STATE_IDLE) {
238             TELEPHONY_LOGW("VoIP call is active, waiting for VoIP to disconnect");
239             AnsweredCallQueue_.hasCall = true;
240             AnsweredCallQueue_.callId = callId;
241             AnsweredCallQueue_.videoState = videoState;
242             return TELEPHONY_SUCCESS;
243     }
244     int32_t ret = AnswerCallPolicy(callId, videoState);
245     if (ret != TELEPHONY_SUCCESS) {
246         TELEPHONY_LOGE("AnswerCallPolicy failed!");
247         CallManagerHisysevent::WriteAnswerCallFaultEvent(
248             INVALID_PARAMETER, callId, videoState, ret, "AnswerCallPolicy failed");
249         return ret;
250     }
251     if (CallRequestHandlerPtr_ == nullptr) {
252         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
253         return TELEPHONY_ERR_LOCAL_PTR_NULL;
254     }
255     ret = CallRequestHandlerPtr_->AnswerCall(callId, videoState);
256     if (ret != TELEPHONY_SUCCESS) {
257         TELEPHONY_LOGE("AnswerCall failed!");
258         return ret;
259     }
260     return TELEPHONY_SUCCESS;
261 }
262 
CurrentIsSuperPrivacyMode(int32_t callId,int32_t videoState)263 bool CallControlManager::CurrentIsSuperPrivacyMode(int32_t callId, int32_t videoState)
264 {
265     bool currentIsSuperPrivacyMode = DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->
266         GetCurrentIsSuperPrivacyMode();
267     TELEPHONY_LOGI("call policy answer currentIsSuperPrivacyMode:%{public}d", currentIsSuperPrivacyMode);
268     if (currentIsSuperPrivacyMode) {
269         DelayedSingleton<CallDialog>::GetInstance()->DialogConnectAnswerPrivpacyModeExtension("SUPER_PRIVACY_MODE",
270             callId, videoState, true);
271         return true;
272     }
273     return false;
274 }
275 
AnswerHandlerForSatelliteOrVideoCall(sptr<CallBase> & call,int32_t videoState)276 void CallControlManager::AnswerHandlerForSatelliteOrVideoCall(sptr<CallBase> &call, int32_t videoState)
277 {
278     if (call == nullptr) {
279         TELEPHONY_LOGE("call is nullptr");
280         return;
281     }
282     if (call->GetCallType() == CallType::TYPE_IMS && videoState != static_cast<int32_t>(call->GetVideoStateType())) {
283         call->SetVideoStateType(static_cast<VideoStateType>(videoState));
284         sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
285         imsCall->InitVideoCall();
286         TELEPHONY_LOGI("videoState has changed");
287     }
288     if (call->GetCallType() == CallType::TYPE_SATELLITE) {
289         sptr<CallBase> foregroundSatelliteCall =
290             CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
291         if (foregroundSatelliteCall != nullptr) {
292             CallRequestHandlerPtr_->HangUpCall(foregroundSatelliteCall->GetCallID());
293         }
294     }
295 }
296 
CarrierAndVoipConflictProcess(int32_t callId,TelCallState callState)297 int32_t CallControlManager::CarrierAndVoipConflictProcess(int32_t callId, TelCallState callState)
298 {
299     sptr<CallBase> call = GetOneCallObject(callId);
300     if (call == nullptr) {
301         TELEPHONY_LOGE("CarrierAndVoipConflictProcess, call is nullptr!");
302         return TELEPHONY_ERR_LOCAL_PTR_NULL;
303     }
304     if (call->GetCallType() == CallType::TYPE_CS ||
305         call->GetCallType() == CallType::TYPE_IMS ||
306         call->GetCallType() == CallType::TYPE_SATELLITE) {
307         std::list<int32_t> voipCallIdList;
308         int32_t ret = GetVoipCallList(voipCallIdList);
309         if (ret != TELEPHONY_SUCCESS) {
310             TELEPHONY_LOGE("GetVoipCallList failed!");
311             return ret;
312         }
313         for (auto voipCallId : voipCallIdList) {
314             sptr<CallBase> voipCall = GetOneCallObject(voipCallId);
315             if (voipCall->GetTelCallState() == TelCallState::CALL_STATUS_INCOMING ||
316                 voipCall->GetTelCallState() == TelCallState::CALL_STATUS_WAITING) {
317                 ret = RejectCall(voipCallId, true, u"CarrierAndVoipConflictProcess");
318             } else if (callState == TelCallState::CALL_STATUS_ANSWERED) {
319                 ret = HangUpCall(voipCallId);
320             }
321             if (ret != TELEPHONY_SUCCESS) {
322                 TELEPHONY_LOGE("CarrierAndVoipConflictProcess failed!");
323                 return ret;
324             }
325         }
326         return TELEPHONY_SUCCESS;
327     }
328     return TELEPHONY_SUCCESS;
329 }
330 
RejectCall(int32_t callId,bool rejectWithMessage,std::u16string textMessage)331 int32_t CallControlManager::RejectCall(int32_t callId, bool rejectWithMessage, std::u16string textMessage)
332 {
333     if (CallRequestHandlerPtr_ == nullptr) {
334         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
335         return TELEPHONY_ERR_LOCAL_PTR_NULL;
336     }
337 
338     if (callId == INVALID_CALLID) {
339         sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
340         if (call == nullptr) {
341             TELEPHONY_LOGE("call is nullptr");
342             CallManagerHisysevent::WriteHangUpFaultEvent(
343                 INVALID_PARAMETER, callId, TELEPHONY_ERR_LOCAL_PTR_NULL, "Reject call is nullptr");
344             return TELEPHONY_ERR_LOCAL_PTR_NULL;
345         }
346         callId = call->GetCallID();
347     }
348 
349     int32_t ret = RejectCallPolicy(callId);
350     if (ret != TELEPHONY_SUCCESS) {
351         TELEPHONY_LOGE("RejectCallPolicy failed!");
352         CallManagerHisysevent::WriteHangUpFaultEvent(INVALID_PARAMETER, callId, ret, "Reject RejectCallPolicy failed");
353         return ret;
354     }
355     std::string messageStr(Str16ToStr8(textMessage));
356     ret = CallRequestHandlerPtr_->RejectCall(callId, rejectWithMessage, messageStr);
357     if (ret != TELEPHONY_SUCCESS) {
358         TELEPHONY_LOGE("RejectCall failed!");
359         return ret;
360     }
361     ReportPhoneUEInSuperPrivacy(CALL_REJECT_IN_SUPER_PRIVACY);
362     return TELEPHONY_SUCCESS;
363 }
364 
HangUpCall(int32_t callId)365 int32_t CallControlManager::HangUpCall(int32_t callId)
366 {
367     if (callId == INVALID_CALLID) {
368         std::vector<CallRunningState> callRunningStateVec;
369         callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
370         callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_DIALING);
371         callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
372 
373         for (auto &state : callRunningStateVec) {
374             sptr<CallBase> call = GetOneCallObject(state);
375             if (call != nullptr) {
376                 callId = call->GetCallID();
377                 break;
378             }
379         }
380 
381         if (callId == INVALID_CALLID) {
382             TELEPHONY_LOGE("callId is INVALID_CALLID!");
383             CallManagerHisysevent::WriteHangUpFaultEvent(
384                 INVALID_PARAMETER, callId, TELEPHONY_ERR_LOCAL_PTR_NULL, "HangUp callId is INVALID_CALLID");
385             return TELEPHONY_ERR_ARGUMENT_INVALID;
386         }
387     }
388 
389     if (CallRequestHandlerPtr_ == nullptr) {
390         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
391         return TELEPHONY_ERR_LOCAL_PTR_NULL;
392     }
393     int32_t ret = HangUpPolicy(callId);
394     if (ret != TELEPHONY_SUCCESS) {
395         TELEPHONY_LOGE("HangUpPolicy failed!");
396         CallManagerHisysevent::WriteHangUpFaultEvent(INVALID_PARAMETER, callId, ret, "HangUp HangUpPolicy failed");
397         return ret;
398     }
399     ret = CallRequestHandlerPtr_->HangUpCall(callId);
400     if (ret != TELEPHONY_SUCCESS) {
401         TELEPHONY_LOGE("HangUpCall failed!");
402         return ret;
403     }
404     return TELEPHONY_SUCCESS;
405 }
406 
GetCallState()407 int32_t CallControlManager::GetCallState()
408 {
409     CallStateToApp callState = CallStateToApp::CALL_STATE_UNKNOWN;
410     if (!HasCellularCallExist() && (VoIPCallState_ == CallStateToApp::CALL_STATE_IDLE ||
411         VoIPCallState_ == CallStateToApp::CALL_STATE_UNKNOWN)) {
412         callState = CallStateToApp::CALL_STATE_IDLE;
413     } else {
414         callState = CallStateToApp::CALL_STATE_OFFHOOK;
415         bool hasRingingCall = false;
416         if ((HasRingingCall(hasRingingCall) == TELEPHONY_SUCCESS && hasRingingCall) ||
417             VoIPCallState_ == CallStateToApp::CALL_STATE_RINGING) {
418             callState = CallStateToApp::CALL_STATE_RINGING;
419         }
420     }
421     return static_cast<int32_t>(callState);
422 }
423 
HoldCall(int32_t callId)424 int32_t CallControlManager::HoldCall(int32_t callId)
425 {
426     int32_t ret = HoldCallPolicy(callId);
427     if (ret != TELEPHONY_SUCCESS) {
428         TELEPHONY_LOGE("HoldCall failed!");
429         return ret;
430     }
431     if (CallRequestHandlerPtr_ == nullptr) {
432         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
433         return TELEPHONY_ERR_LOCAL_PTR_NULL;
434     }
435     ret = CallRequestHandlerPtr_->HoldCall(callId);
436     if (ret != TELEPHONY_SUCCESS) {
437         TELEPHONY_LOGE("HoldCall failed!");
438         return ret;
439     }
440     return TELEPHONY_SUCCESS;
441 }
442 
UnHoldCall(const int32_t callId)443 int32_t CallControlManager::UnHoldCall(const int32_t callId)
444 {
445     int32_t ret = UnHoldCallPolicy(callId);
446     if (ret != TELEPHONY_SUCCESS) {
447         TELEPHONY_LOGE("UnHoldCall failed!");
448         return ret;
449     }
450     if (CallRequestHandlerPtr_ == nullptr) {
451         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
452         return TELEPHONY_ERR_LOCAL_PTR_NULL;
453     }
454     ret = CallRequestHandlerPtr_->UnHoldCall(callId);
455     if (ret != TELEPHONY_SUCCESS) {
456         TELEPHONY_LOGE("UnHoldCall failed!");
457         return ret;
458     }
459     return TELEPHONY_SUCCESS;
460 }
461 
462 // swap two calls state, turn active call into holding, and turn holding call into active
SwitchCall(int32_t callId)463 int32_t CallControlManager::SwitchCall(int32_t callId)
464 {
465     int32_t ret = SwitchCallPolicy(callId);
466     if (ret != TELEPHONY_SUCCESS) {
467         TELEPHONY_LOGE("SwitchCall failed!");
468         return ret;
469     }
470     if (CallRequestHandlerPtr_ == nullptr) {
471         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
472         return TELEPHONY_ERR_LOCAL_PTR_NULL;
473     }
474     ret = CallRequestHandlerPtr_->SwitchCall(callId);
475     if (ret != TELEPHONY_SUCCESS) {
476         TELEPHONY_LOGE("SwitchCall failed!");
477         return ret;
478     }
479     return TELEPHONY_SUCCESS;
480 }
481 
HasCall()482 bool CallControlManager::HasCall()
483 {
484     if (VoIPCallState_ == CallStateToApp::CALL_STATE_ANSWERED ||
485         VoIPCallState_ == CallStateToApp::CALL_STATE_OFFHOOK ||
486         VoIPCallState_ == CallStateToApp::CALL_STATE_RINGING ||
487         HasCellularCallExist()) {
488         return true;
489     }
490     return false;
491 }
492 
IsNewCallAllowed(bool & enabled)493 int32_t CallControlManager::IsNewCallAllowed(bool &enabled)
494 {
495     return IsNewCallAllowedCreate(enabled);
496 }
497 
IsRinging(bool & enabled)498 int32_t CallControlManager::IsRinging(bool &enabled)
499 {
500     return HasRingingCall(enabled);
501 }
502 
HasEmergency(bool & enabled)503 int32_t CallControlManager::HasEmergency(bool &enabled)
504 {
505     return HasEmergencyCall(enabled);
506 }
507 
NotifyNewCallCreated(sptr<CallBase> & callObjectPtr)508 bool CallControlManager::NotifyNewCallCreated(sptr<CallBase> &callObjectPtr)
509 {
510     if (callObjectPtr == nullptr) {
511         TELEPHONY_LOGE("callObjectPtr is null!");
512         return false;
513     }
514     if (callStateListenerPtr_ != nullptr) {
515         callStateListenerPtr_->NewCallCreated(callObjectPtr);
516     }
517     return true;
518 }
519 
NotifyCallDestroyed(const DisconnectedDetails & details)520 bool CallControlManager::NotifyCallDestroyed(const DisconnectedDetails &details)
521 {
522     if (callStateListenerPtr_ != nullptr) {
523         callStateListenerPtr_->CallDestroyed(details);
524         return true;
525     }
526     return false;
527 }
528 
NotifyCallStateUpdated(sptr<CallBase> & callObjectPtr,TelCallState priorState,TelCallState nextState)529 bool CallControlManager::NotifyCallStateUpdated(
530     sptr<CallBase> &callObjectPtr, TelCallState priorState, TelCallState nextState)
531 {
532     if (callObjectPtr == nullptr) {
533         TELEPHONY_LOGE("callObjectPtr is null!");
534         return false;
535     }
536     if (callStateListenerPtr_ != nullptr) {
537         TELEPHONY_LOGI("NotifyCallStateUpdated priorState:%{public}d,nextState:%{public}d", priorState, nextState);
538         callStateListenerPtr_->CallStateUpdated(callObjectPtr, priorState, nextState);
539         if (callObjectPtr->GetCallType() == CallType::TYPE_VOIP) {
540             return true;
541         }
542         if ((priorState == TelCallState::CALL_STATUS_DIALING && nextState == TelCallState::CALL_STATUS_ALERTING) ||
543             (priorState == TelCallState::CALL_STATUS_DIALING && nextState == TelCallState::CALL_STATUS_ACTIVE) ||
544             (priorState == TelCallState::CALL_STATUS_INCOMING && nextState == TelCallState::CALL_STATUS_ACTIVE)) {
545             TELEPHONY_LOGI("call is actived, now check and switch call to distributed audio device");
546             DelayedSingleton<AudioDeviceManager>::GetInstance()->CheckAndSwitchDistributedAudioDevice();
547         } else if ((priorState == TelCallState::CALL_STATUS_ACTIVE &&
548             nextState == TelCallState::CALL_STATUS_DISCONNECTED) ||
549             (priorState == TelCallState::CALL_STATUS_DISCONNECTING &&
550             nextState == TelCallState::CALL_STATUS_DISCONNECTED)) {
551             bool hasHoldCall = false;
552             if ((HasHoldCall(hasHoldCall) == TELEPHONY_SUCCESS) && !hasHoldCall) {
553                 TELEPHONY_LOGI("call is disconnected, clear distributed call state");
554                 DelayedSingleton<AudioDeviceManager>::GetInstance()->OnActivedCallDisconnected();
555             }
556         } else if (priorState == TelCallState::CALL_STATUS_WAITING &&
557             nextState == TelCallState::CALL_STATUS_ACTIVE) {
558             if (DelayedSingleton<DistributedCallManager>::GetInstance()->IsDCallDeviceSwitchedOn()) {
559                 TELEPHONY_LOGI("answer multi-line call, need switch again.");
560                 DelayedSingleton<AudioDeviceManager>::GetInstance()->CheckAndSwitchDistributedAudioDevice();
561             }
562         }
563         return true;
564     }
565     return false;
566 }
567 
NotifyIncomingCallAnswered(sptr<CallBase> & callObjectPtr)568 bool CallControlManager::NotifyIncomingCallAnswered(sptr<CallBase> &callObjectPtr)
569 {
570     if (callObjectPtr == nullptr) {
571         TELEPHONY_LOGE("callObjectPtr is null!");
572         return false;
573     }
574     if (callStateListenerPtr_ != nullptr) {
575         callStateListenerPtr_->IncomingCallActivated(callObjectPtr);
576         return true;
577     }
578     return false;
579 }
580 
NotifyIncomingCallRejected(sptr<CallBase> & callObjectPtr,bool isSendSms,std::string content)581 bool CallControlManager::NotifyIncomingCallRejected(
582     sptr<CallBase> &callObjectPtr, bool isSendSms, std::string content)
583 {
584     if (callObjectPtr == nullptr) {
585         TELEPHONY_LOGE("callObjectPtr is null!");
586         return false;
587     }
588     if (callStateListenerPtr_ != nullptr) {
589         callStateListenerPtr_->IncomingCallHungUp(callObjectPtr, isSendSms, content);
590         return true;
591     }
592     return false;
593 }
594 
NotifyCallEventUpdated(CallEventInfo & info)595 bool CallControlManager::NotifyCallEventUpdated(CallEventInfo &info)
596 {
597     if (callStateListenerPtr_ != nullptr) {
598         callStateListenerPtr_->CallEventUpdated(info);
599         return true;
600     }
601     return false;
602 }
603 
StartDtmf(int32_t callId,char str)604 int32_t CallControlManager::StartDtmf(int32_t callId, char str)
605 {
606     sptr<CallBase> call = GetOneCallObject(callId);
607     if (call == nullptr) {
608         return TELEPHONY_ERR_ARGUMENT_INVALID;
609     }
610     if (!call->IsAliveState()) {
611         return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
612     }
613 
614     int32_t ret = call->StartDtmf(str);
615     if (ret != TELEPHONY_SUCCESS) {
616         TELEPHONY_LOGE("StartDtmf failed, return:%{public}d", ret);
617     }
618     ffrt::submit([str]() {
619         DelayedSingleton<AudioControlManager>::GetInstance()->PlayDtmfTone(str);
620     });
621     return ret;
622 }
623 
StopDtmf(int32_t callId)624 int32_t CallControlManager::StopDtmf(int32_t callId)
625 {
626     sptr<CallBase> call = GetOneCallObject(callId);
627     if (call == nullptr) {
628         return TELEPHONY_ERR_ARGUMENT_INVALID;
629     }
630     if (!call->IsAliveState()) {
631         return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
632     }
633 
634     int32_t ret = call->StopDtmf();
635     if (ret != TELEPHONY_SUCCESS) {
636         TELEPHONY_LOGE("StopDtmf failed, return:%{public}d", ret);
637     }
638     DelayedSingleton<AudioControlManager>::GetInstance()->StopDtmfTone();
639     return ret;
640 }
641 
PostDialProceed(int32_t callId,bool proceed)642 int32_t CallControlManager::PostDialProceed(int32_t callId, bool proceed)
643 {
644     sptr<CallBase> call = GetOneCallObject(callId);
645     if (call == nullptr) {
646         return TELEPHONY_ERR_ARGUMENT_INVALID;
647     }
648     if (!call->IsAliveState()) {
649         return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
650     }
651 
652     int32_t ret = call->PostDialProceed(proceed);
653     if (ret != TELEPHONY_SUCCESS) {
654         TELEPHONY_LOGE("PostDialProceed failed, return:%{public}d", ret);
655     }
656     return ret;
657 }
658 
GetCallWaiting(int32_t slotId)659 int32_t CallControlManager::GetCallWaiting(int32_t slotId)
660 {
661     int32_t ret = CallPolicy::GetCallWaitingPolicy(slotId);
662     if (ret != TELEPHONY_SUCCESS) {
663         TELEPHONY_LOGE("GetCallWaiting failed!");
664         return ret;
665     }
666     if (callSettingManagerPtr_ != nullptr) {
667         return callSettingManagerPtr_->GetCallWaiting(slotId);
668     } else {
669         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
670         return TELEPHONY_ERR_LOCAL_PTR_NULL;
671     }
672 }
673 
SetCallWaiting(int32_t slotId,bool activate)674 int32_t CallControlManager::SetCallWaiting(int32_t slotId, bool activate)
675 {
676     int32_t ret = CallPolicy::SetCallWaitingPolicy(slotId);
677     if (ret != TELEPHONY_SUCCESS) {
678         TELEPHONY_LOGE("SetCallWaiting failed!");
679         return ret;
680     }
681     if (callSettingManagerPtr_ != nullptr) {
682         return callSettingManagerPtr_->SetCallWaiting(slotId, activate);
683     } else {
684         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
685         return TELEPHONY_ERR_LOCAL_PTR_NULL;
686     }
687 }
688 
GetCallRestriction(int32_t slotId,CallRestrictionType type)689 int32_t CallControlManager::GetCallRestriction(int32_t slotId, CallRestrictionType type)
690 {
691     int32_t ret = CallPolicy::GetCallRestrictionPolicy(slotId);
692     if (ret != TELEPHONY_SUCCESS) {
693         TELEPHONY_LOGE("GetCallRestriction failed!");
694         return ret;
695     }
696     if (callSettingManagerPtr_ != nullptr) {
697         return callSettingManagerPtr_->GetCallRestriction(slotId, type);
698     } else {
699         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
700         return TELEPHONY_ERR_LOCAL_PTR_NULL;
701     }
702 }
703 
SetCallRestriction(int32_t slotId,CallRestrictionInfo & info)704 int32_t CallControlManager::SetCallRestriction(int32_t slotId, CallRestrictionInfo &info)
705 {
706     int32_t ret = CallPolicy::SetCallRestrictionPolicy(slotId);
707     if (ret != TELEPHONY_SUCCESS) {
708         TELEPHONY_LOGE("SetCallRestriction failed!");
709         return ret;
710     }
711     if (callSettingManagerPtr_ != nullptr) {
712         return callSettingManagerPtr_->SetCallRestriction(slotId, info);
713     } else {
714         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
715         return TELEPHONY_ERR_LOCAL_PTR_NULL;
716     }
717 }
718 
SetCallRestrictionPassword(int32_t slotId,CallRestrictionType fac,const char * oldPassword,const char * newPassword)719 int32_t CallControlManager::SetCallRestrictionPassword(
720     int32_t slotId, CallRestrictionType fac, const char *oldPassword, const char *newPassword)
721 {
722     int32_t ret = CallPolicy::SetCallRestrictionPolicy(slotId);
723     if (ret != TELEPHONY_SUCCESS) {
724         TELEPHONY_LOGE("policy check failed!");
725         return ret;
726     }
727     if (callSettingManagerPtr_ != nullptr) {
728         return callSettingManagerPtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
729     } else {
730         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
731         return TELEPHONY_ERR_LOCAL_PTR_NULL;
732     }
733 }
734 
GetCallTransferInfo(int32_t slotId,CallTransferType type)735 int32_t CallControlManager::GetCallTransferInfo(int32_t slotId, CallTransferType type)
736 {
737     int32_t ret = CallPolicy::GetCallTransferInfoPolicy(slotId);
738     if (ret != TELEPHONY_SUCCESS) {
739         TELEPHONY_LOGE("GetCallTransferInfo failed!");
740         return ret;
741     }
742     if (callSettingManagerPtr_ != nullptr) {
743         return callSettingManagerPtr_->GetCallTransferInfo(slotId, type);
744     } else {
745         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
746         return TELEPHONY_ERR_LOCAL_PTR_NULL;
747     }
748 }
749 
SetCallTransferInfo(int32_t slotId,CallTransferInfo & info)750 int32_t CallControlManager::SetCallTransferInfo(int32_t slotId, CallTransferInfo &info)
751 {
752     int32_t ret = CallPolicy::SetCallTransferInfoPolicy(slotId);
753     if (ret != TELEPHONY_SUCCESS) {
754         TELEPHONY_LOGE("SetCallTransferInfo failed!");
755         return ret;
756     }
757     if (callSettingManagerPtr_ != nullptr) {
758         return callSettingManagerPtr_->SetCallTransferInfo(slotId, info);
759     } else {
760         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
761         return TELEPHONY_ERR_LOCAL_PTR_NULL;
762     }
763 }
764 
CanSetCallTransferTime(int32_t slotId,bool & result)765 int32_t CallControlManager::CanSetCallTransferTime(int32_t slotId, bool &result)
766 {
767     int32_t ret = CallPolicy::SetCallTransferInfoPolicy(slotId);
768     if (ret != TELEPHONY_SUCCESS) {
769         TELEPHONY_LOGE("[slot%{public}d] failed!", slotId);
770         return ret;
771     }
772     if (callSettingManagerPtr_ != nullptr) {
773         return callSettingManagerPtr_->CanSetCallTransferTime(slotId, result);
774     } else {
775         TELEPHONY_LOGE("[slot%{public}d]  callSettingManagerPtr_ is nullptr!", slotId);
776         return TELEPHONY_ERR_LOCAL_PTR_NULL;
777     }
778 }
779 
SetCallPreferenceMode(int32_t slotId,int32_t mode)780 int32_t CallControlManager::SetCallPreferenceMode(int32_t slotId, int32_t mode)
781 {
782     int32_t ret = CallPolicy::SetCallPreferenceModePolicy(slotId);
783     if (ret != TELEPHONY_SUCCESS) {
784         TELEPHONY_LOGE("SetCallPreferenceMode failed!");
785         return ret;
786     }
787     if (callSettingManagerPtr_ != nullptr) {
788         return callSettingManagerPtr_->SetCallPreferenceMode(slotId, mode);
789     } else {
790         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
791         return TELEPHONY_ERR_LOCAL_PTR_NULL;
792     }
793 }
794 
795 /**
796  * start a telephone conference by merging three-way calls,steps as follows:
797  * 1.A call B: A<---->B,set holding
798  * 2.A call C: A<---->C, active
799  * 3.A initial merge request by CombineConference
800  * @param mainCallId:active call id
801  */
CombineConference(int32_t mainCallId)802 int32_t CallControlManager::CombineConference(int32_t mainCallId)
803 {
804     sptr<CallBase> mainCall = GetOneCallObject(mainCallId);
805     if (mainCall == nullptr) {
806         TELEPHONY_LOGE("GetOneCallObject failed, mainCallId:%{public}d", mainCallId);
807         return TELEPHONY_ERR_ARGUMENT_INVALID;
808     }
809     if (mainCall->GetTelCallState() != TelCallState::CALL_STATUS_ACTIVE) {
810         TELEPHONY_LOGE("mainCall state should be active ");
811         return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
812     }
813     if (!CallObjectManager::IsCallExist(mainCall->GetCallType(), TelCallState::CALL_STATUS_HOLDING)) {
814         TELEPHONY_LOGE("callType:%{public}d,callState:CALL_STATUS_HOLDING is not exist!", mainCall->GetCallType());
815         return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
816     }
817     int32_t ret = mainCall->CanCombineConference();
818     if (ret != TELEPHONY_SUCCESS) {
819         TELEPHONY_LOGE("CanCombineConference failed");
820         return ret;
821     }
822     if (CallRequestHandlerPtr_ == nullptr) {
823         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
824         return TELEPHONY_ERR_LOCAL_PTR_NULL;
825     }
826     ret = CallRequestHandlerPtr_->CombineConference(mainCallId);
827     if (ret != TELEPHONY_SUCCESS) {
828         TELEPHONY_LOGE("CombineConference failed!");
829     }
830     return ret;
831 }
832 
SeparateConference(int32_t callId)833 int32_t CallControlManager::SeparateConference(int32_t callId)
834 {
835     sptr<CallBase> call = GetOneCallObject(callId);
836     if (call == nullptr) {
837         TELEPHONY_LOGE("GetOneCallObject failed, callId:%{public}d", callId);
838         return TELEPHONY_ERR_ARGUMENT_INVALID;
839     }
840     int32_t ret = call->CanSeparateConference();
841     if (ret != TELEPHONY_SUCCESS) {
842         TELEPHONY_LOGE("CanSeparateConference failed");
843         return ret;
844     }
845     if (CallRequestHandlerPtr_ == nullptr) {
846         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
847         return TELEPHONY_ERR_LOCAL_PTR_NULL;
848     }
849     ret = CallRequestHandlerPtr_->SeparateConference(callId);
850     if (ret != TELEPHONY_SUCCESS) {
851         TELEPHONY_LOGE("SeparateConference failed!");
852         return ret;
853     }
854     return TELEPHONY_SUCCESS;
855 }
856 
KickOutFromConference(int32_t callId)857 int32_t CallControlManager::KickOutFromConference(int32_t callId)
858 {
859     sptr<CallBase> call = GetOneCallObject(callId);
860     if (call == nullptr) {
861         TELEPHONY_LOGE("GetOneCallObject failed, callId:%{public}d", callId);
862         return TELEPHONY_ERR_ARGUMENT_INVALID;
863     }
864     int32_t ret = call->CanKickOutFromConference();
865     if (ret != TELEPHONY_SUCCESS) {
866         TELEPHONY_LOGE("CanKickOutFromConference failed");
867         return ret;
868     }
869     if (CallRequestHandlerPtr_ == nullptr) {
870         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
871         return TELEPHONY_ERR_LOCAL_PTR_NULL;
872     }
873     ret = CallRequestHandlerPtr_->KickOutFromConference(callId);
874     if (ret != TELEPHONY_SUCCESS) {
875         TELEPHONY_LOGE("KickOutFromConference failed!");
876         return ret;
877     }
878     return TELEPHONY_SUCCESS;
879 }
880 
GetMainCallId(int32_t callId,int32_t & mainCallId)881 int32_t CallControlManager::GetMainCallId(int32_t callId, int32_t &mainCallId)
882 {
883     sptr<CallBase> call = GetOneCallObject(callId);
884     if (call == nullptr) {
885         TELEPHONY_LOGE("GetMainCallId failed! callId:%{public}d", callId);
886         return TELEPHONY_ERR_ARGUMENT_INVALID;
887     }
888     return call->GetMainCallId(mainCallId);
889 }
890 
GetSubCallIdList(int32_t callId,std::vector<std::u16string> & callIdList)891 int32_t CallControlManager::GetSubCallIdList(int32_t callId, std::vector<std::u16string> &callIdList)
892 {
893     sptr<CallBase> call = GetOneCallObject(callId);
894     if (call == nullptr) {
895         TELEPHONY_LOGE("GetSubCallIdList failed! callId:%{public}d", callId);
896         return TELEPHONY_ERR_ARGUMENT_INVALID;
897     }
898     return call->GetSubCallIdList(callIdList);
899 }
900 
GetCallIdListForConference(int32_t callId,std::vector<std::u16string> & callIdList)901 int32_t CallControlManager::GetCallIdListForConference(int32_t callId, std::vector<std::u16string> &callIdList)
902 {
903     sptr<CallBase> call = GetOneCallObject(callId);
904     if (call == nullptr) {
905         TELEPHONY_LOGE("GetCallIdListForConference failed! callId:%{public}d", callId);
906         return TELEPHONY_ERR_ARGUMENT_INVALID;
907     }
908     return call->GetCallIdListForConference(callIdList);
909 }
910 
GetImsConfig(int32_t slotId,ImsConfigItem item)911 int32_t CallControlManager::GetImsConfig(int32_t slotId, ImsConfigItem item)
912 {
913     int32_t ret = CallPolicy::GetImsConfigPolicy(slotId);
914     if (ret != TELEPHONY_SUCCESS) {
915         TELEPHONY_LOGE("GetImsConfig failed!");
916         return ret;
917     }
918     if (callSettingManagerPtr_ != nullptr) {
919         return callSettingManagerPtr_->GetImsConfig(slotId, item);
920     } else {
921         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
922         return TELEPHONY_ERR_LOCAL_PTR_NULL;
923     }
924 }
925 
SetImsConfig(int32_t slotId,ImsConfigItem item,std::u16string & value)926 int32_t CallControlManager::SetImsConfig(int32_t slotId, ImsConfigItem item, std::u16string &value)
927 {
928     int32_t ret = CallPolicy::SetImsConfigPolicy(slotId);
929     if (ret != TELEPHONY_SUCCESS) {
930         TELEPHONY_LOGE("SetImsConfig failed!");
931         return ret;
932     }
933     if (callSettingManagerPtr_ != nullptr) {
934         return callSettingManagerPtr_->SetImsConfig(slotId, item, value);
935     } else {
936         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
937         return TELEPHONY_ERR_LOCAL_PTR_NULL;
938     }
939 }
940 
GetImsFeatureValue(int32_t slotId,FeatureType type)941 int32_t CallControlManager::GetImsFeatureValue(int32_t slotId, FeatureType type)
942 {
943     int32_t ret = CallPolicy::GetImsFeatureValuePolicy(slotId);
944     if (ret != TELEPHONY_SUCCESS) {
945         TELEPHONY_LOGE("GetImsFeatureValue failed!");
946         return ret;
947     }
948     if (callSettingManagerPtr_ != nullptr) {
949         return callSettingManagerPtr_->GetImsFeatureValue(slotId, type);
950     } else {
951         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
952         return TELEPHONY_ERR_LOCAL_PTR_NULL;
953     }
954 }
955 
SetImsFeatureValue(int32_t slotId,FeatureType type,int32_t value)956 int32_t CallControlManager::SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value)
957 {
958     int32_t ret = CallPolicy::SetImsFeatureValuePolicy(slotId);
959     if (ret != TELEPHONY_SUCCESS) {
960         TELEPHONY_LOGE("SetImsFeatureValue failed!");
961         return ret;
962     }
963     if (callSettingManagerPtr_ != nullptr) {
964         return callSettingManagerPtr_->SetImsFeatureValue(slotId, type, value);
965     } else {
966         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
967         return TELEPHONY_ERR_LOCAL_PTR_NULL;
968     }
969 }
970 
EnableImsSwitch(int32_t slotId)971 int32_t CallControlManager::EnableImsSwitch(int32_t slotId)
972 {
973     int32_t ret = CallPolicy::EnableVoLtePolicy(slotId);
974     if (ret != TELEPHONY_SUCCESS) {
975         TELEPHONY_LOGE("EnableImsSwitch failed!");
976         return ret;
977     }
978     if (callSettingManagerPtr_ != nullptr) {
979         return callSettingManagerPtr_->EnableImsSwitch(slotId);
980     } else {
981         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
982         return TELEPHONY_ERR_LOCAL_PTR_NULL;
983     }
984 }
985 
DisableImsSwitch(int32_t slotId)986 int32_t CallControlManager::DisableImsSwitch(int32_t slotId)
987 {
988     int32_t ret = CallPolicy::DisableVoLtePolicy(slotId);
989     if (ret != TELEPHONY_SUCCESS) {
990         TELEPHONY_LOGE("DisableImsSwitch failed!");
991         return ret;
992     }
993     if (callSettingManagerPtr_ != nullptr) {
994         return callSettingManagerPtr_->DisableImsSwitch(slotId);
995     } else {
996         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
997         return TELEPHONY_ERR_LOCAL_PTR_NULL;
998     }
999 }
1000 
IsImsSwitchEnabled(int32_t slotId,bool & enabled)1001 int32_t CallControlManager::IsImsSwitchEnabled(int32_t slotId, bool &enabled)
1002 {
1003     int32_t ret = CallPolicy::IsVoLteEnabledPolicy(slotId);
1004     if (ret != TELEPHONY_SUCCESS) {
1005         TELEPHONY_LOGE("IsImsSwitchEnabled failed!");
1006         return ret;
1007     }
1008     if (callSettingManagerPtr_ != nullptr) {
1009         return callSettingManagerPtr_->IsImsSwitchEnabled(slotId, enabled);
1010     } else {
1011         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1012         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1013     }
1014 }
1015 
SetVoNRState(int32_t slotId,int32_t state)1016 int32_t CallControlManager::SetVoNRState(int32_t slotId, int32_t state)
1017 {
1018     int32_t ret = CallPolicy::VoNRStatePolicy(slotId, state);
1019     if (ret != TELEPHONY_SUCCESS) {
1020         TELEPHONY_LOGE("SetVoNRState failed!");
1021         return ret;
1022     }
1023     if (callSettingManagerPtr_ != nullptr) {
1024         return callSettingManagerPtr_->SetVoNRState(slotId, state);
1025     } else {
1026         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1027         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1028     }
1029 }
1030 
GetVoNRState(int32_t slotId,int32_t & state)1031 int32_t CallControlManager::GetVoNRState(int32_t slotId, int32_t &state)
1032 {
1033     int32_t ret = CallPolicy::IsValidSlotId(slotId);
1034     if (ret != TELEPHONY_SUCCESS) {
1035         TELEPHONY_LOGE("SetVoNRState failed!");
1036         return ret;
1037     }
1038     if (callSettingManagerPtr_ != nullptr) {
1039         ret = callSettingManagerPtr_->GetVoNRState(slotId, state);
1040         if (ret == TELEPHONY_SUCCESS) {
1041             ret = CallPolicy::VoNRStatePolicy(slotId, state);
1042         }
1043         return ret;
1044     } else {
1045         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1046         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1047     }
1048 }
1049 
UpdateImsCallMode(int32_t callId,ImsCallMode mode)1050 int32_t CallControlManager::UpdateImsCallMode(int32_t callId, ImsCallMode mode)
1051 {
1052     return TELEPHONY_SUCCESS;
1053 }
1054 
StartRtt(int32_t callId,std::u16string & msg)1055 int32_t CallControlManager::StartRtt(int32_t callId, std::u16string &msg)
1056 {
1057     int32_t ret = CallPolicy::StartRttPolicy(callId);
1058     if (ret != TELEPHONY_SUCCESS) {
1059         TELEPHONY_LOGE("NO IMS call,can not StartRtt!");
1060         return ret;
1061     }
1062     if (CallRequestHandlerPtr_ == nullptr) {
1063         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
1064         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1065     }
1066     ret = CallRequestHandlerPtr_->StartRtt(callId, msg);
1067     if (ret != TELEPHONY_SUCCESS) {
1068         TELEPHONY_LOGE("StartRtt failed!");
1069         return ret;
1070     }
1071     return TELEPHONY_SUCCESS;
1072 }
1073 
StopRtt(int32_t callId)1074 int32_t CallControlManager::StopRtt(int32_t callId)
1075 {
1076     int32_t ret = CallPolicy::StopRttPolicy(callId);
1077     if (ret != TELEPHONY_SUCCESS) {
1078         TELEPHONY_LOGE("NO IMS call,no need StopRtt!");
1079         return ret;
1080     }
1081     if (CallRequestHandlerPtr_ == nullptr) {
1082         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
1083         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1084     }
1085     ret = CallRequestHandlerPtr_->StopRtt(callId);
1086     if (ret != TELEPHONY_SUCCESS) {
1087         TELEPHONY_LOGE("StopRtt failed!");
1088         return ret;
1089     }
1090     return TELEPHONY_SUCCESS;
1091 }
1092 
JoinConference(int32_t callId,std::vector<std::u16string> & numberList)1093 int32_t CallControlManager::JoinConference(int32_t callId, std::vector<std::u16string> &numberList)
1094 {
1095     if (CallRequestHandlerPtr_ == nullptr) {
1096         TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
1097         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1098     }
1099     std::vector<std::string> phoneNumberList(numberList.size());
1100     for (size_t index = 0; index < numberList.size(); ++index) {
1101         phoneNumberList[index] = Str16ToStr8(numberList[index]);
1102     }
1103     int32_t ret = CallPolicy::InviteToConferencePolicy(callId, phoneNumberList);
1104     if (ret != TELEPHONY_SUCCESS) {
1105         TELEPHONY_LOGE("check InviteToConference Policy failed!");
1106         return ret;
1107     }
1108     ret = CallRequestHandlerPtr_->JoinConference(callId, phoneNumberList);
1109     if (ret != TELEPHONY_SUCCESS) {
1110         TELEPHONY_LOGE("JoinConference failed!");
1111         return ret;
1112     }
1113     return TELEPHONY_SUCCESS;
1114 }
1115 
SetMuted(bool isMute)1116 int32_t CallControlManager::SetMuted(bool isMute)
1117 {
1118     sptr<CallBase> call = CallObjectManager::GetForegroundLiveCall();
1119     if (call == nullptr) {
1120         return CALL_ERR_AUDIO_SETTING_MUTE_FAILED;
1121     }
1122 
1123     if (call->GetCallType() == CallType::TYPE_VOIP) {
1124         TELEPHONY_LOGI("SetMute by voip");
1125         return call->SetMute(isMute, call->GetSlotId());
1126     }
1127     if (call->GetCallType() == CallType::TYPE_IMS
1128         || call->GetCallType() == CallType::TYPE_CS) {
1129         TELEPHONY_LOGI("SetMute by ims or cs,isMute = %{public}d", isMute);
1130         call->SetMute(isMute, call->GetSlotId());
1131     }
1132 
1133     return DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(isMute);
1134 }
1135 
MuteRinger()1136 int32_t CallControlManager::MuteRinger()
1137 {
1138     CallVoiceAssistantManager::GetInstance()->MuteRinger();
1139     return DelayedSingleton<AudioControlManager>::GetInstance()->MuteRinger();
1140 }
1141 
SetAudioDevice(const AudioDevice & audioDevice)1142 int32_t CallControlManager::SetAudioDevice(const AudioDevice &audioDevice)
1143 {
1144     return DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(audioDevice, true);
1145 }
1146 
ControlCamera(std::u16string cameraId,int32_t callingUid,int32_t callingPid)1147 int32_t CallControlManager::ControlCamera(std::u16string cameraId, int32_t callingUid, int32_t callingPid)
1148 {
1149     return TELEPHONY_SUCCESS;
1150 }
1151 
SetPreviewWindow(VideoWindow & window)1152 int32_t CallControlManager::SetPreviewWindow(VideoWindow &window)
1153 {
1154     return TELEPHONY_SUCCESS;
1155 }
1156 
SetDisplayWindow(VideoWindow & window)1157 int32_t CallControlManager::SetDisplayWindow(VideoWindow &window)
1158 {
1159     return TELEPHONY_SUCCESS;
1160 }
1161 
SetCameraZoom(float zoomRatio)1162 int32_t CallControlManager::SetCameraZoom(float zoomRatio)
1163 {
1164     return TELEPHONY_SUCCESS;
1165 }
1166 
SetPausePicture(std::u16string path)1167 int32_t CallControlManager::SetPausePicture(std::u16string path)
1168 {
1169     return TELEPHONY_SUCCESS;
1170 }
1171 
SetDeviceDirection(int32_t rotation)1172 int32_t CallControlManager::SetDeviceDirection(int32_t rotation)
1173 {
1174     return TELEPHONY_SUCCESS;
1175 }
1176 
IsEmergencyPhoneNumber(std::u16string & number,int32_t slotId,bool & enabled)1177 int32_t CallControlManager::IsEmergencyPhoneNumber(std::u16string &number, int32_t slotId, bool &enabled)
1178 {
1179     if (IsValidSlotId(slotId)) {
1180         return CALL_ERR_INVALID_SLOT_ID;
1181     }
1182     return DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(
1183         Str16ToStr8(number), slotId, enabled);
1184 }
1185 
FormatPhoneNumber(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)1186 int32_t CallControlManager::FormatPhoneNumber(
1187     std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
1188 {
1189     std::string tmpStr("");
1190     int32_t ret = DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(
1191         Str16ToStr8(number), Str16ToStr8(countryCode), tmpStr);
1192     formatNumber = Str8ToStr16(tmpStr);
1193     return ret;
1194 }
1195 
FormatPhoneNumberToE164(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)1196 int32_t CallControlManager::FormatPhoneNumberToE164(
1197     std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
1198 {
1199     std::string tmpStr("");
1200     int32_t ret = DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(
1201         Str16ToStr8(number), Str16ToStr8(countryCode), tmpStr);
1202     formatNumber = Str8ToStr16(tmpStr);
1203     return ret;
1204 }
1205 
CloseUnFinishedUssd(int32_t slotId)1206 int32_t CallControlManager::CloseUnFinishedUssd(int32_t slotId)
1207 {
1208     int32_t ret = CallPolicy::CloseUnFinishedUssdPolicy(slotId);
1209     if (ret != TELEPHONY_SUCCESS) {
1210         TELEPHONY_LOGE("CloseUnFinishedUssd failed!");
1211         return ret;
1212     }
1213     if (callSettingManagerPtr_ != nullptr) {
1214         return callSettingManagerPtr_->CloseUnFinishedUssd(slotId);
1215     } else {
1216         TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1217         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1218     }
1219 }
1220 
GetDialParaInfo(DialParaInfo & info)1221 void CallControlManager::GetDialParaInfo(DialParaInfo &info)
1222 {
1223     std::lock_guard<std::mutex> lock(mutex_);
1224     info = dialSrcInfo_;
1225 }
1226 
GetDialParaInfo(DialParaInfo & info,AppExecFwk::PacMap & extras)1227 void CallControlManager::GetDialParaInfo(DialParaInfo &info, AppExecFwk::PacMap &extras)
1228 {
1229     std::lock_guard<std::mutex> lock(mutex_);
1230     info = dialSrcInfo_;
1231     extras = extras_;
1232 }
1233 
handler()1234 void CallControlManager::handler()
1235 {
1236     alarmSeted = false;
1237     TELEPHONY_LOGE("handle DisconnectAbility");
1238     if (!CallObjectManager::HasCallExist()) {
1239         DelayedSingleton<CallConnectAbility>::GetInstance()->DisconnectAbility();
1240     }
1241 }
1242 
cancel(ffrt::task_handle & handle)1243 bool CallControlManager::cancel(ffrt::task_handle &handle)
1244 {
1245     if (handle != nullptr) {
1246         TELEPHONY_LOGI("skip disconnect ability task");
1247         int ret = ffrt::skip(handle);
1248         if (ret != TELEPHONY_SUCCESS) {
1249             TELEPHONY_LOGE("skip task failed, ret = %{public}d", ret);
1250             return false;
1251         }
1252     }
1253     return true;
1254 }
1255 
ConnectCallUiService(bool shouldConnect)1256 void CallControlManager::ConnectCallUiService(bool shouldConnect)
1257 {
1258     if (shouldConnect) {
1259         if (alarmSeted) {
1260             if (!cancel(disconnectHandle)) {
1261                 return;
1262             }
1263             alarmSeted = false;
1264         }
1265         DelayedSingleton<CallConnectAbility>::GetInstance()->ConnectAbility();
1266         shouldDisconnect = false;
1267     } else {
1268         shouldDisconnect = true;
1269         if (!alarmSeted) {
1270             TELEPHONY_LOGI("submit delay disconnect ability");
1271             disconnectHandle = ffrt::submit_h([&]() {
1272                 handler();
1273             }, {}, {}, ffrt::task_attr().delay(DISCONNECT_DELAY_TIME));
1274             alarmSeted = true;
1275         }  else {
1276             if (!cancel(disconnectHandle)) {
1277                 return;
1278             }
1279             TELEPHONY_LOGI("submit delay disconnect ability");
1280             disconnectHandle = ffrt::submit_h([&]() {
1281                 handler();
1282             }, {}, {}, ffrt::task_attr().delay(DISCONNECT_DELAY_TIME));
1283         }
1284     }
1285 }
1286 
ShouldDisconnectService()1287 bool CallControlManager::ShouldDisconnectService()
1288 {
1289     return shouldDisconnect;
1290 }
1291 
RemoveMissedIncomingCallNotification()1292 int32_t CallControlManager::RemoveMissedIncomingCallNotification()
1293 {
1294     int32_t ret = DelayedSingleton<CallRecordsManager>::GetInstance()->RemoveMissedIncomingCallNotification();
1295     if (ret != TELEPHONY_SUCCESS) {
1296         TELEPHONY_LOGE("RemoveMissedIncomingCallNotification failed!");
1297         return ret;
1298     }
1299     return TELEPHONY_SUCCESS;
1300 }
1301 
SetVoIPCallState(int32_t state)1302 int32_t CallControlManager::SetVoIPCallState(int32_t state)
1303 {
1304     VoIPCallState_ = (CallStateToApp)state;
1305     std::string identity = IPCSkeleton::ResetCallingIdentity();
1306     DelayedSingleton<CallStateReportProxy>::GetInstance()->UpdateCallStateForVoIPOrRestart();
1307     CallVoiceAssistantManager::GetInstance()->UpdateVoipCallState(state);
1308     IPCSkeleton::SetCallingIdentity(identity);
1309     if (VoIPCallState_ == CallStateToApp::CALL_STATE_ANSWERED) {
1310         TELEPHONY_LOGI("VoIP answered the call, should hangup all calls");
1311         std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
1312         for (auto call : allCallList) {
1313             int32_t ret = HangUpCall(call->GetCallID());
1314             if (ret != TELEPHONY_SUCCESS) {
1315                 return ret;
1316             }
1317         }
1318     }
1319     if (VoIPCallState_ == CallStateToApp::CALL_STATE_OFFHOOK) {
1320         HangUpVoipCall();
1321     }
1322     if (VoIPCallState_ == CallStateToApp::CALL_STATE_IDLE) {
1323         TELEPHONY_LOGI("VoIP call state is not active");
1324         if (AnsweredCallQueue_.hasCall == true) {
1325             TELEPHONY_LOGI("answer call now");
1326             AnsweredCallQueue_.hasCall = false;
1327             return AnswerCall(AnsweredCallQueue_.callId, AnsweredCallQueue_.videoState);
1328         }
1329     }
1330     return TELEPHONY_SUCCESS;
1331 }
1332 
HangUpVoipCall()1333 int32_t CallControlManager::HangUpVoipCall()
1334 {
1335     std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
1336     for (auto call : allCallList) {
1337         if (call != nullptr && call->GetCallType() == CallType::TYPE_VOIP) {
1338             TELEPHONY_LOGI("HangUp VoipCall callId %{public}d", call->GetCallID());
1339             int32_t ret = HangUpCall(call->GetCallID());
1340             if (ret != TELEPHONY_SUCCESS) {
1341                 TELEPHONY_LOGE("hangup voip call %{public}d failed!", call->GetCallID());
1342                 return ret;
1343             }
1344         }
1345     }
1346     return TELEPHONY_SUCCESS;
1347 }
1348 
GetVoIPCallState(int32_t & state)1349 int32_t CallControlManager::GetVoIPCallState(int32_t &state)
1350 {
1351     state = (int32_t)VoIPCallState_;
1352     return TELEPHONY_SUCCESS;
1353 }
1354 
CallStateObserve()1355 void CallControlManager::CallStateObserve()
1356 {
1357     if (callStateListenerPtr_ == nullptr) {
1358         TELEPHONY_LOGE("callStateListenerPtr_ is null");
1359         return;
1360     }
1361     std::shared_ptr<RejectCallSms> hangUpSmsPtr = std::make_shared<RejectCallSms>();
1362     if (hangUpSmsPtr == nullptr) {
1363         TELEPHONY_LOGE("hangUpSmsPtr is null");
1364         return;
1365     }
1366     callStateListenerPtr_->AddOneObserver(DelayedSingleton<CallAbilityReportProxy>::GetInstance());
1367     callStateListenerPtr_->AddOneObserver(DelayedSingleton<CallStateReportProxy>::GetInstance());
1368     callStateListenerPtr_->AddOneObserver(DelayedSingleton<AudioControlManager>::GetInstance());
1369     callStateListenerPtr_->AddOneObserver(hangUpSmsPtr);
1370     callStateListenerPtr_->AddOneObserver(missedCallNotification_);
1371     callStateListenerPtr_->AddOneObserver(incomingCallWakeup_);
1372     callStateListenerPtr_->AddOneObserver(DelayedSingleton<CallRecordsManager>::GetInstance());
1373     callStateListenerPtr_->AddOneObserver(CallVoiceAssistantManager::GetInstance());
1374 }
1375 
AddCallLogAndNotification(sptr<CallBase> & callObjectPtr)1376 int32_t CallControlManager::AddCallLogAndNotification(sptr<CallBase> &callObjectPtr)
1377 {
1378     if (callObjectPtr == nullptr) {
1379         TELEPHONY_LOGE("callObjectPtr is null");
1380         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1381     }
1382     callObjectPtr->SetAnswerType(CallAnswerType::CALL_ANSWER_MISSED);
1383     DelayedSingleton<CallRecordsManager>::GetInstance()
1384         ->CallStateUpdated(callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_DISCONNECTED);
1385     if (missedCallNotification_ == nullptr) {
1386         TELEPHONY_LOGE("missedCallNotification is null");
1387         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1388     }
1389     missedCallNotification_->PublishMissedCallEvent(callObjectPtr);
1390     missedCallNotification_->PublishMissedCallNotification(callObjectPtr);
1391     return TELEPHONY_SUCCESS;
1392 }
1393 
AddBlockLogAndNotification(sptr<CallBase> & callObjectPtr)1394 int32_t CallControlManager::AddBlockLogAndNotification(sptr<CallBase> &callObjectPtr)
1395 {
1396     if (callObjectPtr == nullptr) {
1397         TELEPHONY_LOGE("callObjectPtr is null");
1398         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1399     }
1400     callObjectPtr->SetAnswerType(CallAnswerType::CALL_ANSWER_BLOCKED);
1401     DelayedSingleton<CallRecordsManager>::GetInstance()
1402         ->CallStateUpdated(callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_DISCONNECTED);
1403     if (missedCallNotification_ == nullptr) {
1404         TELEPHONY_LOGE("missedCallNotification is null");
1405         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1406     }
1407     missedCallNotification_->PublishBlockedCallEvent(callObjectPtr);
1408     return TELEPHONY_SUCCESS;
1409 }
1410 
NumberLegalityCheck(std::string & number)1411 int32_t CallControlManager::NumberLegalityCheck(std::string &number)
1412 {
1413     if (number.empty()) {
1414         TELEPHONY_LOGE("phone number is NULL!");
1415         return CALL_ERR_PHONE_NUMBER_EMPTY;
1416     }
1417     if (number.length() > kMaxNumberLen) {
1418         TELEPHONY_LOGE(
1419             "the number length exceeds limit,len:%{public}zu,maxLen:%{public}d", number.length(), kMaxNumberLen);
1420         return CALL_ERR_NUMBER_OUT_OF_RANGE;
1421     }
1422     return TELEPHONY_SUCCESS;
1423 }
1424 
AcquireIncomingLock()1425 void CallControlManager::AcquireIncomingLock()
1426 {
1427     if (incomingCallWakeup_ == nullptr) {
1428         return;
1429     }
1430     incomingCallWakeup_->AcquireIncomingLock();
1431 }
1432 
ReleaseIncomingLock()1433 void CallControlManager::ReleaseIncomingLock()
1434 {
1435     if (incomingCallWakeup_ == nullptr) {
1436         return;
1437     }
1438     incomingCallWakeup_->ReleaseIncomingLock();
1439 }
1440 
SystemAbilityListener(std::shared_ptr<CallBroadcastSubscriber> subscriberPtr)1441 CallControlManager::SystemAbilityListener::SystemAbilityListener(std::shared_ptr<CallBroadcastSubscriber> subscriberPtr)
1442     : subscriberPtr_(subscriberPtr)
1443 {}
1444 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1445 void CallControlManager::SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
1446 {
1447     if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
1448         TELEPHONY_LOGE("systemAbilityId is not COMMON_EVENT_SERVICE_ID");
1449         return;
1450     }
1451 
1452     if (subscriberPtr_ == nullptr) {
1453         TELEPHONY_LOGE("CallControlManager::OnAddSystemAbility subscriberPtr is nullptr");
1454         return;
1455     }
1456 
1457     std::string identity = IPCSkeleton::ResetCallingIdentity();
1458     bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberPtr_);
1459     IPCSkeleton::SetCallingIdentity(identity);
1460     TELEPHONY_LOGI("CallControlManager::OnAddSystemAbility subscribeResult = %{public}d", subscribeResult);
1461 }
1462 
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1463 void CallControlManager::SystemAbilityListener::OnRemoveSystemAbility(
1464     int32_t systemAbilityId, const std::string &deviceId)
1465 {
1466     if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
1467         TELEPHONY_LOGE("systemAbilityId is not COMMON_EVENT_SERVICE_ID");
1468         return;
1469     }
1470 
1471     if (subscriberPtr_ == nullptr) {
1472         TELEPHONY_LOGE("CallControlManager::OnRemoveSystemAbility subscriberPtr is nullptr");
1473         return;
1474     }
1475     std::string identity = IPCSkeleton::ResetCallingIdentity();
1476     bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(subscriberPtr_);
1477     IPCSkeleton::SetCallingIdentity(identity);
1478     TELEPHONY_LOGI("CallControlManager::OnRemoveSystemAbility subscribeResult = %{public}d", subscribeResult);
1479 }
1480 
BroadcastSubscriber()1481 int32_t CallControlManager::BroadcastSubscriber()
1482 {
1483     EventFwk::MatchingSkills matchingSkills;
1484     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
1485     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED);
1486     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_NAME_UPDATE);
1487     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
1488     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1489     subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1490     std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
1491     if (subscriberPtr == nullptr) {
1492         TELEPHONY_LOGE("CallControlManager::BroadcastSubscriber subscriberPtr is nullptr");
1493         return TELEPHONY_ERROR;
1494     }
1495 
1496     EventFwk::MatchingSkills matchingSkill;
1497     matchingSkill.AddEvent("event.custom.contacts.PAGE_STATE_CHANGE");
1498     EventFwk::CommonEventSubscribeInfo subscriberInfomation(matchingSkill);
1499     subscriberInfomation.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1500     subscriberInfomation.SetPermission("ohos.permission.SET_TELEPHONY_STATE");
1501     std::shared_ptr<CallBroadcastSubscriber> subscriber =
1502         std::make_shared<CallBroadcastSubscriber>(subscriberInfomation);
1503     if (subscriber == nullptr) {
1504         TELEPHONY_LOGE("CallControlManager::BroadcastSubscriber subscriber is nullptr");
1505         return TELEPHONY_ERROR;
1506     }
1507 
1508     EventFwk::MatchingSkills matchingSkills_;
1509     matchingSkills_.AddEvent("usual.event.thermal.satcomm.HIGH_TEMP_LEVEL");
1510     EventFwk::CommonEventSubscribeInfo subscriberInfo_(matchingSkills_);
1511     subscriberInfo_.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1512     subscriberInfo_.SetPublisherUid(SATCOMM_UID);
1513     std::shared_ptr<CallBroadcastSubscriber> subscriberPtr_ =
1514         std::make_shared<CallBroadcastSubscriber>(subscriberInfo_);
1515     if (subscriberPtr_ == nullptr) {
1516         TELEPHONY_LOGE("CallControlManager::BroadcastSubscriber subscriberPtr_ is nullptr");
1517         return TELEPHONY_ERROR;
1518     }
1519 
1520     EventFwk::MatchingSkills matchingSkill_;
1521     matchingSkill_.AddEvent("usual.event.SUPER_PRIVACY_MODE");
1522     EventFwk::CommonEventSubscribeInfo subscriberInfos_(matchingSkill_);
1523     subscriberInfos_.SetPublisherBundleName("com.settings");
1524     subscriberInfos_.SetPermission("ohos.permission.SET_TELEPHONY_STATE");
1525     subscriberInfos_.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1526     std::shared_ptr<CallBroadcastSubscriber> subscriberPtrs_ =
1527         std::make_shared<CallBroadcastSubscriber>(subscriberInfos_);
1528     if (subscriberPtrs_ == nullptr) {
1529         TELEPHONY_LOGE("CallControlManager::BroadcastSubscriber subscriberPtrs_ is nullptr");
1530         return TELEPHONY_ERROR;
1531     }
1532 
1533     // if SubscribeCommonEvent fail, register statusChangeListener to SubscribeCommonEvent again
1534     auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1535     if (samgrProxy == nullptr) {
1536         TELEPHONY_LOGE("samgrProxy is nullptr");
1537         return TELEPHONY_ERROR;
1538     }
1539     statusChangeListener_ = new (std::nothrow) SystemAbilityListener(subscriberPtr);
1540     if (statusChangeListener_ == nullptr) {
1541         TELEPHONY_LOGE("statusChangeListener_ is nullptr");
1542         return TELEPHONY_ERROR;
1543     }
1544     pageStateChangeListener_ = new (std::nothrow) SystemAbilityListener(subscriber);
1545     if (pageStateChangeListener_ == nullptr) {
1546         TELEPHONY_LOGE("pageStateChangeListener_ is nullptr");
1547         return TELEPHONY_ERROR;
1548     }
1549     satcommEventListener_ =
1550         new (std::nothrow) SystemAbilityListener(subscriberPtr_);
1551     if (satcommEventListener_ == nullptr) {
1552         TELEPHONY_LOGE("satcommEventListener_ is nullptr");
1553         return TELEPHONY_ERROR;
1554     }
1555     superPrivacyEventListener_ =
1556         new (std::nothrow) SystemAbilityListener(subscriberPtrs_);
1557     if (superPrivacyEventListener_ == nullptr) {
1558         TELEPHONY_LOGE("superPrivacyEventListener_ is nullptr");
1559         return TELEPHONY_ERROR;
1560     }
1561     int32_t ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_);
1562     TELEPHONY_LOGI("CallControlManager::BroadcastSubscriber statusChangeListener_ ret: %{public}d", ret);
1563     ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, pageStateChangeListener_);
1564     TELEPHONY_LOGI("CallControlManager::BroadcastSubscriber pageStateChangeListener_ ret: %{public}d", ret);
1565     ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, satcommEventListener_);
1566     TELEPHONY_LOGI("CallControlManager::BroadcastSubscriber satcommEventListener_ ret: %{public}d", ret);
1567     ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, superPrivacyEventListener_);
1568     TELEPHONY_LOGI("CallControlManager::BroadcastSubscriber superPrivacyEventListener_ ret: %{public}d", ret);
1569     return TELEPHONY_SUCCESS;
1570 }
1571 
1572 #ifdef ABILITY_MEDIA_SUPPORT
onButtonDealing(HeadsetButtonService::ButtonEvent type)1573 bool CallControlManager::onButtonDealing(HeadsetButtonService::ButtonEvent type)
1574 {
1575     bool isRingState = false;
1576     sptr<CallBase> call = nullptr;
1577 
1578     if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING) != nullptr) {
1579         call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
1580         isRingState = true;
1581     } else if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING) != nullptr) {
1582         call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
1583     } else if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE) != nullptr) {
1584         call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
1585     } else if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD) != nullptr) {
1586         call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
1587     } else {
1588         return false;
1589     }
1590 
1591     switch (type) {
1592         case HeadsetButtonService::SHORT_PRESS_EVENT:
1593             if (isRingState) {
1594                 call->HangUpCall();
1595             } else {
1596                 call->AnswerCall(0);
1597             }
1598             break;
1599         case HeadsetButtonService::LONG_PRESS_EVENT:
1600             if (isRingState) {
1601                 std::string str = "";
1602                 call->RejectCall(false, str);
1603             } else {
1604                 DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(true);
1605             }
1606             break;
1607         default:
1608             return false;
1609     }
1610     return true;
1611 }
1612 #endif
1613 } // namespace Telephony
1614 } // namespace OHOS
1615