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