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
30namespace OHOS {
31namespace Telephony {
32CallPolicy::CallPolicy() {}
33
34CallPolicy::~CallPolicy() {}
35
36int32_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
82int32_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}
108int32_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
152int32_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
162int32_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
175int32_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
185int32_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
205bool 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
219int32_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
238int32_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
252int32_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
266int32_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
280int32_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
295int32_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
316int32_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
327int32_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
346int32_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
365int32_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
375int32_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
384int32_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
393int32_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
402int32_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
416int32_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
425int32_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
434int32_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
443int32_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
452int32_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
461int32_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
470int32_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
479int32_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
488int32_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
497int32_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
506int32_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
515int32_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
543int32_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