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
48namespace OHOS {
49namespace Telephony {
50bool CallControlManager::alarmSeted = false;
51constexpr int32_t CRS_TYPE = 2;
52const uint64_t DISCONNECT_DELAY_TIME = 1000000;
53static const int32_t SATCOMM_UID = 1096;
54using namespace OHOS::EventFwk;
55CallControlManager::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
65CallControlManager::~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
82bool 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
121int32_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
171int32_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
186void 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
203int32_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
257bool 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
271void 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
292int32_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
332int32_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
365int32_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
415int32_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
430int32_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
449int32_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
469int32_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
488bool CallControlManager::HasCall()
489{
490    return HasCellularCallExist();
491}
492
493int32_t CallControlManager::IsNewCallAllowed(bool &enabled)
494{
495    return IsNewCallAllowedCreate(enabled);
496}
497
498int32_t CallControlManager::IsRinging(bool &enabled)
499{
500    return HasRingingCall(enabled);
501}
502
503int32_t CallControlManager::HasEmergency(bool &enabled)
504{
505    return HasEmergencyCall(enabled);
506}
507
508bool 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
520bool CallControlManager::NotifyCallDestroyed(const DisconnectedDetails &details)
521{
522    if (callStateListenerPtr_ != nullptr) {
523        callStateListenerPtr_->CallDestroyed(details);
524        return true;
525    }
526    return false;
527}
528
529bool 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
567bool 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
582bool 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
596bool CallControlManager::NotifyCallEventUpdated(CallEventInfo &info)
597{
598    if (callStateListenerPtr_ != nullptr) {
599        callStateListenerPtr_->CallEventUpdated(info);
600        return true;
601    }
602    return false;
603}
604
605int32_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
625int32_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
643int32_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
660int32_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
675int32_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
690int32_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
705int32_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
720int32_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
736int32_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
751int32_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
766int32_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
781int32_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 */
803int32_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
834int32_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
858int32_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
882int32_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
892int32_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
902int32_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
912int32_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
927int32_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
942int32_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
957int32_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
972int32_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
987int32_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
1002int32_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
1017int32_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
1032int32_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
1051int32_t CallControlManager::UpdateImsCallMode(int32_t callId, ImsCallMode mode)
1052{
1053    return TELEPHONY_SUCCESS;
1054}
1055
1056int32_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
1075int32_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
1094int32_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
1117int32_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
1137int32_t CallControlManager::MuteRinger()
1138{
1139    CallVoiceAssistantManager::GetInstance()->MuteRinger();
1140    return DelayedSingleton<AudioControlManager>::GetInstance()->MuteRinger();
1141}
1142
1143int32_t CallControlManager::SetAudioDevice(const AudioDevice &audioDevice)
1144{
1145    return DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(audioDevice, true);
1146}
1147
1148int32_t CallControlManager::ControlCamera(std::u16string cameraId, int32_t callingUid, int32_t callingPid)
1149{
1150    return TELEPHONY_SUCCESS;
1151}
1152
1153int32_t CallControlManager::SetPreviewWindow(VideoWindow &window)
1154{
1155    return TELEPHONY_SUCCESS;
1156}
1157
1158int32_t CallControlManager::SetDisplayWindow(VideoWindow &window)
1159{
1160    return TELEPHONY_SUCCESS;
1161}
1162
1163int32_t CallControlManager::SetCameraZoom(float zoomRatio)
1164{
1165    return TELEPHONY_SUCCESS;
1166}
1167
1168int32_t CallControlManager::SetPausePicture(std::u16string path)
1169{
1170    return TELEPHONY_SUCCESS;
1171}
1172
1173int32_t CallControlManager::SetDeviceDirection(int32_t rotation)
1174{
1175    return TELEPHONY_SUCCESS;
1176}
1177
1178int32_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
1187int32_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
1197int32_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
1207int32_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
1222void CallControlManager::GetDialParaInfo(DialParaInfo &info)
1223{
1224    std::lock_guard<std::mutex> lock(mutex_);
1225    info = dialSrcInfo_;
1226}
1227
1228void CallControlManager::GetDialParaInfo(DialParaInfo &info, AppExecFwk::PacMap &extras)
1229{
1230    std::lock_guard<std::mutex> lock(mutex_);
1231    info = dialSrcInfo_;
1232    extras = extras_;
1233}
1234
1235void CallControlManager::handler()
1236{
1237    alarmSeted = false;
1238    TELEPHONY_LOGE("handle DisconnectAbility");
1239    if (!CallObjectManager::HasCallExist()) {
1240        DelayedSingleton<CallConnectAbility>::GetInstance()->DisconnectAbility();
1241    }
1242}
1243
1244bool 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
1257void 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
1288bool CallControlManager::ShouldDisconnectService()
1289{
1290    return shouldDisconnect;
1291}
1292
1293int32_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
1303int32_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
1334int32_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
1354int32_t CallControlManager::GetVoIPCallState(int32_t &state)
1355{
1356    state = (int32_t)VoIPCallState_;
1357    return TELEPHONY_SUCCESS;
1358}
1359
1360void 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
1382int32_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
1400int32_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
1417int32_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
1431void CallControlManager::AcquireIncomingLock()
1432{
1433    if (incomingCallWakeup_ == nullptr) {
1434        return;
1435    }
1436    incomingCallWakeup_->AcquireIncomingLock();
1437}
1438
1439void CallControlManager::ReleaseIncomingLock()
1440{
1441    if (incomingCallWakeup_ == nullptr) {
1442        return;
1443    }
1444    incomingCallWakeup_->ReleaseIncomingLock();
1445}
1446
1447CallControlManager::SystemAbilityListener::SystemAbilityListener(std::shared_ptr<CallBroadcastSubscriber> subscriberPtr)
1448    : subscriberPtr_(subscriberPtr)
1449{}
1450
1451void 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
1468void 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
1486int32_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
1577bool 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