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_policy.h"
17 
18 #include "call_dialog.h"
19 #include "call_data_base_helper.h"
20 #include "call_manager_errors.h"
21 #include "call_number_utils.h"
22 #include "core_service_client.h"
23 #include "ims_conference.h"
24 #include "telephony_log_wrapper.h"
25 #include "call_superprivacy_control_manager.h"
26 
27 namespace OHOS {
28 namespace Telephony {
CallPolicy()29 CallPolicy::CallPolicy() {}
30 
~CallPolicy()31 CallPolicy::~CallPolicy() {}
32 
DialPolicy(std::u16string & number,AppExecFwk::PacMap & extras,bool isEcc)33 int32_t CallPolicy::DialPolicy(std::u16string &number, AppExecFwk::PacMap &extras, bool isEcc)
34 {
35     DialType dialType = (DialType)extras.GetIntValue("dialType");
36     if (dialType != DialType::DIAL_CARRIER_TYPE && dialType != DialType::DIAL_VOICE_MAIL_TYPE &&
37         dialType != DialType::DIAL_OTT_TYPE) {
38         TELEPHONY_LOGE("dial type invalid!");
39         return TELEPHONY_ERR_ARGUMENT_INVALID;
40     }
41     int32_t accountId = extras.GetIntValue("accountId");
42     if (dialType == DialType::DIAL_CARRIER_TYPE) {
43         if (!DelayedSingleton<CallNumberUtils>::GetInstance()->SelectAccountId(accountId, extras)) {
44             extras.PutIntValue("accountId", 0);
45             TELEPHONY_LOGE("invalid accountId, select accountId to 0");
46         }
47     }
48     CallType callType = (CallType)extras.GetIntValue("callType");
49     if (IsValidCallType(callType) != TELEPHONY_SUCCESS) {
50         return TELEPHONY_ERR_ARGUMENT_INVALID;
51     }
52     DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
53     if ((dialScene != DialScene::CALL_NORMAL && dialScene != DialScene::CALL_PRIVILEGED &&
54             dialScene != DialScene::CALL_EMERGENCY)) {
55         TELEPHONY_LOGE("invalid dial scene!");
56         return TELEPHONY_ERR_ARGUMENT_INVALID;
57     }
58     VideoStateType videoState = (VideoStateType)extras.GetIntValue("videoState");
59     if (videoState != VideoStateType::TYPE_VOICE && videoState != VideoStateType::TYPE_VIDEO) {
60         TELEPHONY_LOGE("invalid video state!");
61         return TELEPHONY_ERR_ARGUMENT_INVALID;
62     }
63     if (!isEcc) {
64         if (IsVoiceCallValid(videoState) != TELEPHONY_SUCCESS) {
65             return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
66         }
67         if (HasNewCall() != TELEPHONY_SUCCESS) {
68             return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
69         }
70         bool hasEccCall = false;
71         if (HasEmergencyCall(hasEccCall) == TELEPHONY_ERR_SUCCESS && hasEccCall) {
72             TELEPHONY_LOGE("during emergency call, calling is prohibited");
73             return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
74         }
75     }
76     int32_t slotId = extras.GetIntValue("accountId");
77     return SuperPrivacyMode(number, extras, isEcc);
78 }
79 
SuperPrivacyMode(std::u16string & number,AppExecFwk::PacMap & extras,bool isEcc)80 int32_t CallPolicy::SuperPrivacyMode(std::u16string &number, AppExecFwk::PacMap &extras, bool isEcc)
81 {
82     int32_t accountId = extras.GetIntValue("accountId");
83     CallType callType = (CallType)extras.GetIntValue("callType");
84     int32_t slotId = extras.GetIntValue("accountId");
85     if (isEcc) {
86         return HasNormalCall(isEcc, slotId, callType);
87     }
88     DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
89     if (dialScene == DialScene::CALL_EMERGENCY) {
90         return HasNormalCall(isEcc, slotId, callType);
91     }
92     bool currentIsSuperPrivacyMode = DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->
93         GetCurrentIsSuperPrivacyMode();
94     TELEPHONY_LOGI("call policy currentIsSuperPrivacyMode:%{public}d", currentIsSuperPrivacyMode);
95     if (currentIsSuperPrivacyMode) {
96         int32_t videoState = extras.GetIntValue("videoState");
97         int32_t dialType = extras.GetIntValue("dialType");
98         int32_t dialScene = extras.GetIntValue("dialScene");
99         int32_t spCallType = extras.GetIntValue("callType");
100         DelayedSingleton<CallDialog>::GetInstance()->DialogConnectPrivpacyModeExtension("SUPER_PRIVACY_MODE",
101             number, accountId, videoState, dialType, dialScene, spCallType, true);
102         return CALL_ERR_DIAL_FAILED;
103     }
104     return HasNormalCall(isEcc, slotId, callType);
105 }
HasNormalCall(bool isEcc,int32_t slotId,CallType callType)106 int32_t CallPolicy::HasNormalCall(bool isEcc, int32_t slotId, CallType callType)
107 {
108     if (isEcc || callType == CallType::TYPE_SATELLITE) {
109         return TELEPHONY_SUCCESS;
110     }
111     bool hasSimCard = false;
112     DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
113     if (!hasSimCard) {
114         TELEPHONY_LOGE("Call failed due to no sim card");
115         DelayedSingleton<CallDialog>::GetInstance()->DialogConnectExtension("CALL_FAILED_NO_SIM_CARD");
116         return TELEPHONY_ERR_NO_SIM_CARD;
117     }
118     bool isAirplaneModeOn = false;
119     int32_t ret = GetAirplaneMode(isAirplaneModeOn);
120     if (ret == TELEPHONY_SUCCESS && isAirplaneModeOn) {
121         TELEPHONY_LOGE("Call failed due to isAirplaneModeOn is true");
122         DelayedSingleton<CallDialog>::GetInstance()->DialogConnectExtension("CALL_FAILED_IN_AIRPLANE_MODE");
123         return TELEPHONY_ERR_AIRPLANE_MODE_ON;
124     }
125     sptr<NetworkState> networkState = nullptr;
126     RegServiceState regStatus = RegServiceState::REG_STATE_UNKNOWN;
127     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetNetworkState(slotId, networkState);
128     if (networkState != nullptr) {
129         regStatus = networkState->GetRegStatus();
130     }
131     if (regStatus != RegServiceState::REG_STATE_IN_SERVICE) {
132         TELEPHONY_LOGE("Call failed due to no service");
133         DelayedSingleton<CallDialog>::GetInstance()->DialogConnectExtension("CALL_FAILED_NO_SERVICE");
134         return TELEPHONY_ERR_NETWORK_NOT_IN_SERVICE;
135     }
136     ImsRegInfo info;
137     DelayedRefSingleton<CoreServiceClient>::GetInstance().GetImsRegStatus(slotId, ImsServiceType::TYPE_VOICE, info);
138     bool isImsRegistered = info.imsRegState == ImsRegState::IMS_REGISTERED;
139     bool isCTSimCard = false;
140     bool isRoaming = networkState->IsRoaming();
141     DelayedRefSingleton<CoreServiceClient>::GetInstance().IsCTSimCard(slotId, isCTSimCard);
142     if (isCTSimCard && !isRoaming && !isImsRegistered) {
143         TELEPHONY_LOGE("Call failed due to CT card IMS is UNREGISTERED");
144         DelayedSingleton<CallDialog>::GetInstance()->DialogConnectExtension("CALL_FAILED_CTCARD_NO_IMS", slotId);
145         return CALL_ERR_DIAL_FAILED;
146     }
147     return TELEPHONY_SUCCESS;
148 }
149 
GetAirplaneMode(bool & isAirplaneModeOn)150 int32_t CallPolicy::GetAirplaneMode(bool &isAirplaneModeOn)
151 {
152     std::shared_ptr<CallDataBaseHelper> callDataPtr = DelayedSingleton<CallDataBaseHelper>::GetInstance();
153     if (callDataPtr == nullptr) {
154         TELEPHONY_LOGE("callDataPtr is nullptr");
155         return TELEPHONY_ERR_LOCAL_PTR_NULL;
156     }
157     return callDataPtr->GetAirplaneMode(isAirplaneModeOn);
158 }
159 
IsVoiceCallValid(VideoStateType videoState)160 int32_t CallPolicy::IsVoiceCallValid(VideoStateType videoState)
161 {
162     if (videoState == VideoStateType::TYPE_VOICE) {
163         sptr<CallBase> ringCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
164         if (ringCall != nullptr && ringCall->GetVideoStateType() == VideoStateType::TYPE_VOICE &&
165             ringCall->GetCallType() != CallType::TYPE_VOIP) {
166             TELEPHONY_LOGE("already has new call ringing!");
167             return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
168         }
169     }
170     return TELEPHONY_SUCCESS;
171 }
172 
IsValidCallType(CallType callType)173 int32_t CallPolicy::IsValidCallType(CallType callType)
174 {
175     if (callType != CallType::TYPE_CS && callType != CallType::TYPE_IMS && callType != CallType::TYPE_OTT &&
176         callType != CallType::TYPE_SATELLITE) {
177         TELEPHONY_LOGE("invalid call type!");
178         return CALL_ERR_UNKNOW_CALL_TYPE;
179     }
180     return TELEPHONY_SUCCESS;
181 }
182 
CanDialMulityCall(AppExecFwk::PacMap & extras,bool isEcc)183 int32_t CallPolicy::CanDialMulityCall(AppExecFwk::PacMap &extras, bool isEcc)
184 {
185     VideoStateType videoState = (VideoStateType)extras.GetIntValue("videoState");
186     if (videoState == VideoStateType::TYPE_VIDEO && HasCellularCallExist()) {
187         TELEPHONY_LOGE("can not dial video call when any call exist!");
188         return CALL_ERR_DIAL_IS_BUSY;
189     }
190     if (!isEcc && videoState == VideoStateType::TYPE_VOICE && HasVideoCall()) {
191         TELEPHONY_LOGE("can not dial video call when any call exist!");
192         return CALL_ERR_DIAL_IS_BUSY;
193     }
194     return TELEPHONY_SUCCESS;
195 }
196 
IsSupportVideoCall(AppExecFwk::PacMap & extras)197 bool CallPolicy::IsSupportVideoCall(AppExecFwk::PacMap &extras)
198 {
199     bool isSupportVideoCall = true;
200 #ifdef ABILITY_CONFIG_SUPPORT
201     isSupportVideoCall = GetCarrierConfig(ITEM_VIDEO_CALL);
202 #endif
203     DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
204     if (dialScene != DialScene::CALL_NORMAL) {
205         TELEPHONY_LOGW("emergency call not support video upgrade");
206         isSupportVideoCall = false;
207     }
208     return isSupportVideoCall;
209 }
210 
AnswerCallPolicy(int32_t callId,int32_t videoState)211 int32_t CallPolicy::AnswerCallPolicy(int32_t callId, int32_t videoState)
212 {
213     if (videoState != static_cast<int32_t>(VideoStateType::TYPE_VOICE) &&
214         videoState != static_cast<int32_t>(VideoStateType::TYPE_VIDEO)) {
215         TELEPHONY_LOGE("videoState is invalid!");
216         return TELEPHONY_ERR_ARGUMENT_INVALID;
217     }
218     if (!IsCallExist(callId)) {
219         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
220         return TELEPHONY_ERR_ARGUMENT_INVALID;
221     }
222     TelCallState state = GetCallState(callId);
223     if (state != TelCallState::CALL_STATUS_INCOMING && state != TelCallState::CALL_STATUS_WAITING) {
224         TELEPHONY_LOGE("current call state is:%{public}d, accept call not allowed", state);
225         return CALL_ERR_ILLEGAL_CALL_OPERATION;
226     }
227     return TELEPHONY_SUCCESS;
228 }
229 
RejectCallPolicy(int32_t callId)230 int32_t CallPolicy::RejectCallPolicy(int32_t callId)
231 {
232     if (!IsCallExist(callId)) {
233         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
234         return TELEPHONY_ERR_ARGUMENT_INVALID;
235     }
236     TelCallState state = GetCallState(callId);
237     if (state != TelCallState::CALL_STATUS_INCOMING && state != TelCallState::CALL_STATUS_WAITING) {
238         TELEPHONY_LOGE("current call state is:%{public}d, reject call not allowed", state);
239         return CALL_ERR_ILLEGAL_CALL_OPERATION;
240     }
241     return TELEPHONY_SUCCESS;
242 }
243 
HoldCallPolicy(int32_t callId)244 int32_t CallPolicy::HoldCallPolicy(int32_t callId)
245 {
246     sptr<CallBase> call = GetOneCallObject(callId);
247     if (call == nullptr) {
248         TELEPHONY_LOGE("GetOneCallObject failed, this callId is invalid! callId:%{public}d", callId);
249         return TELEPHONY_ERR_ARGUMENT_INVALID;
250     }
251     if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_ACTIVE) {
252         TELEPHONY_LOGE("this call is not activated! callId:%{public}d", callId);
253         return CALL_ERR_CALL_IS_NOT_ACTIVATED;
254     }
255     return TELEPHONY_SUCCESS;
256 }
257 
UnHoldCallPolicy(int32_t callId)258 int32_t CallPolicy::UnHoldCallPolicy(int32_t callId)
259 {
260     sptr<CallBase> call = GetOneCallObject(callId);
261     if (call == nullptr) {
262         TELEPHONY_LOGE("GetOneCallObject failed, this callId is invalid! callId:%{public}d", callId);
263         return TELEPHONY_ERR_ARGUMENT_INVALID;
264     }
265     if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_HOLD) {
266         TELEPHONY_LOGE("this call is not on holding state! callId:%{public}d", callId);
267         return CALL_ERR_CALL_IS_NOT_ON_HOLDING;
268     }
269     return TELEPHONY_SUCCESS;
270 }
271 
HangUpPolicy(int32_t callId)272 int32_t CallPolicy::HangUpPolicy(int32_t callId)
273 {
274     if (!IsCallExist(callId)) {
275         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
276         return TELEPHONY_ERR_ARGUMENT_INVALID;
277     }
278     TelCallState state = GetCallState(callId);
279     if (state == TelCallState::CALL_STATUS_IDLE || state == TelCallState::CALL_STATUS_DISCONNECTING ||
280         state == TelCallState::CALL_STATUS_DISCONNECTED) {
281         TELEPHONY_LOGE("current call state is:%{public}d, hang up call not allowed", state);
282         return CALL_ERR_ILLEGAL_CALL_OPERATION;
283     }
284     return TELEPHONY_SUCCESS;
285 }
286 
SwitchCallPolicy(int32_t callId)287 int32_t CallPolicy::SwitchCallPolicy(int32_t callId)
288 {
289     std::list<int32_t> callIdList;
290     if (!IsCallExist(callId)) {
291         TELEPHONY_LOGE("callId is invalid");
292         return TELEPHONY_ERR_ARGUMENT_INVALID;
293     }
294     GetCarrierCallList(callIdList);
295     if (callIdList.size() < onlyTwoCall_) {
296         callIdList.clear();
297         return CALL_ERR_PHONE_CALLS_TOO_FEW;
298     }
299     if (GetCallState(callId) != TelCallState::CALL_STATUS_HOLDING ||
300         IsCallExist(TelCallState::CALL_STATUS_DIALING) || IsCallExist(TelCallState::CALL_STATUS_ALERTING)) {
301         TELEPHONY_LOGE("the call is not on hold, callId:%{public}d", callId);
302         return CALL_ERR_ILLEGAL_CALL_OPERATION;
303     }
304     callIdList.clear();
305     return TELEPHONY_SUCCESS;
306 }
307 
VideoCallPolicy(int32_t callId)308 int32_t CallPolicy::VideoCallPolicy(int32_t callId)
309 {
310     TELEPHONY_LOGI("callid %{public}d", callId);
311     sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
312     if (callPtr == nullptr) {
313         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
314         return TELEPHONY_ERR_ARGUMENT_INVALID;
315     }
316     return TELEPHONY_SUCCESS;
317 }
318 
StartRttPolicy(int32_t callId)319 int32_t CallPolicy::StartRttPolicy(int32_t callId)
320 {
321     sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
322     if (callPtr == nullptr) {
323         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
324         return CALL_ERR_INVALID_CALLID;
325     }
326     if (callPtr->GetCallType() != CallType::TYPE_IMS) {
327         TELEPHONY_LOGE("calltype is illegal, calltype:%{public}d", callPtr->GetCallType());
328         return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
329     }
330     TelCallState state = GetCallState(callId);
331     if (state != TelCallState::CALL_STATUS_ACTIVE) {
332         TELEPHONY_LOGE("current call state is:%{public}d, StartRtt not allowed", state);
333         return CALL_ERR_ILLEGAL_CALL_OPERATION;
334     }
335     return TELEPHONY_SUCCESS;
336 }
337 
StopRttPolicy(int32_t callId)338 int32_t CallPolicy::StopRttPolicy(int32_t callId)
339 {
340     sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
341     if (callPtr == nullptr) {
342         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
343         return CALL_ERR_INVALID_CALLID;
344     }
345     if (callPtr->GetCallType() != CallType::TYPE_IMS) {
346         TELEPHONY_LOGE("calltype is illegal, calltype:%{public}d", callPtr->GetCallType());
347         return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
348     }
349     TelCallState state = GetCallState(callId);
350     if (state != TelCallState::CALL_STATUS_ACTIVE) {
351         TELEPHONY_LOGE("current call state is:%{public}d, StopRtt not allowed", state);
352         return CALL_ERR_ILLEGAL_CALL_OPERATION;
353     }
354     return TELEPHONY_SUCCESS;
355 }
356 
IsValidSlotId(int32_t slotId)357 int32_t CallPolicy::IsValidSlotId(int32_t slotId)
358 {
359     bool result = DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(slotId);
360     if (!result) {
361         TELEPHONY_LOGE("invalid slotId!");
362         return CALL_ERR_INVALID_SLOT_ID;
363     }
364     return TELEPHONY_SUCCESS;
365 }
366 
EnableVoLtePolicy(int32_t slotId)367 int32_t CallPolicy::EnableVoLtePolicy(int32_t slotId)
368 {
369     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
370         TELEPHONY_LOGE("invalid slotId!");
371         return CALL_ERR_INVALID_SLOT_ID;
372     }
373     return TELEPHONY_SUCCESS;
374 }
375 
DisableVoLtePolicy(int32_t slotId)376 int32_t CallPolicy::DisableVoLtePolicy(int32_t slotId)
377 {
378     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
379         TELEPHONY_LOGE("invalid slotId!");
380         return CALL_ERR_INVALID_SLOT_ID;
381     }
382     return TELEPHONY_SUCCESS;
383 }
384 
IsVoLteEnabledPolicy(int32_t slotId)385 int32_t CallPolicy::IsVoLteEnabledPolicy(int32_t slotId)
386 {
387     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
388         TELEPHONY_LOGE("invalid slotId!");
389         return CALL_ERR_INVALID_SLOT_ID;
390     }
391     return TELEPHONY_SUCCESS;
392 }
393 
VoNRStatePolicy(int32_t slotId,int32_t state)394 int32_t CallPolicy::VoNRStatePolicy(int32_t slotId, int32_t state)
395 {
396     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
397         TELEPHONY_LOGE("invalid slotId!");
398         return CALL_ERR_INVALID_SLOT_ID;
399     }
400     if (state != static_cast<int32_t>(VoNRState::VONR_STATE_ON) &&
401         state != static_cast<int32_t>(VoNRState::VONR_STATE_OFF)) {
402         TELEPHONY_LOGE("invalid state!");
403         return TELEPHONY_ERR_ARGUMENT_INVALID;
404     }
405     return TELEPHONY_SUCCESS;
406 }
407 
GetCallWaitingPolicy(int32_t slotId)408 int32_t CallPolicy::GetCallWaitingPolicy(int32_t slotId)
409 {
410     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
411         TELEPHONY_LOGE("invalid slotId!");
412         return CALL_ERR_INVALID_SLOT_ID;
413     }
414     return TELEPHONY_SUCCESS;
415 }
416 
SetCallWaitingPolicy(int32_t slotId)417 int32_t CallPolicy::SetCallWaitingPolicy(int32_t slotId)
418 {
419     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
420         TELEPHONY_LOGE("invalid slotId!");
421         return CALL_ERR_INVALID_SLOT_ID;
422     }
423     return TELEPHONY_SUCCESS;
424 }
425 
GetCallRestrictionPolicy(int32_t slotId)426 int32_t CallPolicy::GetCallRestrictionPolicy(int32_t slotId)
427 {
428     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
429         TELEPHONY_LOGE("invalid slotId!");
430         return CALL_ERR_INVALID_SLOT_ID;
431     }
432     return TELEPHONY_SUCCESS;
433 }
434 
SetCallRestrictionPolicy(int32_t slotId)435 int32_t CallPolicy::SetCallRestrictionPolicy(int32_t slotId)
436 {
437     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
438         TELEPHONY_LOGE("invalid slotId!");
439         return CALL_ERR_INVALID_SLOT_ID;
440     }
441     return TELEPHONY_SUCCESS;
442 }
443 
GetCallTransferInfoPolicy(int32_t slotId)444 int32_t CallPolicy::GetCallTransferInfoPolicy(int32_t slotId)
445 {
446     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
447         TELEPHONY_LOGE("invalid slotId!");
448         return CALL_ERR_INVALID_SLOT_ID;
449     }
450     return TELEPHONY_SUCCESS;
451 }
452 
SetCallTransferInfoPolicy(int32_t slotId)453 int32_t CallPolicy::SetCallTransferInfoPolicy(int32_t slotId)
454 {
455     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
456         TELEPHONY_LOGE("invalid slotId!");
457         return CALL_ERR_INVALID_SLOT_ID;
458     }
459     return TELEPHONY_SUCCESS;
460 }
461 
SetCallPreferenceModePolicy(int32_t slotId)462 int32_t CallPolicy::SetCallPreferenceModePolicy(int32_t slotId)
463 {
464     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
465         TELEPHONY_LOGE("invalid slotId!");
466         return CALL_ERR_INVALID_SLOT_ID;
467     }
468     return TELEPHONY_SUCCESS;
469 }
470 
GetImsConfigPolicy(int32_t slotId)471 int32_t CallPolicy::GetImsConfigPolicy(int32_t slotId)
472 {
473     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
474         TELEPHONY_LOGE("invalid slotId!");
475         return CALL_ERR_INVALID_SLOT_ID;
476     }
477     return TELEPHONY_SUCCESS;
478 }
479 
SetImsConfigPolicy(int32_t slotId)480 int32_t CallPolicy::SetImsConfigPolicy(int32_t slotId)
481 {
482     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
483         TELEPHONY_LOGE("invalid slotId!");
484         return CALL_ERR_INVALID_SLOT_ID;
485     }
486     return TELEPHONY_SUCCESS;
487 }
488 
GetImsFeatureValuePolicy(int32_t slotId)489 int32_t CallPolicy::GetImsFeatureValuePolicy(int32_t slotId)
490 {
491     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
492         TELEPHONY_LOGE("invalid slotId!");
493         return CALL_ERR_INVALID_SLOT_ID;
494     }
495     return TELEPHONY_SUCCESS;
496 }
497 
SetImsFeatureValuePolicy(int32_t slotId)498 int32_t CallPolicy::SetImsFeatureValuePolicy(int32_t slotId)
499 {
500     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
501         TELEPHONY_LOGE("invalid slotId!");
502         return CALL_ERR_INVALID_SLOT_ID;
503     }
504     return TELEPHONY_SUCCESS;
505 }
506 
InviteToConferencePolicy(int32_t callId,std::vector<std::string> & numberList)507 int32_t CallPolicy::InviteToConferencePolicy(int32_t callId, std::vector<std::string> &numberList)
508 {
509     if (!IsCallExist(callId)) {
510         TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
511         return TELEPHONY_ERR_ARGUMENT_INVALID;
512     }
513     // check number legality
514     if (numberList.empty()) {
515         TELEPHONY_LOGE("empty phone number list!");
516         return CALL_ERR_PHONE_NUMBER_EMPTY;
517     }
518     for (size_t index = 0; index < numberList.size(); ++index) {
519         if (numberList[index].empty()) {
520             TELEPHONY_LOGE("empty phone number !");
521             return CALL_ERR_PHONE_NUMBER_EMPTY;
522         }
523         if (numberList[index].length() > kMaxNumberLen) {
524             TELEPHONY_LOGE("phone number too long !");
525             return CALL_ERR_NUMBER_OUT_OF_RANGE;
526         }
527     }
528     if (DelayedSingleton<ImsConference>::GetInstance()->GetMainCall() != callId) {
529         TELEPHONY_LOGE("conference with main callId %{public}d not exist", callId);
530         return CALL_ERR_CONFERENCE_NOT_EXISTS;
531     }
532     return TELEPHONY_SUCCESS;
533 }
534 
CloseUnFinishedUssdPolicy(int32_t slotId)535 int32_t CallPolicy::CloseUnFinishedUssdPolicy(int32_t slotId)
536 {
537     if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
538         TELEPHONY_LOGE("invalid slotId!");
539         return CALL_ERR_INVALID_SLOT_ID;
540     }
541     return TELEPHONY_SUCCESS;
542 }
543 } // namespace Telephony
544 } // namespace OHOS
545