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