• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_control_manager.h"
23 #include "call_manager_errors.h"
24 #include "call_manager_hisysevent.h"
25 #include "call_number_utils.h"
26 #include "core_service_client.h"
27 #include "cs_call.h"
28 #include "datashare_predicates.h"
29 #include "hitrace_meter.h"
30 #include "ims_call.h"
31 #include "ott_call.h"
32 #include "report_call_info_handler.h"
33 #include "satellite_call.h"
34 #include "telephony_log_wrapper.h"
35 #include "voip_call.h"
36 
37 namespace OHOS {
38 namespace Telephony {
39 constexpr int32_t INIT_INDEX = 0;
CallStatusManager()40 CallStatusManager::CallStatusManager()
41 {
42     (void)memset_s(&callReportInfo_, sizeof(CallDetailInfo), 0, sizeof(CallDetailInfo));
43     for (int32_t i = 0; i < SLOT_NUM; i++) {
44         (void)memset_s(&callDetailsInfo_[i], sizeof(CallDetailsInfo), 0, sizeof(CallDetailsInfo));
45     }
46 }
47 
~CallStatusManager()48 CallStatusManager::~CallStatusManager()
49 {
50     UnInit();
51 }
52 
Init()53 int32_t CallStatusManager::Init()
54 {
55     for (int32_t i = 0; i < SLOT_NUM; i++) {
56         callDetailsInfo_[i].callVec.clear();
57     }
58     for (int32_t i = 0; i < SLOT_NUM; i++) {
59         priorVideoState_[i] = VideoStateType::TYPE_VOICE;
60     }
61     mEventIdTransferMap_.clear();
62     mOttEventIdTransferMap_.clear();
63     InitCallBaseEvent();
64     CallIncomingFilterManagerPtr_ = (std::make_unique<CallIncomingFilterManager>()).release();
65     return TELEPHONY_SUCCESS;
66 }
67 
InitCallBaseEvent()68 void CallStatusManager::InitCallBaseEvent()
69 {
70     mEventIdTransferMap_[RequestResultEventId::RESULT_DIAL_NO_CARRIER] = CallAbilityEventId::EVENT_DIAL_NO_CARRIER;
71     mEventIdTransferMap_[RequestResultEventId::RESULT_HOLD_SEND_FAILED] = CallAbilityEventId::EVENT_HOLD_CALL_FAILED;
72     mEventIdTransferMap_[RequestResultEventId::RESULT_SWAP_SEND_FAILED] = CallAbilityEventId::EVENT_SWAP_CALL_FAILED;
73     mOttEventIdTransferMap_[OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED] =
74         CallAbilityEventId::EVENT_OTT_FUNCTION_UNSUPPORTED;
75     mEventIdTransferMap_[RequestResultEventId::RESULT_COMBINE_SEND_FAILED] =
76         CallAbilityEventId::EVENT_COMBINE_CALL_FAILED;
77     mEventIdTransferMap_[RequestResultEventId::RESULT_SPLIT_SEND_FAILED] =
78         CallAbilityEventId::EVENT_SPLIT_CALL_FAILED;
79 }
80 
UnInit()81 int32_t CallStatusManager::UnInit()
82 {
83     for (int32_t i = 0; i < SLOT_NUM; i++) {
84         callDetailsInfo_[i].callVec.clear();
85     }
86     mEventIdTransferMap_.clear();
87     mOttEventIdTransferMap_.clear();
88     return TELEPHONY_SUCCESS;
89 }
90 
HandleCallReportInfo(const CallDetailInfo & info)91 int32_t CallStatusManager::HandleCallReportInfo(const CallDetailInfo &info)
92 {
93     int32_t ret = TELEPHONY_ERR_FAIL;
94     callReportInfo_ = info;
95     if (info.callType == CallType::TYPE_VOIP) {
96         ret = HandleVoipCallReportInfo(info);
97         return ret;
98     }
99     switch (info.state) {
100         case TelCallState::CALL_STATUS_ACTIVE:
101             ret = ActiveHandle(info);
102             break;
103         case TelCallState::CALL_STATUS_HOLDING:
104             ret = HoldingHandle(info);
105             break;
106         case TelCallState::CALL_STATUS_DIALING: {
107             ret = DialingHandle(info);
108             FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
109             DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingDialTimeOut(
110                 info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
111             break;
112         }
113         case TelCallState::CALL_STATUS_ALERTING:
114             ret = AlertHandle(info);
115             break;
116         case TelCallState::CALL_STATUS_INCOMING: {
117             ret = IncomingHandle(info);
118             FinishAsyncTrace(HITRACE_TAG_OHOS, "InComingCall", getpid());
119             DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingIncomingTimeOut(
120                 info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
121             break;
122         }
123         case TelCallState::CALL_STATUS_WAITING:
124             ret = WaitingHandle(info);
125             break;
126         case TelCallState::CALL_STATUS_DISCONNECTED:
127             ret = DisconnectedHandle(info);
128             break;
129         case TelCallState::CALL_STATUS_DISCONNECTING:
130             ret = DisconnectingHandle(info);
131             break;
132         default:
133             TELEPHONY_LOGE("Invalid call state!");
134             break;
135     }
136     TELEPHONY_LOGI("Entry CallStatusManager HandleCallReportInfo");
137     HandleDsdaInfo(info.accountId);
138     DelayedSingleton<BluetoothCallService>::GetInstance()->GetCallState();
139     return ret;
140 }
141 
HandleDsdaInfo(int32_t slotId)142 void CallStatusManager::HandleDsdaInfo(int32_t slotId)
143 {
144     int32_t dsdsMode = DSDS_MODE_V2;
145     bool noOtherCall = true;
146     std::list<int32_t> callIdList;
147     GetCarrierCallList(callIdList);
148     int32_t currentCallNum = GetCurrentCallNum();
149     DelayedSingleton<CallRequestProcess>::GetInstance()->IsExistCallOtherSlot(callIdList, slotId, noOtherCall);
150     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
151     if ((dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
152             dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) &&
153         !noOtherCall) {
154         TELEPHONY_LOGI("Handle DsdaCallInfo");
155         sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
156         if (holdCall != nullptr && currentCallNum > CALL_NUMBER) {
157             holdCall->SetCanUnHoldState(false);
158         }
159     }
160 }
161 
162 // handle call state changes, incoming call, outgoing call.
HandleCallsReportInfo(const CallDetailsInfo & info)163 int32_t CallStatusManager::HandleCallsReportInfo(const CallDetailsInfo &info)
164 {
165     bool flag = false;
166     TELEPHONY_LOGI("call list size:%{public}zu,slotId:%{public}d", info.callVec.size(), info.slotId);
167     int32_t curSlotId = info.slotId;
168     if (!DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(curSlotId)) {
169         TELEPHONY_LOGE("invalid slotId!");
170         return CALL_ERR_INVALID_SLOT_ID;
171     }
172     for (auto &it : info.callVec) {
173         for (const auto &it1 : callDetailsInfo_[curSlotId].callVec) {
174             if (it.index == it1.index) {
175                 // call state changes
176                 if (it.state != it1.state || it.mpty != it1.mpty ||
177                     it.callType != it1.callType || it.callMode != it1.callMode) {
178                     TELEPHONY_LOGI("handle updated call state:%{public}d", it.state);
179                     HandleCallReportInfo(it);
180                 }
181                 flag = true;
182                 break;
183             }
184         }
185         // incoming/outgoing call handle
186         if (!flag || callDetailsInfo_[curSlotId].callVec.empty()) {
187             TELEPHONY_LOGI("handle new call state:%{public}d", it.state);
188             HandleCallReportInfo(it);
189         }
190         flag = false;
191     }
192     // disconnected calls handle
193     for (auto &it2 : callDetailsInfo_[curSlotId].callVec) {
194         for (const auto &it3 : info.callVec) {
195             if (it2.index == it3.index) {
196                 TELEPHONY_LOGI("state:%{public}d", it2.state);
197                 flag = true;
198                 break;
199             }
200         }
201         if (!flag) {
202             it2.state = TelCallState::CALL_STATUS_DISCONNECTED;
203             HandleCallReportInfo(it2);
204         }
205         flag = false;
206     }
207     callDetailsInfo_[curSlotId].callVec.clear();
208     callDetailsInfo_[curSlotId] = info;
209     return TELEPHONY_SUCCESS;
210 }
211 
HandleVoipCallReportInfo(const CallDetailInfo & info)212 int32_t CallStatusManager::HandleVoipCallReportInfo(const CallDetailInfo &info)
213 {
214     TELEPHONY_LOGI("Entry CallStatusManager HandleVoipCallReportInfo");
215     int32_t ret = TELEPHONY_ERR_FAIL;
216     switch (info.state) {
217         case TelCallState::CALL_STATUS_ACTIVE:
218             ret = ActiveVoipCallHandle(info);
219             break;
220         case TelCallState::CALL_STATUS_INCOMING: {
221             ret = IncomingVoipCallHandle(info);
222             break;
223         }
224         case TelCallState::CALL_STATUS_DISCONNECTED:
225             ret = DisconnectedVoipCallHandle(info);
226             break;
227         default:
228             TELEPHONY_LOGE("Invalid call state!");
229             break;
230     }
231     DelayedSingleton<BluetoothCallService>::GetInstance()->GetCallState();
232     return ret;
233 }
234 
HandleDisconnectedCause(const DisconnectedDetails & details)235 int32_t CallStatusManager::HandleDisconnectedCause(const DisconnectedDetails &details)
236 {
237     bool ret = DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallDestroyed(details);
238     if (!ret) {
239         TELEPHONY_LOGI("NotifyCallDestroyed failed!");
240         return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
241     }
242     return TELEPHONY_SUCCESS;
243 }
244 
HandleEventResultReportInfo(const CellularCallEventInfo & info)245 int32_t CallStatusManager::HandleEventResultReportInfo(const CellularCallEventInfo &info)
246 {
247     if (info.eventType != CellularCallEventType::EVENT_REQUEST_RESULT_TYPE) {
248         TELEPHONY_LOGE("unexpected type event occurs, eventId:%{public}d", info.eventId);
249         return CALL_ERR_PHONE_TYPE_UNEXPECTED;
250     }
251     TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.eventId);
252     sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
253     if (call != nullptr) {
254         int32_t ret = DealFailDial(call);
255         TELEPHONY_LOGI("DealFailDial ret:%{public}d", ret);
256     }
257     CallEventInfo eventInfo;
258     (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
259     if (mEventIdTransferMap_.find(info.eventId) != mEventIdTransferMap_.end()) {
260         eventInfo.eventId = mEventIdTransferMap_[info.eventId];
261         DialParaInfo dialInfo;
262         if (eventInfo.eventId == CallAbilityEventId::EVENT_DIAL_NO_CARRIER) {
263             DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(dialInfo);
264             if (dialInfo.number.length() > static_cast<size_t>(kMaxNumberLen)) {
265                 TELEPHONY_LOGE("Number out of limit!");
266                 return CALL_ERR_NUMBER_OUT_OF_RANGE;
267             }
268             if (memcpy_s(eventInfo.phoneNum, kMaxNumberLen, dialInfo.number.c_str(), dialInfo.number.length()) != EOK) {
269                 TELEPHONY_LOGE("memcpy_s failed!");
270                 return TELEPHONY_ERR_MEMCPY_FAIL;
271             }
272         } else if (eventInfo.eventId == CallAbilityEventId::EVENT_COMBINE_CALL_FAILED) {
273             sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
274             if (activeCall != nullptr) {
275                 activeCall->HandleCombineConferenceFailEvent();
276             }
277         } else if (eventInfo.eventId == CallAbilityEventId::EVENT_HOLD_CALL_FAILED) {
278             needWaitHold_ = false;
279         }
280         DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
281     } else {
282         TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.eventId);
283     }
284     return TELEPHONY_SUCCESS;
285 }
286 
HandleOttEventReportInfo(const OttCallEventInfo & info)287 int32_t CallStatusManager::HandleOttEventReportInfo(const OttCallEventInfo &info)
288 {
289     TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.ottCallEventId);
290     CallEventInfo eventInfo;
291     (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
292     if (mOttEventIdTransferMap_.find(info.ottCallEventId) != mOttEventIdTransferMap_.end()) {
293         eventInfo.eventId = mOttEventIdTransferMap_[info.ottCallEventId];
294         if (strlen(info.bundleName) > static_cast<size_t>(kMaxNumberLen)) {
295             TELEPHONY_LOGE("Number out of limit!");
296             return CALL_ERR_NUMBER_OUT_OF_RANGE;
297         }
298         if (memcpy_s(eventInfo.bundleName, kMaxNumberLen, info.bundleName, strlen(info.bundleName)) != EOK) {
299             TELEPHONY_LOGE("memcpy_s failed!");
300             return TELEPHONY_ERR_MEMCPY_FAIL;
301         }
302         DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
303     } else {
304         TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.ottCallEventId);
305     }
306     return TELEPHONY_SUCCESS;
307 }
308 
IncomingHandle(const CallDetailInfo & info)309 int32_t CallStatusManager::IncomingHandle(const CallDetailInfo &info)
310 {
311     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
312     if (call != nullptr && (call->GetCallType() != info.callType || call->GetTelCallState() != info.state)) {
313         call = RefreshCallIfNecessary(call, info);
314         if (call->GetCallType() != info.callType) {
315             return UpdateCallState(call, info.state);
316         }
317         return TELEPHONY_SUCCESS;
318     }
319     int32_t ret = IncomingHandlePolicy(info);
320     if (ret != TELEPHONY_SUCCESS) {
321         TELEPHONY_LOGE("IncomingHandlePolicy failed!");
322         if (info.state == TelCallState::CALL_STATUS_INCOMING) {
323             CallManagerHisysevent::WriteIncomingCallFaultEvent(info.accountId, static_cast<int32_t>(info.callType),
324                 static_cast<int32_t>(info.callMode), ret, "IncomingHandlePolicy failed");
325         }
326         return ret;
327     }
328     if (info.callType == CallType::TYPE_CS || info.callType == CallType::TYPE_IMS ||
329         info.callType == CallType::TYPE_SATELLITE) {
330         ret = IncomingFilterPolicy(info);
331         if (ret != TELEPHONY_SUCCESS) {
332             return ret;
333         }
334     }
335     call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
336     if (call == nullptr) {
337         TELEPHONY_LOGE("CreateNewCall failed!");
338         return CALL_ERR_CALL_OBJECT_IS_NULL;
339     }
340 
341     BuildAndQueryCallerInfo(call, info);
342 
343     DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
344     ret = UpdateCallState(call, info.state);
345     if (ret != TELEPHONY_SUCCESS) {
346         TELEPHONY_LOGE("UpdateCallState failed!");
347         return ret;
348     }
349     ret = FilterResultsDispose(call);
350     if (ret != TELEPHONY_SUCCESS) {
351         TELEPHONY_LOGE("FilterResultsDispose failed!");
352     }
353     return ret;
354 }
355 
BuildAndQueryCallerInfo(sptr<CallBase> & call,const CallDetailInfo & info)356 void CallStatusManager::BuildAndQueryCallerInfo(sptr<CallBase> &call, const CallDetailInfo &info)
357 {
358     // allow list filtering
359     // Get the contact data from the database
360     ContactInfo contactInfo = {
361         .name = "",
362         .number = "",
363         .isContacterExists = false,
364         .ringtonePath = "",
365         .isSendToVoicemail = false,
366         .isEcc = false,
367         .isVoiceMail = false,
368     };
369     QueryCallerInfo(contactInfo, std::string(info.phoneNum));
370     call->SetCallerInfo(contactInfo);
371 }
372 
IncomingVoipCallHandle(const CallDetailInfo & info)373 int32_t CallStatusManager::IncomingVoipCallHandle(const CallDetailInfo &info)
374 {
375     int32_t ret = TELEPHONY_ERROR;
376     sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallInfo.voipCallId);
377     if (call != nullptr) {
378         return TELEPHONY_SUCCESS;
379     }
380     call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
381     if (call == nullptr) {
382         TELEPHONY_LOGE("CreateVoipCall failed!");
383         return CALL_ERR_CALL_OBJECT_IS_NULL;
384     }
385     DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
386     ret = UpdateCallState(call, info.state);
387     if (ret != TELEPHONY_SUCCESS) {
388         TELEPHONY_LOGE("UpdateCallState failed!");
389         return ret;
390     }
391     return ret;
392 }
393 
QueryCallerInfo(ContactInfo & contactInfo,std::string phoneNum)394 void CallStatusManager::QueryCallerInfo(ContactInfo &contactInfo, std::string phoneNum)
395 {
396     TELEPHONY_LOGI("Entry CallStatusManager QueryCallerInfo");
397     std::shared_ptr<CallDataBaseHelper> callDataPtr = DelayedSingleton<CallDataBaseHelper>::GetInstance();
398     if (callDataPtr == nullptr) {
399         TELEPHONY_LOGE("callDataPtr is nullptr!");
400         return;
401     }
402     DataShare::DataSharePredicates predicates;
403     predicates.EqualTo(DETAIL_INFO, phoneNum);
404     predicates.And();
405     predicates.EqualTo(CONTENT_TYPE, PHONE);
406     bool ret = callDataPtr->Query(contactInfo, predicates);
407     if (!ret) {
408         TELEPHONY_LOGE("Query contact database fail!");
409     }
410 }
411 
IncomingFilterPolicy(const CallDetailInfo & info)412 int32_t CallStatusManager::IncomingFilterPolicy(const CallDetailInfo &info)
413 {
414     if (CallIncomingFilterManagerPtr_ == nullptr) {
415         TELEPHONY_LOGE("CallIncomingFilterManagerPtr_ is null");
416         return TELEPHONY_ERR_LOCAL_PTR_NULL;
417     }
418     return CallIncomingFilterManagerPtr_->DoIncomingFilter(info);
419 }
420 
CallFilterCompleteResult(const CallDetailInfo & info)421 void CallStatusManager::CallFilterCompleteResult(const CallDetailInfo &info)
422 {
423     int32_t ret = TELEPHONY_ERR_FAIL;
424     sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
425     if (call == nullptr) {
426         TELEPHONY_LOGE("CreateNewCall failed!");
427         return;
428     }
429 #ifdef ABILITY_DATABASE_SUPPORT
430     // allow list filtering
431     // Get the contact data from the database
432     GetCallerInfoDate(ContactInfo);
433     SetCallerInfo(contactInfo);
434 #endif
435     DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
436     ret = UpdateCallState(call, info.state);
437     if (ret != TELEPHONY_SUCCESS) {
438         TELEPHONY_LOGE("UpdateCallState failed!");
439         return;
440     }
441     ret = FilterResultsDispose(call);
442     if (ret != TELEPHONY_SUCCESS) {
443         TELEPHONY_LOGE("FilterResultsDispose failed!");
444         return;
445     }
446 }
447 
UpdateDialingCallInfo(const CallDetailInfo & info)448 int32_t CallStatusManager::UpdateDialingCallInfo(const CallDetailInfo &info)
449 {
450     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
451     if (call != nullptr) {
452         call = RefreshCallIfNecessary(call, info);
453         return TELEPHONY_SUCCESS;
454     }
455     call = GetOneCallObjectByIndex(INIT_INDEX);
456     if (call == nullptr) {
457         TELEPHONY_LOGE("call is nullptr");
458         return TELEPHONY_ERR_LOCAL_PTR_NULL;
459     }
460 
461     std::string oriNum = call->GetAccountNumber();
462     call = RefreshCallIfNecessary(call, info);
463     call->SetCallIndex(info.index);
464     call->SetBundleName(info.bundleName);
465     call->SetSlotId(info.accountId);
466     call->SetTelCallState(info.state);
467     call->SetVideoStateType(info.callMode);
468     call->SetCallType(info.callType);
469     call->SetAccountNumber(oriNum);
470     return TELEPHONY_SUCCESS;
471 }
472 
DialingHandle(const CallDetailInfo & info)473 int32_t CallStatusManager::DialingHandle(const CallDetailInfo &info)
474 {
475     TELEPHONY_LOGI("handle dialing state");
476     if (info.index > 0) {
477         TELEPHONY_LOGI("need update call info");
478         return UpdateDialingCallInfo(info);
479     }
480     sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
481     if (call == nullptr) {
482         TELEPHONY_LOGE("CreateNewCall failed!");
483         return TELEPHONY_ERR_LOCAL_PTR_NULL;
484     }
485     int32_t ret = call->DialingProcess();
486     if (ret != TELEPHONY_SUCCESS) {
487         return ret;
488     }
489     DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
490     ret = UpdateCallState(call, TelCallState::CALL_STATUS_DIALING);
491     if (ret != TELEPHONY_SUCCESS) {
492         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
493     }
494     return ret;
495 }
496 
ActiveHandle(const CallDetailInfo & info)497 int32_t CallStatusManager::ActiveHandle(const CallDetailInfo &info)
498 {
499     TELEPHONY_LOGI("handle active state");
500     std::string tmpStr(info.phoneNum);
501     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
502     if (call == nullptr) {
503         TELEPHONY_LOGE("Call is NULL");
504         return TELEPHONY_ERR_LOCAL_PTR_NULL;
505     }
506     call = RefreshCallIfNecessary(call, info);
507     SetOriginalCallTypeForActiveState(call);
508     // call state change active, need to judge if launching a conference
509     if (info.mpty == 1) {
510         int32_t mainCallId = ERR_ID;
511         call->LaunchConference();
512         call->GetMainCallId(mainCallId);
513         sptr<CallBase> mainCall = GetOneCallObject(mainCallId);
514         if (mainCall != nullptr) {
515             mainCall->SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_ACTIVE);
516         }
517     } else if (call->ExitConference() == TELEPHONY_SUCCESS) {
518         TELEPHONY_LOGI("SubCallSeparateFromConference success!");
519     } else {
520         TELEPHONY_LOGI("SubCallSeparateFromConference fail!");
521     }
522     int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
523     if (ret != TELEPHONY_SUCCESS) {
524         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
525         return ret;
526     }
527     sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
528     if (holdCall != nullptr) {
529         holdCall->SetCanSwitchCallState(true);
530         TELEPHONY_LOGI("holdcall:%{public}d can swap", holdCall->GetCallID());
531     }
532 #ifdef AUDIO_SUPPORT
533     ToSpeakerPhone(call);
534     DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
535 #endif
536     TELEPHONY_LOGI("handle active state success");
537     return ret;
538 }
539 
ActiveVoipCallHandle(const CallDetailInfo & info)540 int32_t CallStatusManager::ActiveVoipCallHandle(const CallDetailInfo &info)
541 {
542     TELEPHONY_LOGI("handle active state");
543     sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallInfo.voipCallId);
544     if (call == nullptr) {
545         TELEPHONY_LOGE("voip Call is NULL");
546         return TELEPHONY_ERR_LOCAL_PTR_NULL;
547     }
548     int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
549     if (ret != TELEPHONY_SUCCESS) {
550         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
551         return ret;
552     }
553     TELEPHONY_LOGI("handle active state success");
554     return ret;
555 }
556 
HoldingHandle(const CallDetailInfo & info)557 int32_t CallStatusManager::HoldingHandle(const CallDetailInfo &info)
558 {
559     TELEPHONY_LOGI("handle holding state");
560     std::string tmpStr(info.phoneNum);
561     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
562     if (call == nullptr) {
563         TELEPHONY_LOGE("Call is NULL");
564         return TELEPHONY_ERR_LOCAL_PTR_NULL;
565     }
566     // if the call is in a conference, it will exit, otherwise just set it holding
567     call = RefreshCallIfNecessary(call, info);
568     if (info.mpty == 1) {
569         int32_t ret = call->HoldConference();
570         if (ret == TELEPHONY_SUCCESS) {
571             TELEPHONY_LOGI("HoldConference success");
572         }
573     }
574     TelCallState priorState = call->GetTelCallState();
575     int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_HOLDING);
576     if (ret != TELEPHONY_SUCCESS) {
577         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
578     }
579     int32_t callId = call->GetCallID();
580     int32_t dsdsMode = DSDS_MODE_V2;
581     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
582     TELEPHONY_LOGE("HoldingHandle dsdsMode:%{public}d", dsdsMode);
583     bool canSwitchCallState = call->GetCanSwitchCallState();
584     if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
585         dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
586         int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
587         if (needWaitHold_ && activeCallNum == 0) {
588             needWaitHold_ = false;
589             int32_t result = DelayedSingleton<CellularCallConnection>::GetInstance()->Dial(GetDialCallInfo());
590             sptr<CallBase> dialCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
591             if (result != TELEPHONY_SUCCESS && dialCall != nullptr) {
592                 DealFailDial(call);
593                 TELEPHONY_LOGI("Dial call fail");
594             }
595         } else {
596             TelConferenceState confState = call->GetTelConferenceState();
597             int32_t conferenceId = ERR_ID;
598             call->GetMainCallId(conferenceId);
599             if (confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == callId) {
600                 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
601             } else if (confState == TelConferenceState::TEL_CONFERENCE_IDLE) {
602                 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
603             }
604         }
605     }
606     return ret;
607 }
608 
WaitingHandle(const CallDetailInfo & info)609 int32_t CallStatusManager::WaitingHandle(const CallDetailInfo &info)
610 {
611     return IncomingHandle(info);
612 }
613 
AlertHandle(const CallDetailInfo & info)614 int32_t CallStatusManager::AlertHandle(const CallDetailInfo &info)
615 {
616     TELEPHONY_LOGI("handle alerting state");
617     std::string tmpStr(info.phoneNum);
618     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
619     if (call == nullptr) {
620         TELEPHONY_LOGE("Call is NULL");
621         return TELEPHONY_ERR_LOCAL_PTR_NULL;
622     }
623     call = RefreshCallIfNecessary(call, info);
624     int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ALERTING);
625     if (ret != TELEPHONY_SUCCESS) {
626         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
627         return ret;
628     }
629 #ifdef AUDIO_SUPPORT
630     ToSpeakerPhone(call);
631     TurnOffMute(call);
632     DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
633 #endif
634     return ret;
635 }
636 
DisconnectingHandle(const CallDetailInfo & info)637 int32_t CallStatusManager::DisconnectingHandle(const CallDetailInfo &info)
638 {
639     TELEPHONY_LOGI("handle disconnecting state");
640     std::string tmpStr(info.phoneNum);
641     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
642     if (call == nullptr) {
643         TELEPHONY_LOGE("Call is NULL");
644         return TELEPHONY_ERR_LOCAL_PTR_NULL;
645     }
646     call = RefreshCallIfNecessary(call, info);
647     SetOriginalCallTypeForDisconnectState(call);
648     int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTING);
649     if (ret != TELEPHONY_SUCCESS) {
650         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
651     }
652     return ret;
653 }
654 
DisconnectedVoipCallHandle(const CallDetailInfo & info)655 int32_t CallStatusManager::DisconnectedVoipCallHandle(const CallDetailInfo &info)
656 {
657     TELEPHONY_LOGI("handle disconnected voip call state");
658     sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallInfo.voipCallId);
659     if (call == nullptr) {
660         TELEPHONY_LOGE("voip Call is NULL");
661         return TELEPHONY_ERR_LOCAL_PTR_NULL;
662     }
663     int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
664     if (ret != TELEPHONY_SUCCESS) {
665         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
666         return ret;
667     }
668     DeleteOneCallObject(call->GetCallID());
669     TELEPHONY_LOGI("handle disconnected voip call state success");
670     return ret;
671 }
672 
DisconnectedHandle(const CallDetailInfo & info)673 int32_t CallStatusManager::DisconnectedHandle(const CallDetailInfo &info)
674 {
675     TELEPHONY_LOGI("handle disconnected state");
676     std::string tmpStr(info.phoneNum);
677     sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
678     if (call == nullptr) {
679         TELEPHONY_LOGE("call is null");
680         return TELEPHONY_ERR_LOCAL_PTR_NULL;
681     }
682     call = RefreshCallIfNecessary(call, info);
683     SetOriginalCallTypeForDisconnectState(call);
684     std::vector<std::u16string> callIdList;
685     call->GetSubCallIdList(callIdList);
686     CallRunningState previousState = call->GetCallRunningState();
687     int32_t ret = call->ExitConference();
688     if (ret == TELEPHONY_SUCCESS) {
689         TELEPHONY_LOGI("SubCallSeparateFromConference success");
690     }
691     TelCallState priorState = call->GetTelCallState();
692     ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
693     if (ret != TELEPHONY_SUCCESS) {
694         TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
695         return ret;
696     }
697     HandleHoldCallOrAutoAnswerCall(call, callIdList, previousState, priorState);
698     return ret;
699 }
700 
HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,std::vector<std::u16string> callIdList,CallRunningState previousState,TelCallState priorState)701 void CallStatusManager::HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,
702     std::vector<std::u16string> callIdList, CallRunningState previousState, TelCallState priorState)
703 {
704     if (call == nullptr) {
705         TELEPHONY_LOGE("call is null");
706         return;
707     }
708     bool canUnHold = false;
709     size_t size = callIdList.size();
710     int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
711     int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
712     IsCanUnHold(activeCallNum, waitingCallNum, size, canUnHold);
713     sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
714     if (previousState != CallRunningState::CALL_RUNNING_STATE_HOLD &&
715         previousState != CallRunningState::CALL_RUNNING_STATE_ACTIVE &&
716         priorState == TelCallState::CALL_STATUS_DISCONNECTING) {
717         if (holdCall != nullptr && canUnHold && holdCall->GetCanUnHoldState()) {
718             if (holdCall->GetSlotId() == call->GetSlotId()) {
719                 TELEPHONY_LOGI("release call and recover the held call");
720                 holdCall->UnHoldCall();
721             }
722         }
723     }
724     DeleteOneCallObject(call->GetCallID());
725     int32_t dsdsMode = DSDS_MODE_V2;
726     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
727     if (dsdsMode == DSDS_MODE_V3) {
728         AutoAnswer(activeCallNum, waitingCallNum);
729     } else if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
730         dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
731         bool canSwitchCallState = call->GetCanSwitchCallState();
732         AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), true);
733     }
734 }
735 
IsCanUnHold(int32_t activeCallNum,int32_t waitingCallNum,int32_t size,bool & canUnHold)736 void CallStatusManager::IsCanUnHold(int32_t activeCallNum, int32_t waitingCallNum, int32_t size, bool &canUnHold)
737 {
738     int32_t incomingCallNum = GetCallNum(TelCallState::CALL_STATUS_INCOMING);
739     int32_t answeredCallNum = GetCallNum(TelCallState::CALL_STATUS_ANSWERED);
740     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
741     if (answeredCallNum == 0 && incomingCallNum == 0 && (size == 0 || size == 1) && activeCallNum == 0 &&
742         waitingCallNum == 0 && dialingCallNum == 0) {
743         canUnHold = true;
744     }
745     TELEPHONY_LOGI("CanUnHold state: %{public}d", canUnHold);
746 }
747 
AutoHandleForDsda(bool canSwitchCallState,TelCallState priorState,int32_t activeCallNum,int32_t slotId,bool continueAnswer)748 void CallStatusManager::AutoHandleForDsda(
749     bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId, bool continueAnswer)
750 {
751     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
752     int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
753     std::list<int32_t> callIdList;
754     GetCarrierCallList(callIdList);
755     for (int32_t ringCallId : callIdList) {
756         sptr<CallBase> ringCall = GetOneCallObject(ringCallId);
757         if (ringCall != nullptr && ringCall->GetAutoAnswerState()) {
758             TELEPHONY_LOGI("ringCall is not nullptr");
759             int32_t videoState = static_cast<int32_t>(ringCall->GetVideoStateType());
760             if (videoState == static_cast<int32_t>(VideoStateType::TYPE_VIDEO)) {
761                 TELEPHONY_LOGI("AutoAnswer VideoCall for Dsda");
762                 AutoAnswerForVideoCall(activeCallNum);
763                 return;
764             }
765             if (dialingCallNum == 0 && alertingCallNum == 0 && activeCallNum == 0 &&
766                 ringCall->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_RINGING) {
767                 AutoAnswerForVoiceCall(ringCall, slotId, continueAnswer);
768                 return;
769             }
770         }
771     }
772     AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
773 }
774 
AutoUnHoldForDsda(bool canSwitchCallState,TelCallState priorState,int32_t activeCallNum,int32_t slotId)775 void CallStatusManager::AutoUnHoldForDsda(
776     bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId)
777 {
778     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
779     int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
780     int32_t callNum = 2;
781     std::list<int32_t> callIdList;
782     GetCarrierCallList(callIdList);
783     int32_t currentCallNum = GetCurrentCallNum();
784     for (int32_t otherCallId : callIdList) {
785         sptr<CallBase> otherCall = GetOneCallObject(otherCallId);
786         TelCallState state = otherCall->GetTelCallState();
787         TelConferenceState confState = otherCall->GetTelConferenceState();
788         int32_t conferenceId = ERR_ID;
789         otherCall->GetMainCallId(conferenceId);
790         if (otherCall != nullptr && slotId != otherCall->GetSlotId() && state == TelCallState::CALL_STATUS_HOLDING &&
791             otherCall->GetCanUnHoldState() && activeCallNum == 0 && waitingCallNum == 0 &&
792             dialingCallNum == 0 &&
793             ((confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == otherCallId) ||
794                 confState == TelConferenceState::TEL_CONFERENCE_IDLE)) {
795             // Actively hang up the processing unhold state or exchange call
796             if (priorState == TelCallState::CALL_STATUS_DISCONNECTING ||
797                 (!canSwitchCallState && currentCallNum == callNum)) {
798                 otherCall->UnHoldCall();
799                 return;
800             }
801         }
802     }
803     for (int32_t otherCallId : callIdList) {
804         sptr<CallBase> holdCall = GetOneCallObject(otherCallId);
805         if (holdCall != nullptr && holdCall->GetTelCallState() == TelCallState::CALL_STATUS_HOLDING) {
806             if (currentCallNum == callNum) {
807                 holdCall->SetCanUnHoldState(true);
808             }
809         }
810     }
811 }
812 
AutoAnswerForVoiceCall(sptr<CallBase> ringCall,int32_t slotId,bool continueAnswer)813 void CallStatusManager::AutoAnswerForVoiceCall(sptr<CallBase> ringCall, int32_t slotId, bool continueAnswer)
814 {
815     /* Need to check whether the autoAnswer call and the holding call are on the same slotid
816      * To prevent repeated AT command delivery.
817      */
818     if (continueAnswer || slotId != ringCall->GetSlotId()) {
819         DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(
820             ringCall, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED);
821         int ret = ringCall->AnswerCall(ringCall->GetAnswerVideoState());
822         if (ret == TELEPHONY_SUCCESS) {
823             DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(ringCall);
824         }
825         TELEPHONY_LOGI("ret = %{public}d", ret);
826     }
827     ringCall->SetAutoAnswerState(false);
828 }
829 
AutoAnswerForVideoCall(int32_t activeCallNum)830 void CallStatusManager::AutoAnswerForVideoCall(int32_t activeCallNum)
831 {
832     int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
833     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
834     int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
835     if (activeCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 && alertingCallNum == 0) {
836         std::list<int32_t> ringCallIdList;
837         GetCarrierCallList(ringCallIdList);
838         for (int32_t ringingCallId : ringCallIdList) {
839             sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
840             CallRunningState ringingCallState = ringingCall->GetCallRunningState();
841             if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
842                     (ringingCall->GetAutoAnswerState()))) {
843                 ringingCall->SetAutoAnswerState(false);
844                 int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
845                 TELEPHONY_LOGI("ret = %{public}d", ret);
846                 break;
847             }
848         }
849     }
850 }
851 
AutoAnswer(int32_t activeCallNum,int32_t waitingCallNum)852 void CallStatusManager::AutoAnswer(int32_t activeCallNum, int32_t waitingCallNum)
853 {
854     int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
855     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
856     int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
857     if (activeCallNum == 0 && waitingCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 &&
858         alertingCallNum == 0) {
859         std::list<int32_t> ringCallIdList;
860         GetCarrierCallList(ringCallIdList);
861         for (int32_t ringingCallId : ringCallIdList) {
862             sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
863             CallRunningState ringingCallState = ringingCall->GetCallRunningState();
864             if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
865                     (ringingCall->GetAutoAnswerState()))) {
866                 ringingCall->SetAutoAnswerState(false);
867                 int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
868                 TELEPHONY_LOGI("ret = %{public}d", ret);
869                 break;
870             }
871         }
872     }
873 }
874 
UpdateCallState(sptr<CallBase> & call,TelCallState nextState)875 int32_t CallStatusManager::UpdateCallState(sptr<CallBase> &call, TelCallState nextState)
876 {
877     TELEPHONY_LOGI("UpdateCallState start");
878     if (call == nullptr) {
879         TELEPHONY_LOGE("Call is NULL");
880         return TELEPHONY_ERR_LOCAL_PTR_NULL;
881     }
882     TelCallState priorState = call->GetTelCallState();
883     VideoStateType videoState = call->GetVideoStateType();
884     TELEPHONY_LOGI(
885         "callIndex:%{public}d, callId:%{public}d, priorState:%{public}d, nextState:%{public}d, videoState:%{public}d",
886         call->GetCallIndex(), call->GetCallID(), priorState, nextState, videoState);
887     if (priorState == TelCallState::CALL_STATUS_INCOMING && nextState == TelCallState::CALL_STATUS_ACTIVE) {
888         DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingAnswerTimeOut(
889             call->GetSlotId(), call->GetCallID(), static_cast<int32_t>(call->GetVideoStateType()));
890     }
891     // need DTMF judge
892     int32_t ret = call->SetTelCallState(nextState);
893     if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
894         TELEPHONY_LOGE("SetTelCallState failed");
895         return TELEPHONY_ERR_LOCAL_PTR_NULL;
896     }
897     // notify state changed
898     if (!DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(call, priorState, nextState)) {
899         TELEPHONY_LOGE(
900             "NotifyCallStateUpdated failed! priorState:%{public}d,nextState:%{public}d", priorState, nextState);
901         if (nextState == TelCallState::CALL_STATUS_INCOMING) {
902             CallManagerHisysevent::WriteIncomingCallFaultEvent(call->GetSlotId(),
903                 static_cast<int32_t>(call->GetCallType()), static_cast<int32_t>(call->GetVideoStateType()), ret,
904                 "NotifyCallStateUpdated failed");
905         }
906         return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
907     }
908     int slotId = call->GetSlotId();
909     bool isSlotIdValid = false;
910     if (slotId < SLOT_NUM && slotId >= 0) {
911         isSlotIdValid = true;
912     }
913     TELEPHONY_LOGI("nextVideoState:%{public}d, priorVideoState:%{public}d, isSlotIdValid:%{public}d", videoState,
914         priorVideoState_[slotId], isSlotIdValid);
915     if (isSlotIdValid && (priorVideoState_[slotId] != videoState)) {
916         DelayedSingleton<AudioControlManager>::GetInstance()->VideoStateUpdated(
917             call, priorVideoState_[slotId], videoState);
918         priorVideoState_[slotId] = videoState;
919     }
920     if (isSlotIdValid && (nextState == TelCallState::CALL_STATUS_DISCONNECTED)) {
921         priorVideoState_[slotId] = VideoStateType::TYPE_VOICE;
922     }
923     return TELEPHONY_SUCCESS;
924 }
925 
RefreshCallIfNecessary(const sptr<CallBase> & call,const CallDetailInfo & info)926 sptr<CallBase> CallStatusManager::RefreshCallIfNecessary(const sptr<CallBase> &call, const CallDetailInfo &info)
927 {
928     TELEPHONY_LOGI("RefreshCallIfNecessary");
929     if (call->GetCallType() == CallType::TYPE_IMS && call->GetVideoStateType() != info.callMode) {
930         call->SetVideoStateType(info.callMode);
931         sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
932         imsCall->InitVideoCall();
933     }
934     if (call->GetCallType() == CallType::TYPE_IMS) {
935         call->SetCrsType(info.crsType);
936     }
937     if (call->GetCallType() == info.callType) {
938         TELEPHONY_LOGI("RefreshCallIfNecessary not need Refresh");
939         return call;
940     }
941     TelCallState priorState = call->GetTelCallState();
942     CallAttributeInfo attrInfo;
943     (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
944     call->GetCallAttributeBaseInfo(attrInfo);
945     sptr<CallBase> newCall = CreateNewCall(info, attrInfo.callDirection);
946     if (newCall == nullptr) {
947         TELEPHONY_LOGE("RefreshCallIfNecessary createCallFail");
948         return call;
949     }
950     newCall->SetCallRunningState(call->GetCallRunningState());
951     newCall->SetTelConferenceState(call->GetTelConferenceState());
952     newCall->SetStartTime(attrInfo.startTime);
953     newCall->SetPolicyFlag(PolicyFlag(call->GetPolicyFlag()));
954     newCall->SetSpeakerphoneOn(call->IsSpeakerphoneOn());
955     newCall->SetCallEndedType(call->GetCallEndedType());
956     newCall->SetCallBeginTime(attrInfo.callBeginTime);
957     newCall->SetCallEndTime(attrInfo.callEndTime);
958     newCall->SetRingBeginTime(attrInfo.ringBeginTime);
959     newCall->SetRingEndTime(attrInfo.ringEndTime);
960     newCall->SetAnswerType(attrInfo.answerType);
961     newCall->SetMicPhoneState(call->IsMuted());
962     DeleteOneCallObject(call->GetCallID());
963     newCall->SetCallId(call->GetCallID());
964     newCall->SetTelCallState(priorState);
965     return newCall;
966 }
967 
SetOriginalCallTypeForActiveState(sptr<CallBase> & call)968 void CallStatusManager::SetOriginalCallTypeForActiveState(sptr<CallBase> &call)
969 {
970     if (call == nullptr) {
971         TELEPHONY_LOGE("Call is NULL");
972         return;
973     }
974     TelCallState priorState = call->GetTelCallState();
975     VideoStateType videoState = call->GetVideoStateType();
976     int32_t videoStateHistory = call->GetOriginalCallType();
977     if (priorState == TelCallState::CALL_STATUS_ALERTING || priorState == TelCallState::CALL_STATUS_INCOMING ||
978         priorState == TelCallState::CALL_STATUS_WAITING) {
979         // outgoing/incoming video call, but accepted/answered with voice call
980         if (videoStateHistory != static_cast<int32_t>(videoState)) {
981             TELEPHONY_LOGD("set videoState:%{public}d as original call type", static_cast<int32_t>(videoState));
982             call->SetOriginalCallType(static_cast<int32_t>(videoState));
983         }
984     } else if (priorState == TelCallState::CALL_STATUS_ACTIVE || priorState == TelCallState::CALL_STATUS_HOLDING) {
985         int32_t videoStateCurrent = videoStateHistory | static_cast<int32_t>(videoState);
986         TELEPHONY_LOGD("maybe upgrade/downgrade operation, keep video record always, videoStateCurrent:%{public}d",
987             videoStateCurrent);
988         call->SetOriginalCallType(videoStateCurrent);
989     }
990 }
991 
SetOriginalCallTypeForDisconnectState(sptr<CallBase> & call)992 void CallStatusManager::SetOriginalCallTypeForDisconnectState(sptr<CallBase> &call)
993 {
994     if (call == nullptr) {
995         TELEPHONY_LOGE("Call is NULL");
996         return;
997     }
998     TelCallState priorState = call->GetTelCallState();
999     CallAttributeInfo attrInfo;
1000     (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
1001     call->GetCallAttributeBaseInfo(attrInfo);
1002     if (priorState == TelCallState::CALL_STATUS_DIALING || priorState == TelCallState::CALL_STATUS_ALERTING ||
1003         ((priorState == TelCallState::CALL_STATUS_INCOMING || priorState == TelCallState::CALL_STATUS_WAITING) &&
1004         attrInfo.answerType != CallAnswerType::CALL_ANSWER_REJECT)) {
1005         // outgoing/incoming video call, but canceled or missed
1006         TELEPHONY_LOGD("canceled or missed call, set voice type as original call type");
1007         call->SetOriginalCallType(static_cast<int32_t>(VideoStateType::TYPE_VOICE));
1008     }
1009 }
1010 
ToSpeakerPhone(sptr<CallBase> & call)1011 int32_t CallStatusManager::ToSpeakerPhone(sptr<CallBase> &call)
1012 {
1013     int32_t ret = TELEPHONY_ERR_FAIL;
1014     if (call == nullptr) {
1015         TELEPHONY_LOGE("Call is NULL");
1016         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1017     }
1018     if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_DIALING) {
1019         TELEPHONY_LOGI("Call is CALL_STATUS_DIALING");
1020         return ret;
1021     }
1022     if (call->IsSpeakerphoneOn()) {
1023         AudioDevice device = {
1024             .deviceType = AudioDeviceType::DEVICE_SPEAKER,
1025             .address = { 0 },
1026         };
1027         DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(device);
1028         ret = call->SetSpeakerphoneOn(false);
1029     }
1030     return ret;
1031 }
1032 
TurnOffMute(sptr<CallBase> & call)1033 int32_t CallStatusManager::TurnOffMute(sptr<CallBase> &call)
1034 {
1035     bool enabled = true;
1036     if (HasEmergencyCall(enabled) != TELEPHONY_SUCCESS) {
1037         TELEPHONY_LOGI("CallStatusManager::TurnOffMute HasEmergencyCall failed.");
1038     }
1039     if (call->GetEmergencyState() || enabled) {
1040         DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(false);
1041     } else {
1042         DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(true);
1043     }
1044     return TELEPHONY_SUCCESS;
1045 }
1046 
CreateNewCall(const CallDetailInfo & info,CallDirection dir)1047 sptr<CallBase> CallStatusManager::CreateNewCall(const CallDetailInfo &info, CallDirection dir)
1048 {
1049     DialParaInfo paraInfo;
1050     AppExecFwk::PacMap extras;
1051     extras.Clear();
1052     PackParaInfo(paraInfo, info, dir, extras);
1053 
1054     sptr<CallBase> callPtr = CreateNewCallByCallType(paraInfo, info, dir, extras);
1055     if (callPtr == nullptr) {
1056         TELEPHONY_LOGE("CreateNewCall failed!");
1057         return nullptr;
1058     }
1059     callPtr->SetOriginalCallType(info.originalCallType);
1060     TELEPHONY_LOGD("originalCallType:%{public}d", info.originalCallType);
1061     AddOneCallObject(callPtr);
1062     return callPtr;
1063 }
1064 
CreateNewCallByCallType(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1065 sptr<CallBase> CallStatusManager::CreateNewCallByCallType(
1066     DialParaInfo &paraInfo, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1067 {
1068     sptr<CallBase> callPtr = nullptr;
1069     switch (info.callType) {
1070         case CallType::TYPE_CS: {
1071             if (dir == CallDirection::CALL_DIRECTION_OUT) {
1072                 callPtr = (std::make_unique<CSCall>(paraInfo, extras)).release();
1073             } else {
1074                 callPtr = (std::make_unique<CSCall>(paraInfo)).release();
1075             }
1076             break;
1077         }
1078         case CallType::TYPE_IMS: {
1079             if (dir == CallDirection::CALL_DIRECTION_OUT) {
1080                 callPtr = (std::make_unique<IMSCall>(paraInfo, extras)).release();
1081             } else {
1082                 callPtr = (std::make_unique<IMSCall>(paraInfo)).release();
1083             }
1084             if (callPtr->GetCallType() == CallType::TYPE_IMS) {
1085                 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(callPtr.GetRefPtr());
1086                 imsCall->InitVideoCall();
1087             }
1088             break;
1089         }
1090         case CallType::TYPE_OTT: {
1091             if (dir == CallDirection::CALL_DIRECTION_OUT) {
1092                 callPtr = (std::make_unique<OTTCall>(paraInfo, extras)).release();
1093             } else {
1094                 callPtr = (std::make_unique<OTTCall>(paraInfo)).release();
1095             }
1096             break;
1097         }
1098         case CallType::TYPE_VOIP: {
1099             callPtr = (std::make_unique<VoIPCall>(paraInfo)).release();
1100             break;
1101         }
1102         case CallType::TYPE_SATELLITE: {
1103             if (dir == CallDirection::CALL_DIRECTION_OUT) {
1104                 callPtr = (std::make_unique<SatelliteCall>(paraInfo, extras)).release();
1105             } else {
1106                 callPtr = (std::make_unique<SatelliteCall>(paraInfo)).release();
1107             }
1108             break;
1109         }
1110         default:
1111             return nullptr;
1112     }
1113     return callPtr;
1114 }
1115 
PackParaInfo(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1116 void CallStatusManager::PackParaInfo(
1117     DialParaInfo &paraInfo, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1118 {
1119     paraInfo.isEcc = false;
1120     paraInfo.dialType = DialType::DIAL_CARRIER_TYPE;
1121     if (dir == CallDirection::CALL_DIRECTION_OUT) {
1122         DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(paraInfo, extras);
1123     }
1124     if (info.callType == CallType::TYPE_VOIP) {
1125         paraInfo.voipCallInfo.voipCallId = info.voipCallInfo.voipCallId;
1126         paraInfo.voipCallInfo.userName = info.voipCallInfo.userName;
1127         (paraInfo.voipCallInfo.userProfile).assign(
1128             (info.voipCallInfo.userProfile).begin(), (info.voipCallInfo.userProfile).end());
1129         paraInfo.voipCallInfo.abilityName = info.voipCallInfo.abilityName;
1130         paraInfo.voipCallInfo.extensionId = info.voipCallInfo.extensionId;
1131         paraInfo.voipCallInfo.voipBundleName = info.voipCallInfo.voipBundleName;
1132     }
1133     paraInfo.number = info.phoneNum;
1134     paraInfo.callId = GetNewCallId();
1135     paraInfo.index = info.index;
1136     paraInfo.videoState = info.callMode;
1137     paraInfo.accountId = info.accountId;
1138     paraInfo.callType = info.callType;
1139     paraInfo.callState = info.state;
1140     paraInfo.bundleName = info.bundleName;
1141     paraInfo.crsType = info.crsType;
1142     paraInfo.originalCallType = info.originalCallType;
1143 }
1144 } // namespace Telephony
1145 } // namespace OHOS
1146