1/*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "call_status_manager.h"
17
18#include <securec.h>
19
20#include "audio_control_manager.h"
21#include "bluetooth_call_service.h"
22#include "call_ability_report_proxy.h"
23#include "call_control_manager.h"
24#include "call_manager_errors.h"
25#include "call_manager_hisysevent.h"
26#include "call_number_utils.h"
27#include "call_request_event_handler_helper.h"
28#include "core_service_client.h"
29#include "cs_call.h"
30#include "datashare_predicates.h"
31#include "hitrace_meter.h"
32#include "ims_call.h"
33#include "os_account_manager.h"
34#include "ott_call.h"
35#include "report_call_info_handler.h"
36#include "satellite_call.h"
37#include "satellite_call_control.h"
38#include "settings_datashare_helper.h"
39#include "telephony_log_wrapper.h"
40#include "call_number_utils.h"
41#include "voip_call.h"
42#include "uri.h"
43#include "ffrt.h"
44#include "parameters.h"
45#include "spam_call_adapter.h"
46#include "call_superprivacy_control_manager.h"
47#include "notification_helper.h"
48#include "call_earthquake_alarm_locator.h"
49#include "distributed_communication_manager.h"
50#include "want_params_wrapper.h"
51
52namespace OHOS {
53namespace Telephony {
54constexpr int32_t INIT_INDEX = 0;
55CallStatusManager::CallStatusManager()
56{
57    (void)memset_s(&callReportInfo_, sizeof(CallDetailInfo), 0, sizeof(CallDetailInfo));
58    for (int32_t i = 0; i < SLOT_NUM; i++) {
59        (void)memset_s(&callDetailsInfo_[i], sizeof(CallDetailsInfo), 0, sizeof(CallDetailsInfo));
60    }
61}
62
63CallStatusManager::~CallStatusManager()
64{
65    UnInit();
66}
67
68int32_t CallStatusManager::Init()
69{
70    for (int32_t i = 0; i < SLOT_NUM; i++) {
71        callDetailsInfo_[i].callVec.clear();
72        tmpCallDetailsInfo_[i].callVec.clear();
73    }
74    for (int32_t i = 0; i < SLOT_NUM; i++) {
75        priorVideoState_[i] = VideoStateType::TYPE_VOICE;
76    }
77    mEventIdTransferMap_.clear();
78    mOttEventIdTransferMap_.clear();
79    InitCallBaseEvent();
80    CallIncomingFilterManagerPtr_ = (std::make_unique<CallIncomingFilterManager>()).release();
81    return TELEPHONY_SUCCESS;
82}
83
84void CallStatusManager::InitCallBaseEvent()
85{
86    mEventIdTransferMap_[RequestResultEventId::RESULT_DIAL_NO_CARRIER] = CallAbilityEventId::EVENT_DIAL_NO_CARRIER;
87    mEventIdTransferMap_[RequestResultEventId::RESULT_HOLD_SEND_FAILED] = CallAbilityEventId::EVENT_HOLD_CALL_FAILED;
88    mEventIdTransferMap_[RequestResultEventId::RESULT_SWAP_SEND_FAILED] = CallAbilityEventId::EVENT_SWAP_CALL_FAILED;
89    mOttEventIdTransferMap_[OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED] =
90        CallAbilityEventId::EVENT_OTT_FUNCTION_UNSUPPORTED;
91    mEventIdTransferMap_[RequestResultEventId::RESULT_COMBINE_SEND_FAILED] =
92        CallAbilityEventId::EVENT_COMBINE_CALL_FAILED;
93    mEventIdTransferMap_[RequestResultEventId::RESULT_SPLIT_SEND_FAILED] =
94        CallAbilityEventId::EVENT_SPLIT_CALL_FAILED;
95}
96
97int32_t CallStatusManager::UnInit()
98{
99    for (int32_t i = 0; i < SLOT_NUM; i++) {
100        callDetailsInfo_[i].callVec.clear();
101        tmpCallDetailsInfo_[i].callVec.clear();
102    }
103    mEventIdTransferMap_.clear();
104    mOttEventIdTransferMap_.clear();
105    return TELEPHONY_SUCCESS;
106}
107
108int32_t CallStatusManager::HandleCallReportInfo(const CallDetailInfo &info)
109{
110    int32_t ret = TELEPHONY_ERR_FAIL;
111    callReportInfo_ = info;
112    if (info.callType == CallType::TYPE_VOIP) {
113        ret = HandleVoipCallReportInfo(info);
114        return ret;
115    }
116    switch (info.state) {
117        case TelCallState::CALL_STATUS_ACTIVE:
118            ret = ActiveHandle(info);
119            break;
120        case TelCallState::CALL_STATUS_HOLDING:
121            ret = HoldingHandle(info);
122            break;
123        case TelCallState::CALL_STATUS_DIALING: {
124            ret = DialingHandle(info);
125            FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
126            DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingDialTimeOut(
127                info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
128            break;
129        }
130        case TelCallState::CALL_STATUS_ALERTING:
131            ret = AlertHandle(info);
132            break;
133        case TelCallState::CALL_STATUS_INCOMING: {
134            DelayedSingleton<CallControlManager>::GetInstance()->AcquireIncomingLock();
135            ret = IncomingHandle(info);
136            DelayedSingleton<CallControlManager>::GetInstance()->ReleaseIncomingLock();
137            FinishAsyncTrace(HITRACE_TAG_OHOS, "InComingCall", getpid());
138            DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingIncomingTimeOut(
139                info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
140            break;
141        }
142        case TelCallState::CALL_STATUS_WAITING:
143            ret = WaitingHandle(info);
144            break;
145        case TelCallState::CALL_STATUS_DISCONNECTED:
146            ret = DisconnectedHandle(info);
147            break;
148        case TelCallState::CALL_STATUS_DISCONNECTING:
149            ret = DisconnectingHandle(info);
150            break;
151        default:
152            TELEPHONY_LOGE("Invalid call state!");
153            break;
154    }
155    TELEPHONY_LOGI("Entry CallStatusManager HandleCallReportInfo");
156    HandleDsdaInfo(info.accountId);
157    DelayedSingleton<BluetoothCallService>::GetInstance()->GetCallState();
158    TELEPHONY_LOGI("End CallStatusManager HandleCallReportInfo");
159    return ret;
160}
161
162void CallStatusManager::HandleDsdaInfo(int32_t slotId)
163{
164    int32_t dsdsMode = DSDS_MODE_V2;
165    bool noOtherCall = true;
166    std::list<int32_t> callIdList;
167    GetCarrierCallList(callIdList);
168    int32_t currentCallNum = GetCurrentCallNum();
169    DelayedSingleton<CallRequestProcess>::GetInstance()->IsExistCallOtherSlot(callIdList, slotId, noOtherCall);
170    DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
171    TELEPHONY_LOGI("dsdsMode:%{public}d", dsdsMode);
172    if ((dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
173            dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) &&
174        !noOtherCall) {
175        TELEPHONY_LOGI("Handle DsdaCallInfo");
176        sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
177        if (holdCall != nullptr && currentCallNum > CALL_NUMBER) {
178            holdCall->SetCanUnHoldState(false);
179        }
180    }
181}
182
183// handle call state changes, incoming call, outgoing call.
184int32_t CallStatusManager::HandleCallsReportInfo(const CallDetailsInfo &info)
185{
186    bool flag = false;
187    TELEPHONY_LOGI("call list size:%{public}zu,slotId:%{public}d", info.callVec.size(), info.slotId);
188    int32_t curSlotId = info.slotId;
189    if (!DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(curSlotId)) {
190        TELEPHONY_LOGE("invalid slotId!");
191        return CALL_ERR_INVALID_SLOT_ID;
192    }
193    tmpCallDetailsInfo_[curSlotId].callVec.clear();
194    tmpCallDetailsInfo_[curSlotId] = info;
195    for (auto &it : info.callVec) {
196        for (const auto &it1 : callDetailsInfo_[curSlotId].callVec) {
197            if (it.index == it1.index) {
198                // call state changes
199                if (it.state != it1.state || it.mpty != it1.mpty || it.callType != it1.callType
200                    || it.callMode != it1.callMode || it.state == TelCallState::CALL_STATUS_ALERTING) {
201                    TELEPHONY_LOGI("handle updated call state:%{public}d", it.state);
202                    HandleCallReportInfo(it);
203                }
204                flag = true;
205                break;
206            }
207        }
208        // incoming/outgoing call handle
209        if (!flag || callDetailsInfo_[curSlotId].callVec.empty()) {
210            TELEPHONY_LOGI("handle new call state:%{public}d", it.state);
211            HandleCallReportInfo(it);
212        }
213        flag = false;
214    }
215    // disconnected calls handle
216    for (auto &it2 : callDetailsInfo_[curSlotId].callVec) {
217        for (const auto &it3 : info.callVec) {
218            if (it2.index == it3.index) {
219                TELEPHONY_LOGI("state:%{public}d", it2.state);
220                flag = true;
221                break;
222            }
223        }
224        if (!flag) {
225            it2.state = TelCallState::CALL_STATUS_DISCONNECTED;
226            HandleCallReportInfo(it2);
227        }
228        flag = false;
229    }
230    UpdateCallDetailsInfo(info);
231    return TELEPHONY_SUCCESS;
232}
233
234void CallStatusManager::UpdateCallDetailsInfo(const CallDetailsInfo &info)
235{
236    int32_t curSlotId = info.slotId;
237    callDetailsInfo_[curSlotId].callVec.clear();
238    callDetailsInfo_[curSlotId] = info;
239    auto condition = [](CallDetailInfo i) { return i.state == TelCallState::CALL_STATUS_DISCONNECTED; };
240    auto it_end = std::remove_if(callDetailsInfo_[curSlotId].callVec.begin(),
241        callDetailsInfo_[curSlotId].callVec.end(), condition);
242    callDetailsInfo_[curSlotId].callVec.erase(it_end, callDetailsInfo_[curSlotId].callVec.end());
243    if (callDetailsInfo_[curSlotId].callVec.empty()) {
244        TELEPHONY_LOGI("clear tmpCallDetailsInfo");
245        tmpCallDetailsInfo_[curSlotId].callVec.clear();
246    }
247    TELEPHONY_LOGI("End CallStatusManager HandleCallsReportInfo slotId:%{public}d, "
248        "callDetailsInfo_ size:%{public}zu", info.slotId, callDetailsInfo_[curSlotId].callVec.size());
249}
250
251int32_t CallStatusManager::HandleVoipCallReportInfo(const CallDetailInfo &info)
252{
253    TELEPHONY_LOGI("Entry CallStatusManager HandleVoipCallReportInfo");
254    int32_t ret = TELEPHONY_ERR_FAIL;
255    switch (info.state) {
256        case TelCallState::CALL_STATUS_ACTIVE:
257            ret = ActiveVoipCallHandle(info);
258            break;
259        case TelCallState::CALL_STATUS_INCOMING: {
260            ret = IncomingVoipCallHandle(info);
261            break;
262        }
263        case TelCallState::CALL_STATUS_DISCONNECTED:
264            ret = DisconnectedVoipCallHandle(info);
265            break;
266        case TelCallState::CALL_STATUS_DIALING:
267            ret = OutgoingVoipCallHandle(info);
268            break;
269        case TelCallState::CALL_STATUS_ANSWERED:
270            ret = AnsweredVoipCallHandle(info);
271            break;
272        case TelCallState::CALL_STATUS_DISCONNECTING:
273            ret = DisconnectingVoipCallHandle(info);
274            break;
275        default:
276            TELEPHONY_LOGE("Invalid call state!");
277            break;
278    }
279    return ret;
280}
281
282int32_t CallStatusManager::HandleDisconnectedCause(const DisconnectedDetails &details)
283{
284    bool ret = DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallDestroyed(details);
285    if (!ret) {
286        TELEPHONY_LOGI("NotifyCallDestroyed failed!");
287        return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
288    }
289    return TELEPHONY_SUCCESS;
290}
291
292int32_t CallStatusManager::HandleEventResultReportInfo(const CellularCallEventInfo &info)
293{
294    if (info.eventType != CellularCallEventType::EVENT_REQUEST_RESULT_TYPE) {
295        TELEPHONY_LOGE("unexpected type event occurs, eventId:%{public}d", info.eventId);
296        return CALL_ERR_PHONE_TYPE_UNEXPECTED;
297    }
298    TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.eventId);
299    sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
300    if (call != nullptr) {
301        int32_t ret = DealFailDial(call);
302        TELEPHONY_LOGI("DealFailDial ret:%{public}d", ret);
303    }
304    CallEventInfo eventInfo;
305    (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
306    if (mEventIdTransferMap_.find(info.eventId) != mEventIdTransferMap_.end()) {
307        eventInfo.eventId = mEventIdTransferMap_[info.eventId];
308        DialParaInfo dialInfo;
309        if (eventInfo.eventId == CallAbilityEventId::EVENT_DIAL_NO_CARRIER) {
310            DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(dialInfo);
311            if (dialInfo.number.length() > static_cast<size_t>(kMaxNumberLen)) {
312                TELEPHONY_LOGE("Number out of limit!");
313                return CALL_ERR_NUMBER_OUT_OF_RANGE;
314            }
315            if (memcpy_s(eventInfo.phoneNum, kMaxNumberLen, dialInfo.number.c_str(), dialInfo.number.length()) != EOK) {
316                TELEPHONY_LOGE("memcpy_s failed!");
317                return TELEPHONY_ERR_MEMCPY_FAIL;
318            }
319        } else if (eventInfo.eventId == CallAbilityEventId::EVENT_COMBINE_CALL_FAILED) {
320            sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
321            if (activeCall != nullptr) {
322                activeCall->HandleCombineConferenceFailEvent();
323            }
324        } else if (eventInfo.eventId == CallAbilityEventId::EVENT_HOLD_CALL_FAILED) {
325            needWaitHold_ = false;
326        }
327        DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
328    } else {
329        TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.eventId);
330    }
331    return TELEPHONY_SUCCESS;
332}
333
334int32_t CallStatusManager::HandleOttEventReportInfo(const OttCallEventInfo &info)
335{
336    TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.ottCallEventId);
337    CallEventInfo eventInfo;
338    (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
339    if (mOttEventIdTransferMap_.find(info.ottCallEventId) != mOttEventIdTransferMap_.end()) {
340        eventInfo.eventId = mOttEventIdTransferMap_[info.ottCallEventId];
341        if (strlen(info.bundleName) > static_cast<size_t>(kMaxNumberLen)) {
342            TELEPHONY_LOGE("Number out of limit!");
343            return CALL_ERR_NUMBER_OUT_OF_RANGE;
344        }
345        if (memcpy_s(eventInfo.bundleName, kMaxNumberLen, info.bundleName, strlen(info.bundleName)) != EOK) {
346            TELEPHONY_LOGE("memcpy_s failed!");
347            return TELEPHONY_ERR_MEMCPY_FAIL;
348        }
349        DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
350    } else {
351        TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.ottCallEventId);
352    }
353    return TELEPHONY_SUCCESS;
354}
355
356int32_t CallStatusManager::HandleVoipEventReportInfo(const VoipCallEventInfo &info)
357{
358    TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.voipCallEvent);
359    sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallId, info.bundleName, info.uid);
360    if (call == nullptr) {
361        TELEPHONY_LOGE("voip call is null");
362        return TELEPHONY_ERR_LOCAL_PTR_NULL;
363    }
364    if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_ACTIVE
365        && call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_DIALING) {
366        return TELEPHONY_ERR_FAIL;
367    }
368    if (info.voipCallEvent == VoipCallEvent::VOIP_CALL_EVENT_MUTED) {
369        call->SetMicPhoneState(true);
370    } else if (info.voipCallEvent == VoipCallEvent::VOIP_CALL_EVENT_UNMUTED) {
371        call->SetMicPhoneState(false);
372    }
373    DelayedSingleton<AudioDeviceManager>::GetInstance()->ReportAudioDeviceInfo(call);
374    return TELEPHONY_SUCCESS;
375}
376
377int32_t CallStatusManager::IncomingHandle(const CallDetailInfo &info)
378{
379    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
380    if (call != nullptr) {
381        auto oldCallType = call->GetCallType();
382        auto videoState = call->GetVideoStateType();
383        if (oldCallType != info.callType || call->GetTelCallState() != info.state || videoState != info.callMode) {
384            call = RefreshCallIfNecessary(call, info);
385            if (oldCallType != info.callType || videoState != info.callMode) {
386                return UpdateCallState(call, info.state);
387            }
388        }
389        return TELEPHONY_SUCCESS;
390    }
391    int32_t ret = TELEPHONY_SUCCESS;
392    if (info.callType == CallType::TYPE_CS || info.callType == CallType::TYPE_IMS ||
393        info.callType == CallType::TYPE_SATELLITE) {
394        ret = IncomingFilterPolicy(info);
395        if (ret != TELEPHONY_SUCCESS) {
396            return ret;
397        }
398    }
399    call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
400    if (call == nullptr) {
401        TELEPHONY_LOGE("CreateNewCall failed!");
402        return CALL_ERR_CALL_OBJECT_IS_NULL;
403    }
404    SetContactInfo(call, std::string(info.phoneNum));
405    bool block = false;
406    if (IsRejectCall(call, info, block)) {
407        return HandleRejectCall(call, block);
408    }
409    if (info.callType != CallType::TYPE_VOIP && IsRingOnceCall(call, info)) {
410        return HandleRingOnceCall(call);
411    }
412    AddOneCallObject(call);
413    DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
414    ret = UpdateCallState(call, info.state);
415    if (ret != TELEPHONY_SUCCESS) {
416        TELEPHONY_LOGE("UpdateCallState failed!");
417        return ret;
418    }
419    ret = FilterResultsDispose(call);
420    if (ret != TELEPHONY_SUCCESS) {
421        TELEPHONY_LOGE("FilterResultsDispose failed!");
422    }
423    return ret;
424}
425
426void CallStatusManager::SetContactInfo(sptr<CallBase> &call, std::string phoneNum)
427{
428    if (call == nullptr) {
429        TELEPHONY_LOGE("CreateVoipCall failed!");
430        return;
431    }
432    ffrt::submit([=, &call]() {
433        sptr<CallBase> callObjectPtr = call;
434        // allow list filtering
435        // Get the contact data from the database
436        ContactInfo contactInfo = {
437            .name = "",
438            .number = phoneNum,
439            .isContacterExists = false,
440            .ringtonePath = "",
441            .isSendToVoicemail = false,
442            .isEcc = false,
443            .isVoiceMail = false,
444            .isQueryComplete = true,
445        };
446        QueryCallerInfo(contactInfo, phoneNum);
447        callObjectPtr->SetCallerInfo(contactInfo);
448        DelayedSingleton<DistributedCommunicationManager>::GetInstance()->ProcessCallInfo(callObjectPtr,
449            DistributedDataType::NAME);
450    });
451}
452
453int32_t CallStatusManager::HandleRejectCall(sptr<CallBase> &call, bool isBlock)
454{
455    if (call == nullptr) {
456        TELEPHONY_LOGE("call is nullptr!");
457        return TELEPHONY_ERR_LOCAL_PTR_NULL;
458    }
459    int32_t ret = call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
460    if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
461        TELEPHONY_LOGE("Set CallState failed!");
462        return ret;
463    }
464    ret = call->RejectCall();
465    if (ret != TELEPHONY_SUCCESS) {
466        TELEPHONY_LOGE("RejectCall failed!");
467        return ret;
468    }
469    if (isBlock) {
470        return DelayedSingleton<CallControlManager>::GetInstance()->AddBlockLogAndNotification(call);
471    }
472    return DelayedSingleton<CallControlManager>::GetInstance()->AddCallLogAndNotification(call);
473}
474
475int32_t CallStatusManager::IncomingVoipCallHandle(const CallDetailInfo &info)
476{
477    int32_t ret = TELEPHONY_ERROR;
478    sptr<CallBase> call = GetOneCallObjectByVoipCallId(
479        info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
480    if (call != nullptr) {
481        return TELEPHONY_SUCCESS;
482    }
483    call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
484    if (call == nullptr) {
485        TELEPHONY_LOGE("CreateVoipCall failed!");
486        return CALL_ERR_CALL_OBJECT_IS_NULL;
487    }
488    AddOneCallObject(call);
489    DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
490    ret = UpdateCallState(call, info.state);
491    if (ret != TELEPHONY_SUCCESS) {
492        TELEPHONY_LOGE("UpdateCallState failed!");
493        return ret;
494    }
495    return ret;
496}
497
498int32_t CallStatusManager::OutgoingVoipCallHandle(const CallDetailInfo &info)
499{
500    int32_t ret = TELEPHONY_ERROR;
501    sptr<CallBase> call = GetOneCallObjectByVoipCallId(
502        info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
503    if (call != nullptr) {
504        VideoStateType originalType = call->GetVideoStateType();
505        if (originalType != info.callMode) {
506            TELEPHONY_LOGI("change VideoStateType from %{public}d to %{public}d",
507                static_cast<int32_t>(originalType), static_cast<int32_t>(info.callMode));
508            call->SetVideoStateType(info.callMode);
509            return UpdateCallState(call, info.state);
510        }
511        return TELEPHONY_SUCCESS;
512    }
513    call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
514    if (call == nullptr) {
515        TELEPHONY_LOGE("CreateVoipCall failed!");
516        return CALL_ERR_CALL_OBJECT_IS_NULL;
517    }
518    AddOneCallObject(call);
519    DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
520    ret = UpdateCallState(call, info.state);
521    if (ret != TELEPHONY_SUCCESS) {
522        TELEPHONY_LOGE("UpdateCallState failed!");
523        return ret;
524    }
525    return ret;
526}
527
528int32_t CallStatusManager::AnsweredVoipCallHandle(const CallDetailInfo &info)
529{
530    int32_t ret = TELEPHONY_ERROR;
531    sptr<CallBase> call = GetOneCallObjectByVoipCallId(
532        info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
533    if (call == nullptr) {
534        return ret;
535    }
536    if (DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(
537        call, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED)) {
538        return TELEPHONY_SUCCESS;
539    } else {
540        return ret;
541    }
542}
543
544int32_t CallStatusManager::DisconnectingVoipCallHandle(const CallDetailInfo &info)
545{
546    sptr<CallBase> call = GetOneCallObjectByVoipCallId(
547        info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
548    if (call == nullptr) {
549        return TELEPHONY_ERROR;
550    }
551    return UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTING);
552}
553
554void CallStatusManager::QueryCallerInfo(ContactInfo &contactInfo, std::string phoneNum)
555{
556    TELEPHONY_LOGI("Entry CallStatusManager QueryCallerInfo");
557    std::shared_ptr<CallDataBaseHelper> callDataPtr = DelayedSingleton<CallDataBaseHelper>::GetInstance();
558    if (callDataPtr == nullptr) {
559        TELEPHONY_LOGE("callDataPtr is nullptr!");
560        return;
561    }
562    DataShare::DataSharePredicates predicates;
563    predicates.EqualTo(TYPE_ID, 5); // type 5 means query number
564    predicates.And();
565    predicates.EqualTo(IS_DELETED, 0);
566    predicates.And();
567#ifdef TELEPHONY_CUST_SUPPORT
568    if (phoneNum.length() >= static_cast<size_t>(QUERY_CONTACT_LEN)) {
569        TELEPHONY_LOGI("phoneNum is longer than 7");
570        predicates.EndsWith(DETAIL_INFO, phoneNum.substr(phoneNum.length() - QUERY_CONTACT_LEN));
571        if (!callDataPtr->QueryContactInfoEnhanced(contactInfo, predicates)) {
572            TELEPHONY_LOGE("Query contact database enhanced fail!");
573        }
574        return;
575    }
576#endif
577    predicates.EqualTo(DETAIL_INFO, phoneNum);
578    if (!callDataPtr->Query(contactInfo, predicates)) {
579        TELEPHONY_LOGE("Query contact database fail!");
580    }
581}
582
583int32_t CallStatusManager::IncomingFilterPolicy(const CallDetailInfo &info)
584{
585    if (CallIncomingFilterManagerPtr_ == nullptr) {
586        TELEPHONY_LOGE("CallIncomingFilterManagerPtr_ is null");
587        return TELEPHONY_ERR_LOCAL_PTR_NULL;
588    }
589    return CallIncomingFilterManagerPtr_->DoIncomingFilter(info);
590}
591
592void CallStatusManager::CallFilterCompleteResult(const CallDetailInfo &info)
593{
594    int32_t ret = TELEPHONY_ERR_FAIL;
595    sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
596    if (call == nullptr) {
597        TELEPHONY_LOGE("CreateNewCall failed!");
598        return;
599    }
600    AddOneCallObject(call);
601    DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
602    ret = UpdateCallState(call, info.state);
603    if (ret != TELEPHONY_SUCCESS) {
604        TELEPHONY_LOGE("UpdateCallState failed!");
605        return;
606    }
607    ret = FilterResultsDispose(call);
608    if (ret != TELEPHONY_SUCCESS) {
609        TELEPHONY_LOGE("FilterResultsDispose failed!");
610        return;
611    }
612}
613
614int32_t CallStatusManager::UpdateDialingCallInfo(const CallDetailInfo &info)
615{
616    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
617    if (call != nullptr) {
618        call = RefreshCallIfNecessary(call, info);
619        return TELEPHONY_SUCCESS;
620    }
621    call = GetOneCallObjectByIndex(INIT_INDEX);
622    if (call == nullptr) {
623        TELEPHONY_LOGE("call is nullptr");
624        return TELEPHONY_ERR_LOCAL_PTR_NULL;
625    }
626
627    std::string oriNum = call->GetAccountNumber();
628    call = RefreshCallIfNecessary(call, info);
629    call->SetCallIndex(info.index);
630    call->SetBundleName(info.bundleName);
631    call->SetSlotId(info.accountId);
632    call->SetTelCallState(info.state);
633    call->SetVideoStateType(info.callMode);
634    call->SetCallType(info.callType);
635    call->SetAccountNumber(oriNum);
636    auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
637    int32_t callId = call->GetCallID();
638    if (callRequestEventHandler->HasPendingMo(callId)) {
639        callRequestEventHandler->SetPendingMo(false, -1);
640    }
641    if (callRequestEventHandler->HasPendingHangup(callId)) {
642        call->HangUpCall();
643        callRequestEventHandler->SetPendingHangup(false, -1);
644    }
645    return TELEPHONY_SUCCESS;
646}
647
648int32_t CallStatusManager::DialingHandle(const CallDetailInfo &info)
649{
650    TELEPHONY_LOGI("handle dialing state");
651    if (info.index > 0) {
652        sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(INIT_INDEX, info.accountId);
653        if (call == nullptr) {
654            call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
655        }
656        if (call != nullptr) {
657            TELEPHONY_LOGI("need update call info");
658            return UpdateDialingCallInfo(info);
659        }
660    }
661    sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
662    if (call == nullptr) {
663        TELEPHONY_LOGE("CreateNewCall failed!");
664        return TELEPHONY_ERR_LOCAL_PTR_NULL;
665    }
666    if (IsDcCallConneceted()) {
667        SetContactInfo(call, std::string(info.phoneNum));
668    }
669    AddOneCallObject(call);
670    auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
671    if (info.index == INIT_INDEX) {
672        callRequestEventHandler->SetPendingMo(true, call->GetCallID());
673    }
674
675    callRequestEventHandler->RestoreDialingFlag(false);
676    callRequestEventHandler->RemoveEventHandlerTask();
677    int32_t ret = call->DialingProcess();
678    if (ret != TELEPHONY_SUCCESS) {
679        return ret;
680    }
681    DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
682    MyLocationEngine::StartEccService(call, info);
683    ret = UpdateCallState(call, TelCallState::CALL_STATUS_DIALING);
684    if (ret != TELEPHONY_SUCCESS) {
685        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
686    }
687    return ret;
688}
689
690int32_t CallStatusManager::ActiveHandle(const CallDetailInfo &info)
691{
692    TELEPHONY_LOGI("handle active state");
693    std::string tmpStr(info.phoneNum);
694    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
695    if (call == nullptr && IsDcCallConneceted()) {
696        CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_UNKNOW);
697        call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
698    }
699    if (call == nullptr) {
700        TELEPHONY_LOGE("Call is NULL");
701        return TELEPHONY_ERR_LOCAL_PTR_NULL;
702    }
703    call = RefreshCallIfNecessary(call, info);
704    SetOriginalCallTypeForActiveState(call);
705    // call state change active, need to judge if launching a conference
706    std::vector<sptr<CallBase>> conferenceCallList = GetConferenceCallList(call->GetSlotId());
707    if (info.mpty == 1 && conferenceCallList.size() > 1) {
708        SetConferenceCall(conferenceCallList);
709    } else if (call->ExitConference() == TELEPHONY_SUCCESS) {
710        TELEPHONY_LOGI("SubCallSeparateFromConference success!");
711    } else {
712        TELEPHONY_LOGI("SubCallSeparateFromConference fail!");
713    }
714    int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
715    if (ret != TELEPHONY_SUCCESS) {
716        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
717        return ret;
718    }
719    sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
720    if (holdCall != nullptr) {
721        holdCall->SetCanSwitchCallState(true);
722        TELEPHONY_LOGI("holdcall:%{public}d can swap", holdCall->GetCallID());
723    }
724#ifdef AUDIO_SUPPORT
725    ToSpeakerPhone(call);
726    DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
727#endif
728    TELEPHONY_LOGI("handle active state success");
729    return ret;
730}
731
732void CallStatusManager::SetConferenceCall(std::vector<sptr<CallBase>> conferenceCallList)
733{
734    for (auto conferenceCall : conferenceCallList) {
735        TELEPHONY_LOGI("SetConferenceCall callid : %{public}d; State : %{public}d",
736            conferenceCall->GetCallID(), conferenceCall->GetTelConferenceState());
737        if (conferenceCall->GetTelConferenceState() != TelConferenceState::TEL_CONFERENCE_ACTIVE) {
738            conferenceCall->LaunchConference();
739            UpdateCallState(conferenceCall, conferenceCall->GetTelCallState());
740        }
741    }
742}
743
744int32_t CallStatusManager::ActiveVoipCallHandle(const CallDetailInfo &info)
745{
746    TELEPHONY_LOGI("handle active state");
747    sptr<CallBase> call = GetOneCallObjectByVoipCallId(
748        info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
749    if (call == nullptr) {
750        TELEPHONY_LOGE("voip Call is NULL");
751        return TELEPHONY_ERR_LOCAL_PTR_NULL;
752    }
753    VideoStateType originalType = call->GetVideoStateType();
754    if (originalType != info.callMode) {
755        TELEPHONY_LOGI("change VideoStateType from %{public}d to %{public}d",
756            static_cast<int32_t>(originalType), static_cast<int32_t>(info.callMode));
757        call->SetVideoStateType(info.callMode);
758    }
759    int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
760    if (ret != TELEPHONY_SUCCESS) {
761        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
762        return ret;
763    }
764    TELEPHONY_LOGI("handle active state success");
765    return ret;
766}
767
768int32_t CallStatusManager::HoldingHandle(const CallDetailInfo &info)
769{
770    TELEPHONY_LOGI("handle holding state");
771    std::string tmpStr(info.phoneNum);
772    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
773    if (call == nullptr && IsDcCallConneceted()) {
774        CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_UNKNOW);
775        call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
776    }
777    if (call == nullptr) {
778        TELEPHONY_LOGE("Call is NULL");
779        return TELEPHONY_ERR_LOCAL_PTR_NULL;
780    }
781    // if the call is in a conference, it will exit, otherwise just set it holding
782    call = RefreshCallIfNecessary(call, info);
783    if (info.mpty == 1) {
784        int32_t ret = call->HoldConference();
785        if (ret == TELEPHONY_SUCCESS) {
786            TELEPHONY_LOGI("HoldConference success");
787        }
788    }
789    return UpdateCallStateAndHandleDsdsMode(info, call);
790}
791
792int32_t CallStatusManager::WaitingHandle(const CallDetailInfo &info)
793{
794    DelayedSingleton<CallControlManager>::GetInstance()->AcquireIncomingLock();
795    int32_t ret = IncomingHandle(info);
796    DelayedSingleton<CallControlManager>::GetInstance()->ReleaseIncomingLock();
797    return ret;
798}
799
800int32_t CallStatusManager::AlertHandle(const CallDetailInfo &info)
801{
802    TELEPHONY_LOGI("handle alerting state");
803    std::string tmpStr(info.phoneNum);
804    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
805    if (call == nullptr && IsDcCallConneceted()) {
806        CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_OUT);
807        call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
808    }
809    if (call == nullptr) {
810        TELEPHONY_LOGE("Call is NULL");
811        return TELEPHONY_ERR_LOCAL_PTR_NULL;
812    }
813    call = RefreshCallIfNecessary(call, info);
814    int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ALERTING);
815    if (ret != TELEPHONY_SUCCESS) {
816        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
817        return ret;
818    }
819#ifdef AUDIO_SUPPORT
820    ToSpeakerPhone(call);
821    TurnOffMute(call);
822    DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
823#endif
824    return ret;
825}
826
827int32_t CallStatusManager::DisconnectingHandle(const CallDetailInfo &info)
828{
829    TELEPHONY_LOGI("handle disconnecting state");
830    std::string tmpStr(info.phoneNum);
831    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
832    if (call == nullptr) {
833        TELEPHONY_LOGE("Call is NULL");
834        return TELEPHONY_ERR_LOCAL_PTR_NULL;
835    }
836    call = RefreshCallIfNecessary(call, info);
837    SetOriginalCallTypeForDisconnectState(call);
838    int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTING);
839    if (ret != TELEPHONY_SUCCESS) {
840        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
841    }
842    return ret;
843}
844
845int32_t CallStatusManager::DisconnectedVoipCallHandle(const CallDetailInfo &info)
846{
847    TELEPHONY_LOGI("handle disconnected voip call state");
848    sptr<CallBase> call = GetOneCallObjectByVoipCallId(
849        info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
850    if (call == nullptr) {
851        TELEPHONY_LOGE("voip Call is NULL");
852        return TELEPHONY_ERR_LOCAL_PTR_NULL;
853    }
854    int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
855    if (ret != TELEPHONY_SUCCESS) {
856        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
857        return ret;
858    }
859    DeleteOneCallObject(call->GetCallID());
860    TELEPHONY_LOGI("handle disconnected voip call state success");
861    return ret;
862}
863
864int32_t CallStatusManager::DisconnectedHandle(const CallDetailInfo &info)
865{
866    TELEPHONY_LOGI("handle disconnected state");
867    if (timeWaitHelper_ !=  nullptr) {
868        TELEPHONY_LOGI("ringtone once");
869        timeWaitHelper_->NotifyAll();
870        timeWaitHelper_ = nullptr;
871    }
872    std::string tmpStr(info.phoneNum);
873    sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
874    if (call == nullptr) {
875        TELEPHONY_LOGE("call is null");
876        return TELEPHONY_ERR_LOCAL_PTR_NULL;
877    }
878    call = RefreshCallIfNecessary(call, info);
879    SetOriginalCallTypeForDisconnectState(call);
880    std::vector<std::u16string> callIdList;
881    call->GetSubCallIdList(callIdList);
882    CallRunningState previousState = call->GetCallRunningState();
883    call->ExitConference();
884    TelCallState priorState = call->GetTelCallState();
885    UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
886    MyLocationEngine::StopEccService(call->GetCallID());
887    HandleHoldCallOrAutoAnswerCall(call, callIdList, previousState, priorState);
888    std::vector<sptr<CallBase>> conferenceCallList = GetConferenceCallList(call->GetSlotId());
889    if (conferenceCallList.size() == 1) {
890        sptr<CallBase> leftOneConferenceCall = conferenceCallList[0];
891        if (leftOneConferenceCall != nullptr &&
892            leftOneConferenceCall->GetTelConferenceState() != TelConferenceState::TEL_CONFERENCE_IDLE) {
893            TELEPHONY_LOGI("Not enough calls to be a conference!");
894            leftOneConferenceCall->SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_IDLE);
895            UpdateCallState(leftOneConferenceCall, leftOneConferenceCall->GetTelCallState());
896        }
897    }
898    int32_t currentCallNum = CallObjectManager::GetCurrentCallNum();
899    if (currentCallNum <= 0) {
900        DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->RestoreSuperPrivacyMode();
901    }
902    return TELEPHONY_SUCCESS;
903}
904
905std::vector<sptr<CallBase>> CallStatusManager::GetConferenceCallList(int32_t slotId)
906{
907    std::vector<sptr<CallBase>> conferenceCallList;
908    for (const auto &it : tmpCallDetailsInfo_[slotId].callVec) {
909        if (it.mpty == 1) {
910            sptr<CallBase> conferenceCall = GetOneCallObjectByIndexAndSlotId(it.index, it.accountId);
911            if (conferenceCall != nullptr) {
912                conferenceCallList.emplace_back(conferenceCall);
913            }
914        }
915    }
916    TELEPHONY_LOGI("Conference call list size:%{public}zu", conferenceCallList.size());
917    return conferenceCallList;
918}
919
920void CallStatusManager::HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,
921    std::vector<std::u16string> callIdList, CallRunningState previousState, TelCallState priorState)
922{
923    if (call == nullptr) {
924        TELEPHONY_LOGE("call is null");
925        return;
926    }
927    bool canUnHold = false;
928    size_t size = callIdList.size();
929    int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
930    int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
931    IsCanUnHold(activeCallNum, waitingCallNum, size, canUnHold);
932    sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
933    if (previousState != CallRunningState::CALL_RUNNING_STATE_HOLD &&
934        previousState != CallRunningState::CALL_RUNNING_STATE_ACTIVE &&
935        priorState == TelCallState::CALL_STATUS_DISCONNECTING) {
936        if (holdCall != nullptr && canUnHold && holdCall->GetCanUnHoldState()) {
937            if (holdCall->GetSlotId() == call->GetSlotId()) {
938                TELEPHONY_LOGI("release call and recover the held call");
939                holdCall->UnHoldCall();
940            }
941        }
942    }
943    DeleteOneCallObject(call->GetCallID());
944    int32_t dsdsMode = DSDS_MODE_V2;
945    DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
946    if (dsdsMode == DSDS_MODE_V3) {
947        AutoAnswer(activeCallNum, waitingCallNum);
948    } else if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
949        dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
950        bool canSwitchCallState = call->GetCanSwitchCallState();
951        AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), true);
952    }
953}
954
955void CallStatusManager::IsCanUnHold(int32_t activeCallNum, int32_t waitingCallNum, int32_t size, bool &canUnHold)
956{
957    int32_t incomingCallNum = GetCallNum(TelCallState::CALL_STATUS_INCOMING);
958    int32_t answeredCallNum = GetCallNum(TelCallState::CALL_STATUS_ANSWERED);
959    int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
960    if (answeredCallNum == 0 && incomingCallNum == 0 && (size == 0 || size == 1) && activeCallNum == 0 &&
961        waitingCallNum == 0 && dialingCallNum == 0) {
962        canUnHold = true;
963    }
964    TELEPHONY_LOGI("CanUnHold state: %{public}d", canUnHold);
965}
966
967void CallStatusManager::AutoHandleForDsda(
968    bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId, bool continueAnswer)
969{
970    int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
971    int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
972    std::list<int32_t> callIdList;
973    GetCarrierCallList(callIdList);
974    for (int32_t ringCallId : callIdList) {
975        sptr<CallBase> ringCall = GetOneCallObject(ringCallId);
976        if (ringCall != nullptr && ringCall->GetAutoAnswerState()) {
977            TELEPHONY_LOGI("ringCall is not nullptr");
978            int32_t videoState = static_cast<int32_t>(ringCall->GetVideoStateType());
979            if (videoState == static_cast<int32_t>(VideoStateType::TYPE_VIDEO)) {
980                TELEPHONY_LOGI("AutoAnswer VideoCall for Dsda");
981                AutoAnswerForVideoCall(activeCallNum);
982                AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
983                return;
984            }
985            if (dialingCallNum == 0 && alertingCallNum == 0 && activeCallNum == 0 &&
986                ringCall->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_RINGING) {
987                TELEPHONY_LOGI("AutoAnswer VoiceCall for Dsda");
988                AutoAnswerForVoiceCall(ringCall, slotId, continueAnswer);
989                AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
990                return;
991            }
992        }
993    }
994    AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
995}
996
997void CallStatusManager::AutoUnHoldForDsda(
998    bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId)
999{
1000    int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1001    int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
1002    int32_t callNum = 2;
1003    std::list<int32_t> callIdList;
1004    GetCarrierCallList(callIdList);
1005    int32_t currentCallNum = GetCurrentCallNum();
1006    for (int32_t otherCallId : callIdList) {
1007        sptr<CallBase> otherCall = GetOneCallObject(otherCallId);
1008        if (otherCall == nullptr) {
1009            TELEPHONY_LOGE("otherCall is nullptr");
1010            continue;
1011        }
1012        TelCallState state = otherCall->GetTelCallState();
1013        TelConferenceState confState = otherCall->GetTelConferenceState();
1014        int32_t conferenceId = ERR_ID;
1015        otherCall->GetMainCallId(conferenceId);
1016        if (slotId != otherCall->GetSlotId() && state == TelCallState::CALL_STATUS_HOLDING &&
1017            otherCall->GetCanUnHoldState() && activeCallNum == 0 && waitingCallNum == 0 &&
1018            dialingCallNum == 0 &&
1019            ((confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == otherCallId) ||
1020                confState == TelConferenceState::TEL_CONFERENCE_IDLE)) {
1021            // Actively hang up the processing unhold state or exchange call
1022            if (priorState == TelCallState::CALL_STATUS_DISCONNECTING ||
1023                (!canSwitchCallState && currentCallNum == callNum)) {
1024                otherCall->UnHoldCall();
1025                return;
1026            }
1027        }
1028    }
1029    for (int32_t otherCallId : callIdList) {
1030        sptr<CallBase> holdCall = GetOneCallObject(otherCallId);
1031        if (holdCall != nullptr && holdCall->GetTelCallState() == TelCallState::CALL_STATUS_HOLDING) {
1032            if (currentCallNum == callNum) {
1033                holdCall->SetCanUnHoldState(true);
1034            }
1035        }
1036    }
1037}
1038
1039void CallStatusManager::AutoAnswerForVoiceCall(sptr<CallBase> ringCall, int32_t slotId, bool continueAnswer)
1040{
1041    /* Need to check whether the autoAnswer call and the holding call are on the same slotid
1042     * To prevent repeated AT command delivery.
1043     */
1044    if (continueAnswer || slotId != ringCall->GetSlotId()) {
1045        DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(
1046            ringCall, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED);
1047        int ret = ringCall->AnswerCall(ringCall->GetAnswerVideoState());
1048        if (ret == TELEPHONY_SUCCESS) {
1049            DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(ringCall);
1050        }
1051        TELEPHONY_LOGI("ret = %{public}d", ret);
1052    }
1053    ringCall->SetAutoAnswerState(false);
1054}
1055
1056void CallStatusManager::AutoAnswerForVideoCall(int32_t activeCallNum)
1057{
1058    int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
1059    int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1060    int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
1061    if (activeCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 && alertingCallNum == 0) {
1062        std::list<int32_t> ringCallIdList;
1063        GetCarrierCallList(ringCallIdList);
1064        for (int32_t ringingCallId : ringCallIdList) {
1065            sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
1066            if (ringingCall == nullptr) {
1067                TELEPHONY_LOGE("ringingCall is nullptr");
1068                return;
1069            }
1070            CallRunningState ringingCallState = ringingCall->GetCallRunningState();
1071            if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
1072                    (ringingCall->GetAutoAnswerState()))) {
1073                ringingCall->SetAutoAnswerState(false);
1074                int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
1075                TELEPHONY_LOGI("ret = %{public}d", ret);
1076                break;
1077            }
1078        }
1079    }
1080}
1081
1082void CallStatusManager::AutoAnswer(int32_t activeCallNum, int32_t waitingCallNum)
1083{
1084    int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
1085    int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1086    int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
1087    if (activeCallNum == 0 && waitingCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 &&
1088        alertingCallNum == 0) {
1089        std::list<int32_t> ringCallIdList;
1090        GetCarrierCallList(ringCallIdList);
1091        for (int32_t ringingCallId : ringCallIdList) {
1092            sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
1093            if (ringingCall == nullptr) {
1094                TELEPHONY_LOGE("ringingCall is nullptr");
1095                return;
1096            }
1097            CallRunningState ringingCallState = ringingCall->GetCallRunningState();
1098            if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
1099                    (ringingCall->GetAutoAnswerState()))) {
1100                ringingCall->SetAutoAnswerState(false);
1101                int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
1102                TELEPHONY_LOGI("ret = %{public}d", ret);
1103                break;
1104            }
1105        }
1106    }
1107}
1108
1109int32_t CallStatusManager::UpdateCallState(sptr<CallBase> &call, TelCallState nextState)
1110{
1111    TELEPHONY_LOGW("UpdateCallState start");
1112    if (call == nullptr) {
1113        TELEPHONY_LOGE("Call is NULL");
1114        return TELEPHONY_ERR_LOCAL_PTR_NULL;
1115    }
1116    TelCallState priorState = call->GetTelCallState();
1117    VideoStateType videoState = call->GetVideoStateType();
1118    TELEPHONY_LOGI(
1119        "callIndex:%{public}d, callId:%{public}d, priorState:%{public}d, nextState:%{public}d, videoState:%{public}d",
1120        call->GetCallIndex(), call->GetCallID(), priorState, nextState, videoState);
1121    if (call->GetCallType() == CallType::TYPE_SATELLITE) {
1122        DelayedSingleton<SatelliteCallControl>::GetInstance()->
1123            HandleSatelliteCallStateUpdate(call, priorState, nextState);
1124    }
1125    if (priorState == TelCallState::CALL_STATUS_INCOMING && nextState == TelCallState::CALL_STATUS_ACTIVE) {
1126        DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingAnswerTimeOut(
1127            call->GetSlotId(), call->GetCallID(), static_cast<int32_t>(call->GetVideoStateType()));
1128    }
1129    int32_t ret = call->SetTelCallState(nextState);
1130    UpdateOneCallObjectByCallId(call->GetCallID(), nextState);
1131    if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
1132        TELEPHONY_LOGE("SetTelCallState failed");
1133        return TELEPHONY_ERR_LOCAL_PTR_NULL;
1134    }
1135    if (!DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(call, priorState, nextState)) {
1136        TELEPHONY_LOGE(
1137            "NotifyCallStateUpdated failed! priorState:%{public}d,nextState:%{public}d", priorState, nextState);
1138        if (nextState == TelCallState::CALL_STATUS_INCOMING) {
1139            CallManagerHisysevent::WriteIncomingCallFaultEvent(call->GetSlotId(),
1140                static_cast<int32_t>(call->GetCallType()), static_cast<int32_t>(call->GetVideoStateType()), ret,
1141                "NotifyCallStateUpdated failed");
1142        }
1143        return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
1144    }
1145    SetVideoCallState(call, nextState);
1146    return TELEPHONY_SUCCESS;
1147}
1148
1149void CallStatusManager::SetVideoCallState(sptr<CallBase> &call, TelCallState nextState)
1150{
1151    if (call == nullptr) {
1152        TELEPHONY_LOGE("Call is NULL");
1153        return;
1154    }
1155    int slotId = call->GetSlotId();
1156    bool isSlotIdValid = false;
1157    if (slotId < SLOT_NUM && slotId >= 0) {
1158        isSlotIdValid = true;
1159    }
1160    VideoStateType videoState = call->GetVideoStateType();
1161    TELEPHONY_LOGI("nextVideoState:%{public}d, priorVideoState:%{public}d, isSlotIdValid:%{public}d", videoState,
1162        priorVideoState_[slotId], isSlotIdValid);
1163    if (isSlotIdValid && (priorVideoState_[slotId] != videoState)) {
1164        DelayedSingleton<AudioControlManager>::GetInstance()->VideoStateUpdated(
1165            call, priorVideoState_[slotId], videoState);
1166        priorVideoState_[slotId] = videoState;
1167    }
1168    if (isSlotIdValid && (nextState == TelCallState::CALL_STATUS_DISCONNECTED)) {
1169        priorVideoState_[slotId] = VideoStateType::TYPE_VOICE;
1170    }
1171}
1172
1173sptr<CallBase> CallStatusManager::RefreshCallIfNecessary(const sptr<CallBase> &call, const CallDetailInfo &info)
1174{
1175    TELEPHONY_LOGI("RefreshCallIfNecessary");
1176    if (call->GetCallType() == CallType::TYPE_IMS && call->GetVideoStateType() != info.callMode) {
1177        call->SetVideoStateType(info.callMode);
1178        sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
1179        imsCall->InitVideoCall();
1180    }
1181    if (call->GetCallType() == CallType::TYPE_IMS) {
1182        call->SetCrsType(info.crsType);
1183    }
1184    if (call->GetCallType() == info.callType) {
1185        TELEPHONY_LOGI("RefreshCallIfNecessary not need Refresh");
1186        return call;
1187    }
1188    TelCallState priorState = call->GetTelCallState();
1189    CallAttributeInfo attrInfo;
1190    (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
1191    call->GetCallAttributeBaseInfo(attrInfo);
1192    sptr<CallBase> newCall = CreateNewCall(info, attrInfo.callDirection);
1193    if (newCall == nullptr) {
1194        TELEPHONY_LOGE("RefreshCallIfNecessary createCallFail");
1195        return call;
1196    }
1197    AddOneCallObject(newCall);
1198    newCall->SetCallRunningState(call->GetCallRunningState());
1199    newCall->SetTelConferenceState(call->GetTelConferenceState());
1200    newCall->SetStartTime(attrInfo.startTime);
1201    newCall->SetPolicyFlag(PolicyFlag(call->GetPolicyFlag()));
1202    newCall->SetSpeakerphoneOn(call->IsSpeakerphoneOn());
1203    newCall->SetCallEndedType(call->GetCallEndedType());
1204    newCall->SetCallBeginTime(attrInfo.callBeginTime);
1205    newCall->SetCallCreateTime(attrInfo.callCreateTime);
1206    newCall->SetCallEndTime(attrInfo.callEndTime);
1207    newCall->SetRingBeginTime(attrInfo.ringBeginTime);
1208    newCall->SetRingEndTime(attrInfo.ringEndTime);
1209    newCall->SetAnswerType(attrInfo.answerType);
1210    newCall->SetMicPhoneState(call->IsMuted());
1211    DeleteOneCallObject(call->GetCallID());
1212    newCall->SetCallId(call->GetCallID());
1213    newCall->SetTelCallState(priorState);
1214    if (call->GetNumberLocation() != "default") {
1215        newCall->SetNumberLocation(call->GetNumberLocation());
1216    }
1217    NumberMarkInfo numberMarkInfo = call->GetNumberMarkInfo();
1218    if (numberMarkInfo.markType != MarkType::MARK_TYPE_NONE) {
1219        newCall->SetNumberMarkInfo(numberMarkInfo);
1220    }
1221    return newCall;
1222}
1223
1224void CallStatusManager::SetOriginalCallTypeForActiveState(sptr<CallBase> &call)
1225{
1226    if (call == nullptr) {
1227        TELEPHONY_LOGE("Call is NULL");
1228        return;
1229    }
1230    TelCallState priorState = call->GetTelCallState();
1231    VideoStateType videoState = call->GetVideoStateType();
1232    int32_t videoStateHistory = call->GetOriginalCallType();
1233    if (priorState == TelCallState::CALL_STATUS_ALERTING || priorState == TelCallState::CALL_STATUS_INCOMING ||
1234        priorState == TelCallState::CALL_STATUS_WAITING) {
1235        // outgoing/incoming video call, but accepted/answered with voice call
1236        if (videoStateHistory != static_cast<int32_t>(videoState)) {
1237            TELEPHONY_LOGD("set videoState:%{public}d as original call type", static_cast<int32_t>(videoState));
1238            call->SetOriginalCallType(static_cast<int32_t>(videoState));
1239        }
1240    } else if (priorState == TelCallState::CALL_STATUS_ACTIVE || priorState == TelCallState::CALL_STATUS_HOLDING) {
1241        int32_t videoStateCurrent =
1242            static_cast<int32_t>(static_cast<uint32_t>(videoStateHistory) | static_cast<uint32_t>(videoState));
1243        TELEPHONY_LOGD("maybe upgrade/downgrade operation, keep video record always, videoStateCurrent:%{public}d",
1244            videoStateCurrent);
1245        call->SetOriginalCallType(videoStateCurrent);
1246    }
1247}
1248
1249void CallStatusManager::SetOriginalCallTypeForDisconnectState(sptr<CallBase> &call)
1250{
1251    if (call == nullptr) {
1252        TELEPHONY_LOGE("Call is NULL");
1253        return;
1254    }
1255    TelCallState priorState = call->GetTelCallState();
1256    CallAttributeInfo attrInfo;
1257    (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
1258    call->GetCallAttributeBaseInfo(attrInfo);
1259    if (priorState == TelCallState::CALL_STATUS_DIALING || priorState == TelCallState::CALL_STATUS_ALERTING ||
1260        ((priorState == TelCallState::CALL_STATUS_INCOMING || priorState == TelCallState::CALL_STATUS_WAITING) &&
1261        attrInfo.answerType != CallAnswerType::CALL_ANSWER_REJECT)) {
1262        // outgoing/incoming video call, but canceled or missed
1263        TELEPHONY_LOGD("canceled or missed call, set voice type as original call type");
1264        call->SetOriginalCallType(static_cast<int32_t>(VideoStateType::TYPE_VOICE));
1265    }
1266}
1267
1268int32_t CallStatusManager::ToSpeakerPhone(sptr<CallBase> &call)
1269{
1270    int32_t ret = TELEPHONY_ERR_FAIL;
1271    if (call == nullptr) {
1272        TELEPHONY_LOGE("Call is NULL");
1273        return TELEPHONY_ERR_LOCAL_PTR_NULL;
1274    }
1275    if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_DIALING) {
1276        TELEPHONY_LOGI("Call is CALL_STATUS_DIALING");
1277        return ret;
1278    }
1279    if (call->IsSpeakerphoneOn()) {
1280        AudioDevice device = {
1281            .deviceType = AudioDeviceType::DEVICE_SPEAKER,
1282            .address = { 0 },
1283        };
1284        DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(device);
1285        ret = call->SetSpeakerphoneOn(false);
1286    }
1287    return ret;
1288}
1289
1290int32_t CallStatusManager::TurnOffMute(sptr<CallBase> &call)
1291{
1292    bool enabled = true;
1293    if (HasEmergencyCall(enabled) != TELEPHONY_SUCCESS) {
1294        TELEPHONY_LOGI("CallStatusManager::TurnOffMute HasEmergencyCall failed.");
1295    }
1296    if (call->GetEmergencyState() || enabled) {
1297        DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(false);
1298    } else {
1299        DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(true);
1300    }
1301    return TELEPHONY_SUCCESS;
1302}
1303
1304sptr<CallBase> CallStatusManager::CreateNewCall(const CallDetailInfo &info, CallDirection dir)
1305{
1306    TELEPHONY_LOGI("CreateNewCall");
1307    DialParaInfo paraInfo;
1308    AppExecFwk::PacMap extras;
1309    extras.Clear();
1310    PackParaInfo(paraInfo, info, dir, extras);
1311
1312    sptr<CallBase> callPtr = CreateNewCallByCallType(paraInfo, info, dir, extras);
1313    if (callPtr == nullptr) {
1314        TELEPHONY_LOGE("CreateNewCall failed!");
1315        return nullptr;
1316    }
1317    DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
1318    if (dialScene == DialScene::CALL_EMERGENCY) {
1319        callPtr->SetIsEccContact(true);
1320    }
1321    callPtr->SetOriginalCallType(info.originalCallType);
1322    TELEPHONY_LOGD("originalCallType:%{public}d", info.originalCallType);
1323    if (info.callType == CallType::TYPE_VOIP) {
1324        return callPtr;
1325    }
1326    if (info.state == TelCallState::CALL_STATUS_INCOMING || info.state == TelCallState::CALL_STATUS_WAITING ||
1327        (info.state == TelCallState::CALL_STATUS_DIALING && (info.index == 0 || IsDcCallConneceted()))) {
1328        TELEPHONY_LOGI("NumberLocationUpdate start");
1329        wptr<CallBase> callBaseWeakPtr = callPtr;
1330        ffrt::submit([callBaseWeakPtr, info]() {
1331            sptr<CallBase> callBasePtr = callBaseWeakPtr.promote();
1332            if (callBasePtr == nullptr) {
1333                TELEPHONY_LOGE("callBasePtr is nullptr");
1334                return;
1335            }
1336            DelayedSingleton<CallNumberUtils>::GetInstance()->NumberLocationUpdate(callBasePtr);
1337            DelayedSingleton<DistributedCommunicationManager>::GetInstance()->ProcessCallInfo(callBasePtr,
1338                DistributedDataType::LOCATION);
1339            if (info.state == TelCallState::CALL_STATUS_DIALING) {
1340                DelayedSingleton<CallNumberUtils>::GetInstance()->YellowPageAndMarkUpdate(callBasePtr);
1341            }
1342        });
1343    }
1344    time_t createTime = time(nullptr);
1345    if (createTime < 0) {
1346        createTime = 0;
1347    }
1348    callPtr->SetCallCreateTime(createTime);
1349    return callPtr;
1350}
1351
1352sptr<CallBase> CallStatusManager::CreateNewCallByCallType(
1353    DialParaInfo &paraInfo, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1354{
1355    sptr<CallBase> callPtr = nullptr;
1356    switch (info.callType) {
1357        case CallType::TYPE_CS: {
1358            if (dir == CallDirection::CALL_DIRECTION_OUT) {
1359                callPtr = (std::make_unique<CSCall>(paraInfo, extras)).release();
1360            } else {
1361                callPtr = (std::make_unique<CSCall>(paraInfo)).release();
1362            }
1363            break;
1364        }
1365        case CallType::TYPE_IMS: {
1366            if (dir == CallDirection::CALL_DIRECTION_OUT) {
1367                callPtr = (std::make_unique<IMSCall>(paraInfo, extras)).release();
1368            } else {
1369                callPtr = (std::make_unique<IMSCall>(paraInfo)).release();
1370            }
1371            if (callPtr->GetCallType() == CallType::TYPE_IMS) {
1372                sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(callPtr.GetRefPtr());
1373                imsCall->InitVideoCall();
1374            }
1375            break;
1376        }
1377        case CallType::TYPE_OTT: {
1378            if (dir == CallDirection::CALL_DIRECTION_OUT) {
1379                callPtr = (std::make_unique<OTTCall>(paraInfo, extras)).release();
1380            } else {
1381                callPtr = (std::make_unique<OTTCall>(paraInfo)).release();
1382            }
1383            break;
1384        }
1385        case CallType::TYPE_VOIP: {
1386            callPtr = (std::make_unique<VoIPCall>(paraInfo)).release();
1387            break;
1388        }
1389        case CallType::TYPE_SATELLITE: {
1390            if (dir == CallDirection::CALL_DIRECTION_OUT) {
1391                callPtr = (std::make_unique<SatelliteCall>(paraInfo, extras)).release();
1392            } else {
1393                callPtr = (std::make_unique<SatelliteCall>(paraInfo)).release();
1394            }
1395            break;
1396        }
1397        default:
1398            return nullptr;
1399    }
1400    return callPtr;
1401}
1402
1403bool CallStatusManager::ShouldRejectIncomingCall()
1404{
1405    bool hasEcc = false;
1406    if (HasEmergencyCall(hasEcc) == TELEPHONY_SUCCESS && hasEcc) {
1407        TELEPHONY_LOGI("HasEmergencyCall reject incoming call.");
1408        return true;
1409    }
1410    auto datashareHelper = SettingsDataShareHelper::GetInstance();
1411    std::string device_provisioned {"0"};
1412    OHOS::Uri uri(
1413        "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=device_provisioned");
1414    int resp = datashareHelper->Query(uri, "device_provisioned", device_provisioned);
1415    if (resp == TELEPHONY_SUCCESS && (device_provisioned == "0" || device_provisioned.empty())) {
1416        TELEPHONY_LOGW("ShouldRejectIncomingCall: device_provisioned = 0");
1417        return true;
1418    }
1419
1420    std::string user_setup_complete {"1"};
1421    std::vector<int> activedOsAccountIds;
1422    OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activedOsAccountIds);
1423    if (activedOsAccountIds.empty()) {
1424        TELEPHONY_LOGW("ShouldRejectIncomingCall: activedOsAccountIds is empty");
1425        return false;
1426    }
1427    int userId = activedOsAccountIds[0];
1428    OHOS::Uri uri_setup(
1429        "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_"
1430        + std::to_string(userId) + "?Proxy=true&key=user_setup_complete");
1431    int resp_userSetup = datashareHelper->Query(uri_setup, "user_setup_complete", user_setup_complete);
1432    if (resp_userSetup == TELEPHONY_SUCCESS && (user_setup_complete == "0" || user_setup_complete.empty())) {
1433        TELEPHONY_LOGW("ShouldRejectIncomingCall: user_setup_complete = 0");
1434        return true;
1435    }
1436    return false;
1437}
1438
1439bool CallStatusManager::ShouldBlockIncomingCall(const sptr<CallBase> &call, const CallDetailInfo &info)
1440{
1441    bool isEcc = false;
1442    DelayedSingleton<CellularCallConnection>::GetInstance()->IsEmergencyPhoneNumber(
1443        info.phoneNum, info.accountId, isEcc);
1444    if (isEcc) {
1445        TELEPHONY_LOGI("incoming phoneNumber is ecc.");
1446        return false;
1447    }
1448    std::shared_ptr<SpamCallAdapter> spamCallAdapterPtr_ = std::make_shared<SpamCallAdapter>();
1449    if (spamCallAdapterPtr_ == nullptr) {
1450        TELEPHONY_LOGE("create SpamCallAdapter object failed!");
1451        return false;
1452    }
1453    spamCallAdapterPtr_->DetectSpamCall(std::string(info.phoneNum), info.accountId);
1454    if (spamCallAdapterPtr_->WaitForDetectResult()) {
1455        TELEPHONY_LOGI("DetectSpamCall no time out");
1456        NumberMarkInfo numberMarkInfo;
1457        bool isBlock = false;
1458        int32_t blockReason;
1459        spamCallAdapterPtr_->GetParseResult(isBlock, numberMarkInfo, blockReason);
1460        call->SetNumberMarkInfo(numberMarkInfo);
1461        call->SetBlockReason(blockReason);
1462        if (isBlock) {
1463            return true;
1464        }
1465    }
1466    return false;
1467}
1468
1469bool CallStatusManager::IsRingOnceCall(const sptr<CallBase> &call, const CallDetailInfo &info)
1470{
1471    NumberMarkInfo numberMarkInfo = call->GetNumberMarkInfo();
1472    ContactInfo contactInfo = call->GetCallerInfo();
1473    if (numberMarkInfo.markType == MarkType::MARK_TYPE_YELLOW_PAGE || contactInfo.name != "") {
1474        TELEPHONY_LOGI("yellowpage or contact, no need check ring once call");
1475        return false;
1476    }
1477    auto datashareHelper = SettingsDataShareHelper::GetInstance();
1478    std::string is_check_ring_once {"0"};
1479    std::string key = "spamshield_sim" + std::to_string(info.accountId + 1) + "_phone_switch_ring_once";
1480    OHOS::Uri uri(
1481        "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=" + key);
1482    int32_t ret = datashareHelper->Query(uri, key, is_check_ring_once);
1483    TELEPHONY_LOGI("is_check_ring_once = %{public}s", is_check_ring_once.c_str());
1484    if (ret != TELEPHONY_SUCCESS || is_check_ring_once == "0") {
1485        return false;
1486    }
1487    if (timeWaitHelper_ == nullptr) {
1488        timeWaitHelper_ = std::make_unique<TimeWaitHelper>(WAIT_TIME_THREE_SECOND);
1489    }
1490    if (!timeWaitHelper_->WaitForResult()) {
1491        TELEPHONY_LOGI("is not ring once");
1492        return false;
1493    }
1494    return true;
1495}
1496
1497int32_t CallStatusManager::HandleRingOnceCall(sptr<CallBase> &call)
1498{
1499    if (call == nullptr) {
1500        TELEPHONY_LOGE("call is nullptr!");
1501        return TELEPHONY_ERR_LOCAL_PTR_NULL;
1502    }
1503    int32_t ret = call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1504    if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
1505        TELEPHONY_LOGE("Set CallState failed!");
1506        return ret;
1507    }
1508    return DelayedSingleton<CallControlManager>::GetInstance()->AddCallLogAndNotification(call);
1509}
1510
1511void CallStatusManager::PackParaInfo(
1512    DialParaInfo &paraInfo, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1513{
1514    paraInfo.isEcc = false;
1515    paraInfo.dialType = DialType::DIAL_CARRIER_TYPE;
1516    if (dir == CallDirection::CALL_DIRECTION_OUT) {
1517        DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(paraInfo, extras);
1518    }
1519    if (info.callType == CallType::TYPE_VOIP) {
1520        paraInfo.voipCallInfo.voipCallId = info.voipCallInfo.voipCallId;
1521        paraInfo.voipCallInfo.userName = info.voipCallInfo.userName;
1522        (paraInfo.voipCallInfo.userProfile).assign(
1523            (info.voipCallInfo.userProfile).begin(), (info.voipCallInfo.userProfile).end());
1524        paraInfo.voipCallInfo.abilityName = info.voipCallInfo.abilityName;
1525        paraInfo.voipCallInfo.extensionId = info.voipCallInfo.extensionId;
1526        paraInfo.voipCallInfo.voipBundleName = info.voipCallInfo.voipBundleName;
1527        paraInfo.voipCallInfo.showBannerForIncomingCall = info.voipCallInfo.showBannerForIncomingCall;
1528        paraInfo.voipCallInfo.isConferenceCall = info.voipCallInfo.isConferenceCall;
1529        paraInfo.voipCallInfo.isVoiceAnswerSupported = info.voipCallInfo.isVoiceAnswerSupported;
1530        paraInfo.voipCallInfo.hasMicPermission = info.voipCallInfo.hasMicPermission;
1531        paraInfo.voipCallInfo.uid = info.voipCallInfo.uid;
1532    }
1533    paraInfo.number = info.phoneNum;
1534    paraInfo.callId = GetNewCallId();
1535    paraInfo.index = info.index;
1536    paraInfo.videoState = info.callMode;
1537    paraInfo.accountId = info.accountId;
1538    paraInfo.callType = info.callType;
1539    paraInfo.callState = info.state;
1540    paraInfo.bundleName = info.bundleName;
1541    paraInfo.crsType = info.crsType;
1542    paraInfo.originalCallType = info.originalCallType;
1543    paraInfo.extraParams =
1544        AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(extras.GetStringValue("extraParams"));
1545}
1546
1547bool CallStatusManager::IsFocusModeOpen()
1548{
1549    auto datashareHelper = SettingsDataShareHelper::GetInstance();
1550    std::string focusModeEnable {"0"};
1551    std::vector<int> activedOsAccountIds;
1552    OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activedOsAccountIds);
1553    if (activedOsAccountIds.empty()) {
1554        TELEPHONY_LOGW("ShouldRejectIncomingCall: activedOsAccountIds is empty");
1555        return false;
1556    }
1557    int userId = activedOsAccountIds[0];
1558    OHOS::Uri uri(
1559        "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_"
1560        + std::to_string(userId) + "?Proxy=true&key=focus_mode_enable");
1561    int resp = datashareHelper->Query(uri, "focus_mode_enable", focusModeEnable);
1562    if (resp == TELEPHONY_SUCCESS && focusModeEnable == "1") {
1563        TELEPHONY_LOGI("IsFocusModeOpen: focus_mode_enable = 1");
1564        return true;
1565    }
1566    return false;
1567}
1568
1569bool CallStatusManager::IsRejectCall(sptr<CallBase> &call, const CallDetailInfo &info, bool &block)
1570{
1571    int32_t state;
1572    DelayedSingleton<CallControlManager>::GetInstance()->GetVoIPCallState(state);
1573    if (ShouldRejectIncomingCall() || state == (int32_t)CallStateToApp::CALL_STATE_RINGING) {
1574        block = false;
1575        return true;
1576    }
1577    if (info.callType != CallType::TYPE_VOIP && ShouldBlockIncomingCall(call, info)) {
1578        block = true;
1579        return true;
1580    }
1581    if (IsFocusModeOpen()) {
1582        int ret = Notification::NotificationHelper::IsNeedSilentInDoNotDisturbMode(info.phoneNum, 0);
1583        TELEPHONY_LOGI("IsRejectCall IsNeedSilentInDoNotDisturbMode ret:%{public}d", ret);
1584        if (ret == 0) {
1585            block = false;
1586            return true;
1587        }
1588    }
1589    return false;
1590}
1591
1592void CallStatusManager::CreateAndSaveNewCall(const CallDetailInfo &info, CallDirection direction)
1593{
1594    auto call = CreateNewCall(info, direction);
1595    if (call != nullptr) {
1596        ffrt::submit([=]() {
1597            DelayedSingleton<CallNumberUtils>::GetInstance()->YellowPageAndMarkUpdate(call);
1598        });
1599        AddOneCallObject(call);
1600        DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
1601    }
1602}
1603
1604int32_t CallStatusManager::UpdateCallStateAndHandleDsdsMode(const CallDetailInfo &info, sptr<CallBase> &call)
1605{
1606    if (call == nullptr) {
1607        return TELEPHONY_ERR_LOCAL_PTR_NULL;
1608    }
1609    TelCallState priorState = call->GetTelCallState();
1610    int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_HOLDING);
1611    if (ret != TELEPHONY_SUCCESS) {
1612        TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
1613    }
1614    int32_t callId = call->GetCallID();
1615    int32_t dsdsMode = DSDS_MODE_V2;
1616    DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
1617    TELEPHONY_LOGE("HoldingHandle dsdsMode:%{public}d", dsdsMode);
1618    bool canSwitchCallState = call->GetCanSwitchCallState();
1619    if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
1620        dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
1621        int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
1622        if (needWaitHold_ && activeCallNum == 0) {
1623            needWaitHold_ = false;
1624            HandleDialWhenHolding(callId, call);
1625        } else {
1626            TelConferenceState confState = call->GetTelConferenceState();
1627            int32_t conferenceId = ERR_ID;
1628            call->GetMainCallId(conferenceId);
1629            if (confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == callId) {
1630                AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
1631            } else if (confState == TelConferenceState::TEL_CONFERENCE_IDLE) {
1632                AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
1633            }
1634        }
1635    }
1636    return ret;
1637}
1638
1639void CallStatusManager::HandleDialWhenHolding(int32_t callId, sptr<CallBase> &call)
1640{
1641    auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
1642    if (callRequestEventHandler->IsPendingHangup()) {
1643        sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(callId);
1644        if (holdCall != nullptr) {
1645            holdCall->UnHoldCall();
1646        }
1647        int32_t pendingHangupCallId = callRequestEventHandler->GetPendingHangupCallId();
1648        sptr<CallBase> pendingHangupCall = CallObjectManager::GetOneCallObject(pendingHangupCallId);
1649        if (pendingHangupCall != nullptr) {
1650            UpdateCallState(pendingHangupCall, TelCallState::CALL_STATUS_DISCONNECTED);
1651            DeleteOneCallObject(pendingHangupCallId);
1652        }
1653        callRequestEventHandler->SetPendingHangup(false, -1);
1654    } else {
1655        int32_t result = DelayedSingleton<CellularCallConnection>::GetInstance()->Dial(GetDialCallInfo());
1656        sptr<CallBase> dialCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
1657        if (result != TELEPHONY_SUCCESS && dialCall != nullptr) {
1658            DealFailDial(call);
1659            TELEPHONY_LOGI("Dial call fail");
1660        }
1661    }
1662}
1663
1664bool CallStatusManager::IsDcCallConneceted()
1665{
1666    std::string dcStatus = "";
1667    auto settingHelper = SettingsDataShareHelper::GetInstance();
1668    if (settingHelper != nullptr) {
1669        OHOS::Uri settingUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI);
1670        settingHelper->Query(settingUri, "distributed_modem_state", dcStatus);
1671    }
1672    if (dcStatus == "1_sink" || dcStatus == "1_source") {
1673        return true;
1674    }
1675    return false;
1676}
1677} // namespace Telephony
1678} // namespace OHOS
1679