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 
52 namespace OHOS {
53 namespace Telephony {
54 constexpr int32_t INIT_INDEX = 0;
CallStatusManager()55 CallStatusManager::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 
~CallStatusManager()63 CallStatusManager::~CallStatusManager()
64 {
65     UnInit();
66 }
67 
Init()68 int32_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 
InitCallBaseEvent()84 void 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 
UnInit()97 int32_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 
HandleCallReportInfo(const CallDetailInfo &info)108 int32_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 
HandleDsdaInfo(int32_t slotId)162 void 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.
HandleCallsReportInfo(const CallDetailsInfo &info)184 int32_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 
UpdateCallDetailsInfo(const CallDetailsInfo &info)234 void 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 
HandleVoipCallReportInfo(const CallDetailInfo &info)251 int32_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 
HandleDisconnectedCause(const DisconnectedDetails &details)282 int32_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 
HandleEventResultReportInfo(const CellularCallEventInfo &info)292 int32_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 
HandleOttEventReportInfo(const OttCallEventInfo &info)334 int32_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 
HandleVoipEventReportInfo(const VoipCallEventInfo &info)356 int32_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 
IncomingHandle(const CallDetailInfo &info)377 int32_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 
SetContactInfo(sptr<CallBase> &call, std::string phoneNum)426 void 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 
HandleRejectCall(sptr<CallBase> &call, bool isBlock)453 int32_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 
IncomingVoipCallHandle(const CallDetailInfo &info)475 int32_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 
OutgoingVoipCallHandle(const CallDetailInfo &info)498 int32_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 
AnsweredVoipCallHandle(const CallDetailInfo &info)528 int32_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 
DisconnectingVoipCallHandle(const CallDetailInfo &info)544 int32_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 
QueryCallerInfo(ContactInfo &contactInfo, std::string phoneNum)554 void 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 
IncomingFilterPolicy(const CallDetailInfo &info)583 int32_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 
CallFilterCompleteResult(const CallDetailInfo &info)592 void 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 
UpdateDialingCallInfo(const CallDetailInfo &info)614 int32_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 
DialingHandle(const CallDetailInfo &info)648 int32_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 
ActiveHandle(const CallDetailInfo &info)690 int32_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 
SetConferenceCall(std::vector<sptr<CallBase>> conferenceCallList)732 void 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 
ActiveVoipCallHandle(const CallDetailInfo &info)744 int32_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 
HoldingHandle(const CallDetailInfo &info)768 int32_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 
WaitingHandle(const CallDetailInfo &info)792 int32_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 
AlertHandle(const CallDetailInfo &info)800 int32_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 
DisconnectingHandle(const CallDetailInfo &info)827 int32_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 
DisconnectedVoipCallHandle(const CallDetailInfo &info)845 int32_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 
DisconnectedHandle(const CallDetailInfo &info)864 int32_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 
GetConferenceCallList(int32_t slotId)905 std::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 
HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call, std::vector<std::u16string> callIdList, CallRunningState previousState, TelCallState priorState)920 void 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 
IsCanUnHold(int32_t activeCallNum, int32_t waitingCallNum, int32_t size, bool &canUnHold)955 void 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 
AutoHandleForDsda( bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId, bool continueAnswer)967 void 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 
AutoUnHoldForDsda( bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId)997 void 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 
AutoAnswerForVoiceCall(sptr<CallBase> ringCall, int32_t slotId, bool continueAnswer)1039 void 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 
AutoAnswerForVideoCall(int32_t activeCallNum)1056 void 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 
AutoAnswer(int32_t activeCallNum, int32_t waitingCallNum)1082 void 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 
UpdateCallState(sptr<CallBase> &call, TelCallState nextState)1109 int32_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 
SetVideoCallState(sptr<CallBase> &call, TelCallState nextState)1149 void 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 
RefreshCallIfNecessary(const sptr<CallBase> &call, const CallDetailInfo &info)1173 sptr<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 
SetOriginalCallTypeForActiveState(sptr<CallBase> &call)1224 void 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 
SetOriginalCallTypeForDisconnectState(sptr<CallBase> &call)1249 void 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 
ToSpeakerPhone(sptr<CallBase> &call)1268 int32_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 
TurnOffMute(sptr<CallBase> &call)1290 int32_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 
CreateNewCall(const CallDetailInfo &info, CallDirection dir)1304 sptr<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 
CreateNewCallByCallType( DialParaInfo &paraInfo, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)1352 sptr<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 
ShouldRejectIncomingCall()1403 bool 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 
ShouldBlockIncomingCall(const sptr<CallBase> &call, const CallDetailInfo &info)1439 bool 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 
IsRingOnceCall(const sptr<CallBase> &call, const CallDetailInfo &info)1469 bool 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 
HandleRingOnceCall(sptr<CallBase> &call)1497 int32_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 
PackParaInfo( DialParaInfo &paraInfo, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)1511 void 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 
IsFocusModeOpen()1547 bool 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 
IsRejectCall(sptr<CallBase> &call, const CallDetailInfo &info, bool &block)1569 bool 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 
CreateAndSaveNewCall(const CallDetailInfo &info, CallDirection direction)1592 void 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 
UpdateCallStateAndHandleDsdsMode(const CallDetailInfo &info, sptr<CallBase> &call)1604 int32_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 
HandleDialWhenHolding(int32_t callId, sptr<CallBase> &call)1639 void 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 
IsDcCallConneceted()1664 bool 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