1 /*
2  * Copyright (C) 2021 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_request_process.h"
17 
18 #include "call_ability_report_proxy.h"
19 #include "call_control_manager.h"
20 #include "call_dialog.h"
21 #include "call_manager_errors.h"
22 #include "call_manager_hisysevent.h"
23 #include "call_number_utils.h"
24 #include "call_request_event_handler_helper.h"
25 #include "cellular_call_connection.h"
26 #include "common_type.h"
27 #include "core_service_client.h"
28 #include "core_service_connection.h"
29 #include "cs_call.h"
30 #include "ims_call.h"
31 #include "ott_call.h"
32 #include "report_call_info_handler.h"
33 #include "telephony_log_wrapper.h"
34 
35 namespace OHOS {
36 namespace Telephony {
37 bool g_flagForDsda = false;
38 
CallRequestProcess()39 CallRequestProcess::CallRequestProcess() {}
40 
~CallRequestProcess()41 CallRequestProcess::~CallRequestProcess() {}
42 
DialRequest()43 int32_t CallRequestProcess::DialRequest()
44 {
45     DialParaInfo info;
46     DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(info);
47     if (!info.isDialing) {
48         TELEPHONY_LOGE("the device is not dialing!");
49         CallManagerHisysevent::WriteDialCallFaultEvent(info.accountId, static_cast<int32_t>(info.callType),
50             static_cast<int32_t>(info.videoState), static_cast<int32_t>(CallErrorCode::CALL_ERROR_DEVICE_NOT_DIALING),
51             "the device is not dialing");
52         return CALL_ERR_ILLEGAL_CALL_OPERATION;
53     }
54     if (info.number.length() > static_cast<size_t>(kMaxNumberLen)) {
55         TELEPHONY_LOGE("Number out of limit!");
56         return CALL_ERR_NUMBER_OUT_OF_RANGE;
57     }
58     bool isEcc = false;
59     DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(info.number, info.accountId, isEcc);
60     if (!isEcc && info.dialType == DialType::DIAL_CARRIER_TYPE &&
61         DelayedSingleton<CoreServiceConnection>::GetInstance()->IsFdnEnabled(info.accountId)) {
62         std::vector<std::u16string> fdnNumberList =
63             DelayedSingleton<CoreServiceConnection>::GetInstance()->GetFdnNumberList(info.accountId);
64         if (fdnNumberList.empty() || !IsFdnNumber(fdnNumberList, info.number)) {
65             CallEventInfo eventInfo;
66             (void)memset_s(eventInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen);
67             eventInfo.eventId = CallAbilityEventId::EVENT_INVALID_FDN_NUMBER;
68             (void)memcpy_s(eventInfo.phoneNum, kMaxNumberLen, info.number.c_str(), info.number.length());
69             DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
70             CallManagerHisysevent::WriteDialCallFaultEvent(info.accountId, static_cast<int32_t>(info.callType),
71                 static_cast<int32_t>(info.videoState),
72                 static_cast<int32_t>(CallErrorCode::CALL_ERROR_INVALID_FDN_NUMBER), "invalid fdn number!");
73             DelayedSingleton<CallDialog>::GetInstance()->DialogConnectExtension("CALL_FAILED_DUE_TO_FDN");
74             return CALL_ERR_DIAL_FAILED;
75         }
76     }
77     TELEPHONY_LOGI("dialType:%{public}d", info.dialType);
78     int32_t ret = CALL_ERR_UNKNOW_DIAL_TYPE;
79     switch (info.dialType) {
80         case DialType::DIAL_CARRIER_TYPE:
81             ret = CarrierDialProcess(info);
82             break;
83         case DialType::DIAL_VOICE_MAIL_TYPE:
84             ret = VoiceMailDialProcess(info);
85             break;
86         case DialType::DIAL_OTT_TYPE:
87             ret = OttDialProcess(info);
88             break;
89         default:
90             break;
91     }
92     return ret;
93 }
94 
AnswerRequest(int32_t callId,int32_t videoState)95 void CallRequestProcess::AnswerRequest(int32_t callId, int32_t videoState)
96 {
97     sptr<CallBase> call = GetOneCallObject(callId);
98     if (call == nullptr) {
99         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
100         return;
101     }
102     call->SetAnswerVideoState(videoState);
103     if (call->GetCallType() == CallType::TYPE_VOIP) {
104         int32_t ret = call->AnswerCall(videoState);
105         if (ret != TELEPHONY_SUCCESS) {
106             TELEPHONY_LOGE("AnswerCall failed!");
107             return;
108         }
109         DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(call);
110         return;
111     }
112     AnswerRequestForDsda(call, callId, videoState);
113 }
114 
AnswerRequestForDsda(sptr<CallBase> call,int32_t callId,int32_t videoState)115 void CallRequestProcess::AnswerRequestForDsda(sptr<CallBase> call, int32_t callId, int32_t videoState)
116 {
117     int32_t slotId = call->GetSlotId();
118     int32_t callCrsType = 2;
119     if (IsDsdsMode3()) {
120         DisconnectOtherSubIdCall(callId, slotId, videoState);
121     } else if (IsDsdsMode5()) {
122         if (NeedAnswerVTAndEndActiveVO(callId, videoState)) {
123             TELEPHONY_LOGI("Answer videoCall for Dsda");
124             DisconnectOtherCallForVideoCall(callId);
125             call->SetAutoAnswerState(true);
126             return;
127         } else if (NeedAnswerVOAndEndActiveVT(callId, videoState)) {
128             TELEPHONY_LOGI("Answer voiceCall for Dsda, but has video call");
129             DisconnectOtherCallForVideoCall(callId);
130             call->SetAutoAnswerState(true);
131             return;
132         }
133         // There is already an incoming call to the CRS.
134         int32_t otherRingCallId = GetOtherRingingCall(callId);
135         if (otherRingCallId != INVALID_CALLID) {
136             sptr<CallBase> ringingCall = GetOneCallObject(otherRingCallId);
137             if (ringingCall != nullptr && ringingCall->GetCrsType() == callCrsType) {
138                 ringingCall->HangUpCall();
139                 call->SetAutoAnswerState(true);
140                 return;
141             }
142         }
143         call->SetAutoAnswerState(true);
144         HoldOrDisconnectedCall(callId, slotId, videoState);
145     } else {
146         int32_t ret = call->AnswerCall(videoState);
147         if (ret != TELEPHONY_SUCCESS) {
148             TELEPHONY_LOGE("AnswerCall failed!");
149             return;
150         }
151         DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(call);
152     }
153 }
154 
IsDsdsMode3()155 bool CallRequestProcess::IsDsdsMode3()
156 {
157     int32_t dsdsMode = DSDS_MODE_V2;
158     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
159     TELEPHONY_LOGI("dsdsMode:%{public}d", dsdsMode);
160     if (dsdsMode == DSDS_MODE_V3) {
161         return true;
162     }
163     return false;
164 }
165 
IsDsdsMode5()166 bool CallRequestProcess::IsDsdsMode5()
167 {
168     int32_t dsdsMode = DSDS_MODE_V2;
169     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
170     TELEPHONY_LOGI("IsDsdsMode5:%{public}d", dsdsMode);
171     if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
172         dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
173         return true;
174     }
175     return false;
176 }
177 
HasDialingCall()178 bool CallRequestProcess::HasDialingCall()
179 {
180     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
181     int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
182     if (dialingCallNum == 0 && alertingCallNum == 0) {
183         return false;
184     }
185     return true;
186 }
187 
HasActiveCall()188 bool CallRequestProcess::HasActiveCall()
189 {
190     int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
191     int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
192     int32_t answeredCallNum = GetCallNum(TelCallState::CALL_STATUS_ANSWERED);
193     if (activeCallNum == 0 && holdingCallNum == 0 && answeredCallNum == 0) {
194         return false;
195     }
196     return true;
197 }
198 
NeedAnswerVTAndEndActiveVO(int32_t callId,int32_t videoState)199 bool CallRequestProcess::NeedAnswerVTAndEndActiveVO(int32_t callId, int32_t videoState)
200 {
201     TELEPHONY_LOGI("Enter NeedAnswerVTAndEndActiveVO");
202     sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
203     sptr<CallBase> holdingCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
204     // if this call is existed foreground or backgroud call, don't hang up it.
205     if ((activeCall != nullptr && activeCall->GetCallID() == callId) ||
206         (holdingCall != nullptr && holdingCall->GetCallID() == callId)) {
207         return false;
208     }
209     if (HasDialingCall() || HasActiveCall()) {
210         if (videoState != static_cast<int32_t>(VideoStateType::TYPE_VOICE)) {
211             TELEPHONY_LOGI("answer a new video call, need to hang up the exist call");
212             return true;
213         }
214     }
215     return false;
216 }
217 
NeedAnswerVOAndEndActiveVT(int32_t callId,int32_t videoState)218 bool CallRequestProcess::NeedAnswerVOAndEndActiveVT(int32_t callId, int32_t videoState)
219 {
220     if (videoState != static_cast<int32_t>(VideoStateType::TYPE_VOICE)) {
221         return false;
222     }
223     if (HasActiveCall()) {
224         sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
225         sptr<CallBase> holdingCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
226         if ((activeCall != nullptr && activeCall->GetVideoStateType() != VideoStateType::TYPE_VOICE &&
227                 activeCall->GetCallID() != callId) ||
228             (holdingCall != nullptr && holdingCall->GetVideoStateType() != VideoStateType::TYPE_VOICE &&
229                 holdingCall->GetCallID() != callId)) {
230             TELEPHONY_LOGI("answer a new voice call, need to hang up the exist video call");
231             return true;
232         }
233     }
234     return false;
235 }
236 
GetOtherRingingCall(int32_t currentCallId)237 int32_t CallRequestProcess::GetOtherRingingCall(int32_t currentCallId)
238 {
239     int32_t otherRingCallId = INVALID_CALLID;
240     std::list<int32_t> callIdList;
241     GetCarrierCallList(callIdList);
242     for (int32_t otherCallId : callIdList) {
243         if (otherCallId == currentCallId) {
244             continue;
245         }
246         sptr<CallBase> call = GetOneCallObject(otherCallId);
247         if (call != nullptr && call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_RINGING) {
248             otherRingCallId = call->GetCallID();
249             break;
250         }
251     }
252     return otherRingCallId;
253 }
254 
HoldOrDisconnectedCall(int32_t callId,int32_t slotId,int32_t videoState)255 void CallRequestProcess::HoldOrDisconnectedCall(int32_t callId, int32_t slotId, int32_t videoState)
256 {
257     TELEPHONY_LOGI("Enter HoldOrDisconnectedCall");
258     std::list<int32_t> callIdList;
259     bool noOtherCall = true;
260     bool flagForConference = false;
261     GetCarrierCallList(callIdList);
262     IsExistCallOtherSlot(callIdList, slotId, noOtherCall);
263     if (noOtherCall) {
264         TELEPHONY_LOGI("no Other Slot Call");
265         sptr<CallBase> call = GetOneCallObject(callId);
266         if (call == nullptr) {
267             TELEPHONY_LOGE("call is nullptr");
268             return;
269         }
270         int32_t ret = call->AnswerCall(videoState);
271         call->SetAutoAnswerState(false);
272         if (ret != TELEPHONY_SUCCESS) {
273             return;
274         }
275         DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(call);
276         return;
277     }
278     sptr<CallBase> incomingCall = GetOneCallObject(callId);
279     int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
280     int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
281     int32_t callNum = 4;
282     for (int32_t otherCallId : callIdList) {
283         sptr<CallBase> call = GetOneCallObject(otherCallId);
284         if (call != nullptr && incomingCall != nullptr && call != incomingCall) {
285             if (HandleDsdaIncomingCall(call, activeCallNum, slotId, videoState, incomingCall)) {
286                 continue;
287             }
288             if (call->GetSlotId() != slotId) {
289                 TELEPHONY_LOGI("exist other slot call");
290                 noOtherCall = false;
291             }
292             int32_t currentCallNum = GetCurrentCallNum();
293             if (waitingCallNum > 1 || currentCallNum == callNum) {
294                 HandleCallWaitingNumTwo(incomingCall, call, slotId, activeCallNum, flagForConference);
295             } else if (waitingCallNum == 1) {
296                 HandleCallWaitingNumOne(incomingCall, call, slotId, activeCallNum, flagForConference);
297             } else {
298                 HandleCallWaitingNumZero(incomingCall, call, slotId, activeCallNum, flagForConference);
299             }
300         }
301     }
302 }
303 
HandleDsdaIncomingCall(sptr<CallBase> call,int32_t activeCallNum,int32_t slotId,int32_t videoState,sptr<CallBase> incomingCall)304 bool CallRequestProcess::HandleDsdaIncomingCall(
305     sptr<CallBase> call, int32_t activeCallNum, int32_t slotId, int32_t videoState, sptr<CallBase> incomingCall)
306 {
307     int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
308     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
309     int32_t answeredCallNum = GetCallNum(TelCallState::CALL_STATUS_ANSWERED);
310     if ((call->GetTelCallState() == TelCallState::CALL_STATUS_DISCONNECTING ||
311             call->GetTelCallState() == TelCallState::CALL_STATUS_HOLDING) &&
312         (activeCallNum == 0 && alertingCallNum == 0 && dialingCallNum == 0 && answeredCallNum == 0)) {
313         if (call->GetSlotId() != slotId) {
314             TELEPHONY_LOGI("enter HandleDsdaIncomingCall");
315             incomingCall->AnswerCall(videoState);
316             incomingCall->SetAutoAnswerState(false);
317         }
318         return true;
319     }
320     return false;
321 }
322 
IsExistCallOtherSlot(std::list<int32_t> & list,int32_t slotId,bool & noOtherCall)323 void CallRequestProcess::IsExistCallOtherSlot(std::list<int32_t> &list, int32_t slotId, bool &noOtherCall)
324 {
325     if (list.size() > 1) {
326         for (int32_t otherCallId : list) {
327             sptr<CallBase> call = GetOneCallObject(otherCallId);
328             if (call != nullptr && call->GetSlotId() != slotId) {
329                 noOtherCall = false;
330                 break;
331             }
332         }
333     }
334 }
335 
HandleCallWaitingNumTwo(sptr<CallBase> incomingCall,sptr<CallBase> call,int32_t slotId,int32_t activeCallNum,bool & flagForConference)336 void CallRequestProcess::HandleCallWaitingNumTwo(
337     sptr<CallBase> incomingCall, sptr<CallBase> call, int32_t slotId, int32_t activeCallNum, bool &flagForConference)
338 {
339     TELEPHONY_LOGI("enter HandleCallWaitingNumTwo");
340     sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
341     int32_t callNum = 3;
342     int32_t currentCallNum = GetCurrentCallNum();
343     if (currentCallNum == callNum) {
344         TELEPHONY_LOGI("enter two waitingCall process");
345         HandleCallWaitingNumOne(incomingCall, call, slotId, activeCallNum, flagForConference);
346         return;
347     }
348     if (holdCall != nullptr) {
349         TELEPHONY_LOGI("enter two holdcall hangup");
350         holdCall->HangUpCall();
351     }
352     TELEPHONY_LOGI("enter two GetTelCallState =:%{public}d", call->GetCallRunningState());
353     if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_ACTIVE && !flagForConference) {
354         if (call->GetSlotId() == slotId) {
355             TELEPHONY_LOGI("enter two activecall hold");
356             call->HoldCall();
357             flagForConference = true;
358         } else {
359             TELEPHONY_LOGI(" enter two  activecall hangup");
360             call->HangUpCall();
361         }
362     }
363 }
364 
HandleCallWaitingNumOne(sptr<CallBase> incomingCall,sptr<CallBase> call,int32_t slotId,int32_t activeCallNum,bool & flagForConference)365 void CallRequestProcess::HandleCallWaitingNumOne(
366     sptr<CallBase> incomingCall, sptr<CallBase> call, int32_t slotId, int32_t activeCallNum, bool &flagForConference)
367 {
368     TELEPHONY_LOGI("enter HandleCallWaitingNumOne");
369     sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
370     TELEPHONY_LOGI("enter one GetTelCallState =:%{public}d", call->GetTelCallState());
371     int32_t callNum = 2;
372     int32_t currentCallNum = GetCurrentCallNum();
373     if (holdCall != nullptr) {
374         HandleCallWaitingNumOneNext(incomingCall, call, holdCall, slotId, flagForConference);
375     } else if (currentCallNum == callNum) {
376         TELEPHONY_LOGI("enter two call process");
377         HandleCallWaitingNumZero(incomingCall, call, slotId, activeCallNum, flagForConference);
378     } else if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_ACTIVE && !flagForConference) {
379         if (call->GetSlotId() != slotId && g_flagForDsda == true) {
380             TELEPHONY_LOGI("enter one hold call is null active call hold for Special Dsda Scenario");
381             call->HoldCall();
382             flagForConference = true;
383             g_flagForDsda = false;
384         } else if (call->GetSlotId() != slotId) {
385             TELEPHONY_LOGI("enter one hold call is null active call hangup");
386             call->HangUpCall();
387         } else {
388             TELEPHONY_LOGI("enter one hold call is null active call hold");
389             call->HoldCall();
390             flagForConference = true;
391         }
392     }
393 }
394 
HandleCallWaitingNumOneNext(sptr<CallBase> incomingCall,sptr<CallBase> call,sptr<CallBase> holdCall,int32_t slotId,bool & flagForConference)395 void CallRequestProcess::HandleCallWaitingNumOneNext(
396     sptr<CallBase> incomingCall, sptr<CallBase> call, sptr<CallBase> holdCall, int32_t slotId, bool &flagForConference)
397 {
398     TELEPHONY_LOGI("enter HandleCallWaitingNumOneNext");
399     int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
400     int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
401     int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
402     if (call->GetTelCallState() == TelCallState ::CALL_STATUS_DIALING ||
403         call->GetTelCallState() == TelCallState ::CALL_STATUS_ALERTING) {
404         TELEPHONY_LOGI("enter one dialing call hangup");
405         call->HangUpCall();
406     } else if (activeCallNum > 0) {
407         TELEPHONY_LOGI("enter one hold call hangup");
408         holdCall->HangUpCall();
409         g_flagForDsda = true;
410     }
411     if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_ACTIVE && !flagForConference) {
412         if (CallObjectManager::IsCallExist(call->GetCallType(), TelCallState::CALL_STATUS_INCOMING) &&
413             call->GetSlotId() != slotId) {
414             TELEPHONY_LOGI("enter one active call hangup");
415             call->HangUpCall();
416         } else {
417             TELEPHONY_LOGI("enter one active call hold");
418             call->HoldCall();
419             flagForConference = true;
420         }
421     } else if (activeCallNum == 0 && incomingCall->GetAutoAnswerState() && alertingCallNum == 0 &&
422                dialingCallNum == 0) {
423         TELEPHONY_LOGI("enter one active with two incoming call");
424         incomingCall->AnswerCall(static_cast<int32_t>(incomingCall->GetVideoStateType()));
425         incomingCall->SetAutoAnswerState(false);
426     }
427 }
428 
HandleCallWaitingNumZero(sptr<CallBase> incomingCall,sptr<CallBase> call,int32_t slotId,int32_t activeCallNum,bool & flagForConference)429 void CallRequestProcess::HandleCallWaitingNumZero(
430     sptr<CallBase> incomingCall, sptr<CallBase> call, int32_t slotId, int32_t activeCallNum, bool &flagForConference)
431 {
432     TELEPHONY_LOGI("enter HandleCallWaitingNumZero");
433     sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
434     if (holdCall != nullptr) {
435         TELEPHONY_LOGI("enter zero holdcall is not null");
436         if (call->GetTelCallState() == TelCallState ::CALL_STATUS_DIALING ||
437             call->GetTelCallState() == TelCallState ::CALL_STATUS_ALERTING) {
438             TELEPHONY_LOGI("enter zero dialing call hangup");
439             call->HangUpCall();
440         } else if (activeCallNum > 0) {
441             TELEPHONY_LOGI("enter zero hold call hangup");
442             holdCall->HangUpCall();
443         }
444         if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_ACTIVE && !flagForConference) {
445             TELEPHONY_LOGI("enter active call hangup");
446             call->HoldCall();
447             flagForConference = true;
448         }
449     } else {
450         TELEPHONY_LOGI("enter zero holdcall is null");
451         if (call->GetTelCallState() == TelCallState ::CALL_STATUS_DIALING ||
452             call->GetTelCallState() == TelCallState ::CALL_STATUS_ALERTING) {
453             TELEPHONY_LOGI("enter zero dialing incoming call hangup");
454             call->HangUpCall();
455         } else if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_ACTIVE && !flagForConference) {
456             sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
457             if (imsCall != nullptr && imsCall->IsVoiceModifyToVideo()) {
458                 TELEPHONY_LOGI("hangup call during voice to video when answerCall");
459                 call->HangUpCall();
460                 return;
461             }
462             TELEPHONY_LOGI("enter zero active call hold");
463             call->HoldCall();
464             flagForConference = true;
465         } else if (incomingCall->GetAutoAnswerState() &&
466                    (call->GetTelCallState() == TelCallState ::CALL_STATUS_INCOMING ||
467                        call->GetTelCallState() == TelCallState ::CALL_STATUS_WAITING)) {
468             TELEPHONY_LOGI("enter two incoming call active");
469             incomingCall->AnswerCall(static_cast<int32_t>(incomingCall->GetVideoStateType()));
470             incomingCall->SetAutoAnswerState(false);
471         }
472     }
473 }
474 
DisconnectOtherSubIdCall(int32_t callId,int32_t slotId,int32_t videoState)475 void CallRequestProcess::DisconnectOtherSubIdCall(int32_t callId, int32_t slotId, int32_t videoState)
476 {
477     sptr<CallBase> incomingCall = GetOneCallObject(callId);
478     if (incomingCall == nullptr) {
479         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
480         return;
481     }
482     std::list<int32_t> callIdList;
483     bool noOtherCall = true;
484     GetCarrierCallList(callIdList);
485     if (callIdList.size() > 1) {
486         for (int32_t otherCallId : callIdList) {
487             sptr<CallBase> call = GetOneCallObject(otherCallId);
488             if (call != nullptr && call->GetSlotId() != slotId) {
489                 incomingCall->SetAutoAnswerState(true);
490                 TELEPHONY_LOGI("Hangup call callid:%{public}d", call->GetCallID());
491                 call->HangUpCall();
492                 noOtherCall = false;
493             }
494         }
495     }
496     if (noOtherCall == true) {
497         int32_t ret = incomingCall->AnswerCall(videoState);
498         if (ret != TELEPHONY_SUCCESS) {
499             return;
500         }
501         DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(incomingCall);
502     }
503 }
504 
DisconnectOtherCallForVideoCall(int32_t callId)505 void CallRequestProcess::DisconnectOtherCallForVideoCall(int32_t callId)
506 {
507     std::list<int32_t> callIdList;
508     GetCarrierCallList(callIdList);
509     for (int32_t otherCallId : callIdList) {
510         sptr<CallBase> call = GetOneCallObject(otherCallId);
511         if (call != nullptr && call->GetCallID() != callId &&
512             (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_ACTIVE ||
513                 call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_DIALING ||
514                 call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_HOLD)) {
515             TELEPHONY_LOGI("Hangup call callid:%{public}d", call->GetCallID());
516             call->HangUpCall();
517         }
518     }
519 }
520 
RejectRequest(int32_t callId,bool isSendSms,std::string & content)521 void CallRequestProcess::RejectRequest(int32_t callId, bool isSendSms, std::string &content)
522 {
523     sptr<CallBase> call = GetOneCallObject(callId);
524     if (call == nullptr) {
525         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
526         return;
527     }
528 
529     int32_t ret = call->RejectCall();
530     if (ret != TELEPHONY_SUCCESS) {
531         TELEPHONY_LOGE("RejectCall failed!");
532         return;
533     }
534     std::list<int32_t> callIdList;
535     GetCarrierCallList(callIdList);
536     sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
537     if (holdCall) {
538         TELEPHONY_LOGI("release the incoming/waiting call but can not recover the held call");
539         holdCall->SetCanUnHoldState(false);
540     }
541     TELEPHONY_LOGI("start to send reject message...");
542     DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallRejected(call, isSendSms, content);
543 }
544 
HangUpRequest(int32_t callId)545 void CallRequestProcess::HangUpRequest(int32_t callId)
546 {
547     sptr<CallBase> call = GetOneCallObject(callId);
548     if (call == nullptr) {
549         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
550         return;
551     }
552     int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
553     TelCallState state = call->GetTelCallState();
554     TelConferenceState confState = call->GetTelConferenceState();
555     if ((((state == TelCallState::CALL_STATUS_ACTIVE) &&
556         (CallObjectManager::IsCallExist(call->GetCallType(), TelCallState::CALL_STATUS_HOLDING))) ||
557         (confState == TelConferenceState::TEL_CONFERENCE_ACTIVE)) && waitingCallNum == 0) {
558         if (HangUpForDsdaRequest(call)) {
559             TELEPHONY_LOGI("hangup for dsda Request success");
560         } else {
561             TELEPHONY_LOGI("release the active call and recover the held call");
562             call->SetPolicyFlag(PolicyFlag::POLICY_FLAG_HANG_UP_ACTIVE);
563         }
564     } else if (confState == TelConferenceState::TEL_CONFERENCE_HOLDING && waitingCallNum == 0) {
565         TELEPHONY_LOGI("release the held call and the wait call");
566         call->SetPolicyFlag(PolicyFlag::POLICY_FLAG_HANG_UP_HOLD_WAIT);
567     } else if (((confState == TelConferenceState::TEL_CONFERENCE_HOLDING) ||
568         (confState == TelConferenceState::TEL_CONFERENCE_ACTIVE)) && waitingCallNum != 0) {
569         TELEPHONY_LOGI("conference call and holding state, hangup conference call");
570         std::vector<std::u16string> callIdList;
571         call->GetSubCallIdList(callIdList);
572         for (auto it = callIdList.begin(); it != callIdList.end(); ++it) {
573             int32_t callId = -1;
574             StrToInt(Str16ToStr8(*it), callId);
575             KickOutFromConferenceRequest(callId);
576         }
577     }
578     call->HangUpCall();
579 }
580 
HangUpForDsdaRequest(sptr<CallBase> call)581 bool CallRequestProcess::HangUpForDsdaRequest(sptr<CallBase> call)
582 {
583     int32_t dsdsMode = DSDS_MODE_V2;
584     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
585     bool noOtherCall = true;
586     std::list<int32_t> allCallIdList;
587     GetCarrierCallList(allCallIdList);
588     IsExistCallOtherSlot(allCallIdList, call->GetSlotId(), noOtherCall);
589     if ((dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
590             dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) &&
591         (!noOtherCall)) {
592         TELEPHONY_LOGI("release the active call but not recover the held call for dsda");
593         std::vector<std::u16string> callIdList;
594         call->GetSubCallIdList(callIdList);
595         for (auto it = callIdList.begin(); it != callIdList.end(); ++it) {
596             int32_t callId = -1;
597             StrToInt(Str16ToStr8(*it), callId);
598             KickOutFromConferenceRequest(callId);
599         }
600         return true;
601     }
602     return false;
603 }
604 
HoldRequest(int32_t callId)605 void CallRequestProcess::HoldRequest(int32_t callId)
606 {
607     sptr<CallBase> call = GetOneCallObject(callId);
608     if (call == nullptr) {
609         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
610         return;
611     }
612     call->HoldCall();
613 }
614 
UnHoldRequest(int32_t callId)615 void CallRequestProcess::UnHoldRequest(int32_t callId)
616 {
617     TELEPHONY_LOGI("Enter UnHoldRequest");
618     sptr<CallBase> call = GetOneCallObject(callId);
619     if (call == nullptr) {
620         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
621         return;
622     }
623     call->SetCanUnHoldState(true);
624     bool noOtherCall = true;
625     std::list<int32_t> callIdList;
626     GetCarrierCallList(callIdList);
627     IsExistCallOtherSlot(callIdList, call->GetSlotId(), noOtherCall);
628     for (int32_t otherCallId : callIdList) {
629         sptr<CallBase> otherCall = GetOneCallObject(otherCallId);
630         if (otherCall == nullptr) {
631             TELEPHONY_LOGE("otherCall is nullptr");
632             return;
633         }
634         TelCallState state = otherCall->GetTelCallState();
635         TelConferenceState confState = otherCall->GetTelConferenceState();
636         int32_t conferenceId = ERR_ID;
637         otherCall->GetMainCallId(conferenceId);
638         TELEPHONY_LOGI("otherCall->GetTelCallState(): %{public}d ,callid:%{public}d", state, otherCallId);
639         if (IsDsdsMode5() && !noOtherCall && state == TelCallState::CALL_STATUS_ACTIVE &&
640             ((confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == otherCallId) ||
641                 confState == TelConferenceState::TEL_CONFERENCE_IDLE)) {
642             if (otherCall->GetCanSwitchCallState()) {
643                 TELEPHONY_LOGI("Hold other call in other slotId for switch Dsda call");
644                 otherCall->SetCanSwitchCallState(false);
645                 otherCall->HoldCall();
646                 return;
647             } else {
648                 TELEPHONY_LOGI("Currently can not swap this call");
649                 return;
650             }
651         }
652     }
653     if (noOtherCall) {
654         call->UnHoldCall();
655     }
656 }
657 
SwitchRequest(int32_t callId)658 void CallRequestProcess::SwitchRequest(int32_t callId)
659 {
660     sptr<CallBase> call = GetOneCallObject(callId);
661     if (call == nullptr) {
662         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
663         return;
664     }
665     call->SwitchCall();
666 }
667 
CombineConferenceRequest(int32_t mainCallId)668 void CallRequestProcess::CombineConferenceRequest(int32_t mainCallId)
669 {
670     sptr<CallBase> call = GetOneCallObject(mainCallId);
671     if (call == nullptr) {
672         TELEPHONY_LOGE("the call object is nullptr, mainCallId:%{public}d", mainCallId);
673         return;
674     }
675     int32_t ret = call->CombineConference();
676     if (ret != TELEPHONY_SUCCESS) {
677         TELEPHONY_LOGE("CombineConference failed");
678     }
679 }
680 
SeparateConferenceRequest(int32_t callId)681 void CallRequestProcess::SeparateConferenceRequest(int32_t callId)
682 {
683     sptr<CallBase> call = GetOneCallObject(callId);
684     if (call == nullptr) {
685         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
686         return;
687     }
688     int32_t ret = call->SeparateConference();
689     if (ret != TELEPHONY_SUCCESS) {
690         TELEPHONY_LOGE("SeparateConference failed");
691     }
692 }
693 
KickOutFromConferenceRequest(int32_t callId)694 void CallRequestProcess::KickOutFromConferenceRequest(int32_t callId)
695 {
696     sptr<CallBase> call = GetOneCallObject(callId);
697     if (call == nullptr) {
698         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
699         return;
700     }
701     int32_t ret = call->KickOutFromConference();
702     if (ret != TELEPHONY_SUCCESS) {
703         TELEPHONY_LOGE("KickOutFormConference failed");
704     }
705 }
706 
StartRttRequest(int32_t callId,std::u16string & msg)707 void CallRequestProcess::StartRttRequest(int32_t callId, std::u16string &msg)
708 {
709     sptr<CallBase> call = GetOneCallObject(callId);
710     if (call == nullptr) {
711         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
712         return;
713     }
714     if (call->GetCallType() != CallType::TYPE_IMS) {
715         TELEPHONY_LOGE("Unsupported Network type, callId:%{public}d", callId);
716         return;
717     } else {
718         sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
719         imsCall->StartRtt(msg);
720     }
721 }
722 
StopRttRequest(int32_t callId)723 void CallRequestProcess::StopRttRequest(int32_t callId)
724 {
725     sptr<CallBase> call = GetOneCallObject(callId);
726     if (call == nullptr) {
727         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
728         return;
729     }
730     if (call->GetCallType() != CallType::TYPE_IMS) {
731         TELEPHONY_LOGE("Unsupported Network type, callId:%{public}d", callId);
732         return;
733     } else {
734         sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
735         imsCall->StopRtt();
736     }
737 }
738 
JoinConference(int32_t callId,std::vector<std::string> & numberList)739 void CallRequestProcess::JoinConference(int32_t callId, std::vector<std::string> &numberList)
740 {
741     sptr<CallBase> call = GetOneCallObject(callId);
742     if (call == nullptr) {
743         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
744         return;
745     }
746     int32_t ret =
747         DelayedSingleton<CellularCallConnection>::GetInstance()->InviteToConference(numberList, call->GetSlotId());
748     if (ret != TELEPHONY_SUCCESS) {
749         TELEPHONY_LOGE("Invite to conference failed!");
750         return;
751     }
752 }
753 
UpdateCallReportInfo(const DialParaInfo & info,TelCallState state)754 int32_t CallRequestProcess::UpdateCallReportInfo(const DialParaInfo &info, TelCallState state)
755 {
756     CallDetailInfo callDetatilInfo;
757     if (memset_s(&callDetatilInfo, sizeof(CallDetailInfo), 0, sizeof(CallDetailInfo)) != EOK) {
758         TELEPHONY_LOGE("memset_s callDetatilInfo fail");
759         return TELEPHONY_ERR_MEMSET_FAIL;
760     }
761     callDetatilInfo.callType = info.callType;
762     callDetatilInfo.accountId = info.accountId;
763     callDetatilInfo.index = info.index;
764     callDetatilInfo.state = state;
765     callDetatilInfo.callMode = info.videoState;
766     callDetatilInfo.originalCallType = info.originalCallType;
767     callDetatilInfo.voiceDomain = static_cast<int32_t>(info.callType);
768     if (info.number.length() > kMaxNumberLen) {
769         TELEPHONY_LOGE("numbser length out of range");
770         return CALL_ERR_NUMBER_OUT_OF_RANGE;
771     }
772     if (memcpy_s(&callDetatilInfo.phoneNum, kMaxNumberLen, info.number.c_str(), info.number.length()) != EOK) {
773         TELEPHONY_LOGE("memcpy_s number failed!");
774         return TELEPHONY_ERR_MEMCPY_FAIL;
775     }
776     return DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallReportInfo(callDetatilInfo);
777 }
778 
HandleDialFail()779 int32_t CallRequestProcess::HandleDialFail()
780 {
781     std::unique_lock<std::mutex> lock(mutex_);
782     while (!isFirstDialCallAdded_) {
783         if (cv_.wait_for(lock, std::chrono::seconds(WAIT_TIME_ONE_SECOND)) == std::cv_status::timeout) {
784             TELEPHONY_LOGE("CarrierDialProcess call is not added");
785             return CALL_ERR_DIAL_FAILED;
786         }
787     }
788     sptr<CallBase> call = nullptr;
789     call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_CREATE);
790     if (call != nullptr) {
791         return DealFailDial(call);
792     }
793     call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
794     if (call != nullptr) {
795         return DealFailDial(call);
796     }
797     call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
798     if (call != nullptr) {
799         return DealFailDial(call);
800     }
801     TELEPHONY_LOGE("can not find connect call or dialing call");
802     return CALL_ERR_CALL_STATE;
803 }
804 
CarrierDialProcess(DialParaInfo & info)805 int32_t CallRequestProcess::CarrierDialProcess(DialParaInfo &info)
806 {
807     auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
808     if (callRequestEventHandler->IsDialingCallProcessing()) {
809         return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
810     }
811     callRequestEventHandler->RestoreDialingFlag(true);
812     callRequestEventHandler->SetDialingCallProcessing();
813     std::string newPhoneNum =
814         DelayedSingleton<CallNumberUtils>::GetInstance()->RemoveSeparatorsPhoneNumber(info.number);
815     int32_t ret = HandleDialingInfo(newPhoneNum, info);
816     if (ret != TELEPHONY_SUCCESS) {
817         TELEPHONY_LOGE("HandleDialingInfo failed!");
818         callRequestEventHandler->RestoreDialingFlag(false);
819         callRequestEventHandler->RemoveEventHandlerTask();
820         needWaitHold_ = false;
821         return ret;
822     }
823     bool isMMiCode = DelayedSingleton<CallNumberUtils>::GetInstance()->IsMMICode(newPhoneNum);
824     if (!isMMiCode) {
825         isFirstDialCallAdded_ = false;
826         info.number = newPhoneNum;
827         ret = UpdateCallReportInfo(info, TelCallState::CALL_STATUS_DIALING);
828         if (ret != TELEPHONY_SUCCESS) {
829             TELEPHONY_LOGE("UpdateCallReportInfo failed!");
830             needWaitHold_ = false;
831             return ret;
832         }
833     } else {
834         callRequestEventHandler->RestoreDialingFlag(false);
835         callRequestEventHandler->RemoveEventHandlerTask();
836     }
837     CellularCallInfo callInfo;
838     ret = PackCellularCallInfo(info, callInfo);
839     if (ret != TELEPHONY_SUCCESS) {
840         TELEPHONY_LOGW("PackCellularCallInfo failed!");
841         CallManagerHisysevent::WriteDialCallFaultEvent(info.accountId, static_cast<int32_t>(info.callType),
842             static_cast<int32_t>(info.videoState), ret, "Carrier type PackCellularCallInfo failed");
843         needWaitHold_ = false;
844         return ret;
845     }
846     if (needWaitHold_ && !isMMiCode) {
847         TELEPHONY_LOGI("waitting for call hold");
848         dialCallInfo_ = callInfo;
849         return ret;
850     }
851     ret = HandleStartDial(isMMiCode, callInfo);
852     return ret;
853 }
854 
HandleDialingInfo(std::string newPhoneNum,DialParaInfo & info)855 int32_t CallRequestProcess::HandleDialingInfo(std::string newPhoneNum, DialParaInfo &info)
856 {
857     bool isEcc = false;
858     int32_t ret = HandleEccCallForDsda(newPhoneNum, info, isEcc);
859     if (ret != TELEPHONY_SUCCESS) {
860         return ret;
861     }
862     if (!isEcc) {
863         bool canDial = true;
864         IsNewCallAllowedCreate(canDial);
865         if (!canDial) {
866             return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
867         }
868         if (IsDsdsMode5()) {
869             ret = IsDialCallForDsda(info);
870             if (ret != TELEPHONY_SUCCESS) {
871                 TELEPHONY_LOGE("IsDialCallForDsda failed!");
872                 return ret;
873             }
874         }
875     }
876     return TELEPHONY_SUCCESS;
877 }
878 
HandleStartDial(bool isMMiCode,CellularCallInfo callInfo)879 int32_t CallRequestProcess::HandleStartDial(bool isMMiCode, CellularCallInfo callInfo)
880 {
881     int32_t ret = DelayedSingleton<CellularCallConnection>::GetInstance()->Dial(callInfo);
882     if (ret != TELEPHONY_SUCCESS) {
883         TELEPHONY_LOGE("Dial failed!");
884         if (isMMiCode) {
885             return ret;
886         }
887         int32_t handleRet = HandleDialFail();
888         if (handleRet != TELEPHONY_SUCCESS) {
889             TELEPHONY_LOGE("HandleDialFail failed!");
890             return handleRet;
891         }
892         return ret;
893     }
894     return TELEPHONY_SUCCESS;
895 }
896 
IsDialCallForDsda(DialParaInfo & info)897 int32_t CallRequestProcess::IsDialCallForDsda(DialParaInfo &info)
898 {
899     sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
900     TELEPHONY_LOGI("Is dsdsmode5 dial call info.accountId = %{public}d", info.accountId);
901     if (activeCall != nullptr && activeCall->GetSlotId() != info.accountId) {
902         int32_t ret = activeCall->HoldCall();
903         if (ret == TELEPHONY_SUCCESS) {
904             needWaitHold_ = true;
905         }
906         return ret;
907     }
908     return TELEPHONY_SUCCESS;
909 }
910 
HandleEccCallForDsda(std::string newPhoneNum,DialParaInfo & info,bool & isEcc)911 int32_t CallRequestProcess::HandleEccCallForDsda(std::string newPhoneNum, DialParaInfo &info, bool &isEcc)
912 {
913     int32_t ret =
914         DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(newPhoneNum, info.accountId, isEcc);
915     TELEPHONY_LOGE("CheckNumberIsEmergency ret is %{public}d, isEcc: %{public}d", ret, isEcc);
916     if (isEcc) {
917         return EccDialPolicy();
918     }
919     return TELEPHONY_SUCCESS;
920 }
921 
VoiceMailDialProcess(DialParaInfo & info)922 int32_t CallRequestProcess::VoiceMailDialProcess(DialParaInfo &info)
923 {
924     return CarrierDialProcess(info);
925 }
926 
OttDialProcess(DialParaInfo & info)927 int32_t CallRequestProcess::OttDialProcess(DialParaInfo &info)
928 {
929     AppExecFwk::PacMap callInfo;
930     callInfo.PutStringValue("phoneNumber", info.number);
931     callInfo.PutStringValue("bundleName", info.bundleName);
932     callInfo.PutIntValue("videoState", static_cast<int32_t>(info.videoState));
933     int32_t ret = DelayedSingleton<CallAbilityReportProxy>::GetInstance()->OttCallRequest(
934         OttCallRequestId::OTT_REQUEST_DIAL, callInfo);
935     if (ret != TELEPHONY_SUCCESS) {
936         TELEPHONY_LOGE("OTT call Dial failed!");
937         return ret;
938     }
939     return TELEPHONY_SUCCESS;
940 }
941 
PackCellularCallInfo(DialParaInfo & info,CellularCallInfo & callInfo)942 int32_t CallRequestProcess::PackCellularCallInfo(DialParaInfo &info, CellularCallInfo &callInfo)
943 {
944     callInfo.callId = info.callId;
945     callInfo.accountId = info.accountId;
946     callInfo.callType = info.callType;
947     callInfo.videoState = static_cast<int32_t>(info.videoState);
948     callInfo.index = info.index;
949     callInfo.slotId = info.accountId;
950     if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
951         TELEPHONY_LOGW("memset_s failed!");
952         return TELEPHONY_ERR_MEMSET_FAIL;
953     }
954     if (info.number.length() > static_cast<size_t>(kMaxNumberLen)) {
955         TELEPHONY_LOGE("Number out of limit!");
956         return CALL_ERR_NUMBER_OUT_OF_RANGE;
957     }
958     if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, info.number.c_str(), info.number.length()) != EOK) {
959         TELEPHONY_LOGE("memcpy_s failed!");
960         return TELEPHONY_ERR_MEMCPY_FAIL;
961     }
962     return TELEPHONY_SUCCESS;
963 }
964 
IsFdnNumber(std::vector<std::u16string> fdnNumberList,std::string phoneNumber)965 bool CallRequestProcess::IsFdnNumber(std::vector<std::u16string> fdnNumberList, std::string phoneNumber)
966 {
967     char number[kMaxNumberLen + 1] = { 0 };
968     int32_t j = 0;
969     for (int32_t i = 0; i < static_cast<int32_t>(phoneNumber.length()); i++) {
970         if (i >= kMaxNumberLen) {
971             break;
972         }
973         if (*(phoneNumber.c_str() + i) != ' ') {
974             number[j++] = *(phoneNumber.c_str() + i);
975         }
976     }
977     for (std::vector<std::u16string>::iterator it = fdnNumberList.begin(); it != fdnNumberList.end(); ++it) {
978         if (strstr(number, Str16ToStr8(*it).c_str()) != nullptr) {
979             TELEPHONY_LOGI("you are allowed to dial!");
980             return true;
981         }
982     }
983     TELEPHONY_LOGW("There is no fixed number.");
984     return false;
985 }
986 
EccDialPolicy()987 int32_t CallRequestProcess::EccDialPolicy()
988 {
989     std::size_t callNum = 0;
990     std::list<int32_t> callIdList;
991     std::list<sptr<CallBase>> hangupList;
992     std::list<sptr<CallBase>> rejectList;
993 
994     GetCarrierCallList(callIdList);
995     callNum = callIdList.size();
996     for (int32_t callId : callIdList) {
997         sptr<CallBase> call = GetOneCallObject(callId);
998         if (call == nullptr) {
999             continue;
1000         }
1001         CallRunningState crState = call->GetCallRunningState();
1002         if (call->GetCallType() == CallType::TYPE_SATELLITE) {
1003             hangupList.emplace_back(call);
1004         } else if (crState == CallRunningState::CALL_RUNNING_STATE_CREATE ||
1005             crState == CallRunningState::CALL_RUNNING_STATE_CONNECTING ||
1006             crState == CallRunningState::CALL_RUNNING_STATE_DIALING) {
1007             if (call->GetEmergencyState()) {
1008                 hangupList.clear();
1009                 rejectList.clear();
1010                 TELEPHONY_LOGE("already has ecc call dailing!");
1011                 return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
1012             }
1013             hangupList.emplace_back(call);
1014         } else if (crState == CallRunningState::CALL_RUNNING_STATE_RINGING) {
1015             rejectList.emplace_back(call);
1016         } else if (crState == CallRunningState::CALL_RUNNING_STATE_ACTIVE) {
1017             if (callNum > 1) {
1018                 hangupList.emplace_back(call);
1019             }
1020         }
1021     }
1022     for (sptr<CallBase> call : hangupList) {
1023         int32_t callId = call->GetCallID();
1024         CallRunningState crState = call->GetCallRunningState();
1025         TELEPHONY_LOGE("HangUpCall call[id:%{public}d crState:%{public}d]", callId, crState);
1026         call->HangUpCall();
1027     }
1028     for (sptr<CallBase> call : rejectList) {
1029         int32_t callId = call->GetCallID();
1030         CallRunningState crState = call->GetCallRunningState();
1031         TELEPHONY_LOGE("RejectCall call[id:%{public}d crState:%{public}d]", callId, crState);
1032         call->RejectCall();
1033     }
1034     hangupList.clear();
1035     rejectList.clear();
1036     return TELEPHONY_SUCCESS;
1037 }
1038 } // namespace Telephony
1039 } // namespace OHOS
1040