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