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_manager_errors.h"
19 #include "telephony_log_wrapper.h"
20 #include "ims_conference.h"
21
22 #include "call_number_utils.h"
23
24 namespace OHOS {
25 namespace Telephony {
CallPolicy()26 CallPolicy::CallPolicy() {}
27
~CallPolicy()28 CallPolicy::~CallPolicy() {}
29
DialPolicy(std::u16string & number,AppExecFwk::PacMap & extras,bool isEcc)30 int32_t CallPolicy::DialPolicy(std::u16string &number, AppExecFwk::PacMap &extras, bool isEcc)
31 {
32 DialType dialType = (DialType)extras.GetIntValue("dialType");
33 if (dialType != DialType::DIAL_CARRIER_TYPE && dialType != DialType::DIAL_VOICE_MAIL_TYPE &&
34 dialType != DialType::DIAL_OTT_TYPE) {
35 TELEPHONY_LOGE("dial type invalid!");
36 return CALL_ERR_UNKNOW_DIAL_TYPE;
37 }
38 if (dialType == DialType::DIAL_CARRIER_TYPE) {
39 int32_t accountId = extras.GetIntValue("accountId");
40 if (!DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(accountId)) {
41 TELEPHONY_LOGE("invalid accountId!");
42 return CALL_ERR_INVALID_SLOT_ID;
43 }
44 }
45 CallType callType = (CallType)extras.GetIntValue("callType");
46 if (IsValidCallType(callType) != TELEPHONY_SUCCESS) {
47 return CALL_ERR_UNKNOW_CALL_TYPE;
48 }
49 DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
50 if ((dialScene != DialScene::CALL_NORMAL && dialScene != DialScene::CALL_PRIVILEGED &&
51 dialScene != DialScene::CALL_EMERGENCY) ||
52 (dialScene == DialScene::CALL_NORMAL && isEcc) || (dialScene == DialScene::CALL_EMERGENCY && (!isEcc)) ||
53 (dialType == DialType::DIAL_VOICE_MAIL_TYPE && dialScene == DialScene::CALL_EMERGENCY)) {
54 TELEPHONY_LOGE("invalid dial scene!");
55 return CALL_ERR_INVALID_DIAL_SCENE;
56 }
57 VideoStateType videoState = (VideoStateType)extras.GetIntValue("videoState");
58 if (videoState != VideoStateType::TYPE_VOICE && videoState != VideoStateType::TYPE_VIDEO) {
59 TELEPHONY_LOGE("invalid video state!");
60 return CALL_ERR_INVALID_VIDEO_STATE;
61 }
62 if (videoState == VideoStateType::TYPE_VOICE) {
63 sptr<CallBase> ringCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
64 if (ringCall != nullptr && ringCall->GetVideoStateType() == VideoStateType::TYPE_VOICE) {
65 TELEPHONY_LOGE("already has new call ringing!");
66 return CALL_ERR_CALL_COUNTS_EXCEED_LIMIT;
67 }
68 }
69 return HasNewCall();
70 }
71
IsValidCallType(CallType callType)72 int32_t CallPolicy::IsValidCallType(CallType callType)
73 {
74 if (callType != CallType::TYPE_CS && callType != CallType::TYPE_IMS && callType != CallType::TYPE_OTT &&
75 callType != CallType::TYPE_SATELLITE) {
76 TELEPHONY_LOGE("invalid call type!");
77 return CALL_ERR_UNKNOW_CALL_TYPE;
78 }
79 return TELEPHONY_SUCCESS;
80 }
81
CanDialMulityCall(AppExecFwk::PacMap & extras)82 int32_t CallPolicy::CanDialMulityCall(AppExecFwk::PacMap &extras)
83 {
84 VideoStateType videoState = (VideoStateType)extras.GetIntValue("videoState");
85 if (videoState == VideoStateType::TYPE_VIDEO && HasCellularCallExist()) {
86 TELEPHONY_LOGE("can not dial video call when any call exist!");
87 return CALL_ERR_DIAL_IS_BUSY;
88 }
89 if (videoState == VideoStateType::TYPE_VOICE && HasVideoCall()) {
90 TELEPHONY_LOGE("can not dial video call when any call exist!");
91 return CALL_ERR_DIAL_IS_BUSY;
92 }
93 return TELEPHONY_SUCCESS;
94 }
95
IsSupportVideoCall(AppExecFwk::PacMap & extras)96 bool CallPolicy::IsSupportVideoCall(AppExecFwk::PacMap &extras)
97 {
98 bool isSupportVideoCall = true;
99 #ifdef ABILITY_CONFIG_SUPPORT
100 isSupportVideoCall = GetCarrierConfig(ITEM_VIDEO_CALL);
101 #endif
102 DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
103 if (dialScene != DialScene::CALL_NORMAL) {
104 TELEPHONY_LOGW("emergency call not support video upgrade");
105 isSupportVideoCall = false;
106 }
107 return isSupportVideoCall;
108 }
109
AnswerCallPolicy(int32_t callId,int32_t videoState)110 int32_t CallPolicy::AnswerCallPolicy(int32_t callId, int32_t videoState)
111 {
112 if (videoState != static_cast<int32_t>(VideoStateType::TYPE_VOICE) &&
113 videoState != static_cast<int32_t>(VideoStateType::TYPE_VIDEO)) {
114 TELEPHONY_LOGE("videoState is invalid!");
115 return TELEPHONY_ERR_ARGUMENT_INVALID;
116 }
117 if (!IsCallExist(callId)) {
118 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
119 return TELEPHONY_ERR_ARGUMENT_INVALID;
120 }
121 TelCallState state = GetCallState(callId);
122 if (state != TelCallState::CALL_STATUS_INCOMING && state != TelCallState::CALL_STATUS_WAITING) {
123 TELEPHONY_LOGE("current call state is:%{public}d, accept call not allowed", state);
124 return CALL_ERR_ILLEGAL_CALL_OPERATION;
125 }
126 return TELEPHONY_SUCCESS;
127 }
128
RejectCallPolicy(int32_t callId)129 int32_t CallPolicy::RejectCallPolicy(int32_t callId)
130 {
131 if (!IsCallExist(callId)) {
132 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
133 return TELEPHONY_ERR_ARGUMENT_INVALID;
134 }
135 TelCallState state = GetCallState(callId);
136 if (state != TelCallState::CALL_STATUS_INCOMING && state != TelCallState::CALL_STATUS_WAITING) {
137 TELEPHONY_LOGE("current call state is:%{public}d, reject call not allowed", state);
138 return CALL_ERR_ILLEGAL_CALL_OPERATION;
139 }
140 return TELEPHONY_SUCCESS;
141 }
142
HoldCallPolicy(int32_t callId)143 int32_t CallPolicy::HoldCallPolicy(int32_t callId)
144 {
145 sptr<CallBase> call = GetOneCallObject(callId);
146 if (call == nullptr) {
147 TELEPHONY_LOGE("GetOneCallObject failed, this callId is invalid! callId:%{public}d", callId);
148 return TELEPHONY_ERR_ARGUMENT_INVALID;
149 }
150 if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_ACTIVE) {
151 TELEPHONY_LOGE("this call is not activated! callId:%{public}d", callId);
152 return CALL_ERR_CALL_IS_NOT_ACTIVATED;
153 }
154 return TELEPHONY_SUCCESS;
155 }
156
UnHoldCallPolicy(int32_t callId)157 int32_t CallPolicy::UnHoldCallPolicy(int32_t callId)
158 {
159 sptr<CallBase> call = GetOneCallObject(callId);
160 if (call == nullptr) {
161 TELEPHONY_LOGE("GetOneCallObject failed, this callId is invalid! callId:%{public}d", callId);
162 return TELEPHONY_ERR_ARGUMENT_INVALID;
163 }
164 if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_HOLD) {
165 TELEPHONY_LOGE("this call is not on holding state! callId:%{public}d", callId);
166 return CALL_ERR_CALL_IS_NOT_ON_HOLDING;
167 }
168 return TELEPHONY_SUCCESS;
169 }
170
HangUpPolicy(int32_t callId)171 int32_t CallPolicy::HangUpPolicy(int32_t callId)
172 {
173 if (!IsCallExist(callId)) {
174 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
175 return TELEPHONY_ERR_ARGUMENT_INVALID;
176 }
177 TelCallState state = GetCallState(callId);
178 if (state == TelCallState::CALL_STATUS_IDLE || state == TelCallState::CALL_STATUS_DISCONNECTING ||
179 state == TelCallState::CALL_STATUS_DISCONNECTED) {
180 TELEPHONY_LOGE("current call state is:%{public}d, hang up call not allowed", state);
181 return CALL_ERR_ILLEGAL_CALL_OPERATION;
182 }
183 return TELEPHONY_SUCCESS;
184 }
185
SwitchCallPolicy(int32_t callId)186 int32_t CallPolicy::SwitchCallPolicy(int32_t callId)
187 {
188 std::list<int32_t> callIdList;
189 if (!IsCallExist(callId)) {
190 TELEPHONY_LOGE("callId is invalid");
191 return TELEPHONY_ERR_ARGUMENT_INVALID;
192 }
193 GetCarrierCallList(callIdList);
194 if (callIdList.size() < onlyTwoCall_) {
195 callIdList.clear();
196 return CALL_ERR_PHONE_CALLS_TOO_FEW;
197 }
198 if (GetCallState(callId) != TelCallState::CALL_STATUS_HOLDING ||
199 IsCallExist(TelCallState::CALL_STATUS_DIALING) || IsCallExist(TelCallState::CALL_STATUS_ALERTING)) {
200 TELEPHONY_LOGE("the call is not on hold, callId:%{public}d", callId);
201 return CALL_ERR_ILLEGAL_CALL_OPERATION;
202 }
203 callIdList.clear();
204 return TELEPHONY_SUCCESS;
205 }
206
VideoCallPolicy(int32_t callId)207 int32_t CallPolicy::VideoCallPolicy(int32_t callId)
208 {
209 TELEPHONY_LOGI("callid %{public}d", callId);
210 sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
211 if (callPtr == nullptr) {
212 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
213 return TELEPHONY_ERR_ARGUMENT_INVALID;
214 }
215 return TELEPHONY_SUCCESS;
216 }
217
StartRttPolicy(int32_t callId)218 int32_t CallPolicy::StartRttPolicy(int32_t callId)
219 {
220 sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
221 if (callPtr == nullptr) {
222 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
223 return CALL_ERR_INVALID_CALLID;
224 }
225 if (callPtr->GetCallType() != CallType::TYPE_IMS) {
226 TELEPHONY_LOGE("calltype is illegal, calltype:%{public}d", callPtr->GetCallType());
227 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
228 }
229 TelCallState state = GetCallState(callId);
230 if (state != TelCallState::CALL_STATUS_ACTIVE) {
231 TELEPHONY_LOGE("current call state is:%{public}d, StartRtt not allowed", state);
232 return CALL_ERR_ILLEGAL_CALL_OPERATION;
233 }
234 return TELEPHONY_SUCCESS;
235 }
236
StopRttPolicy(int32_t callId)237 int32_t CallPolicy::StopRttPolicy(int32_t callId)
238 {
239 sptr<CallBase> callPtr = CallObjectManager::GetOneCallObject(callId);
240 if (callPtr == nullptr) {
241 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
242 return CALL_ERR_INVALID_CALLID;
243 }
244 if (callPtr->GetCallType() != CallType::TYPE_IMS) {
245 TELEPHONY_LOGE("calltype is illegal, calltype:%{public}d", callPtr->GetCallType());
246 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
247 }
248 TelCallState state = GetCallState(callId);
249 if (state != TelCallState::CALL_STATUS_ACTIVE) {
250 TELEPHONY_LOGE("current call state is:%{public}d, StopRtt not allowed", state);
251 return CALL_ERR_ILLEGAL_CALL_OPERATION;
252 }
253 return TELEPHONY_SUCCESS;
254 }
255
IsValidSlotId(int32_t slotId)256 int32_t CallPolicy::IsValidSlotId(int32_t slotId)
257 {
258 bool result = DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(slotId);
259 if (!result) {
260 TELEPHONY_LOGE("invalid slotId!");
261 return CALL_ERR_INVALID_SLOT_ID;
262 }
263 return TELEPHONY_SUCCESS;
264 }
265
EnableVoLtePolicy(int32_t slotId)266 int32_t CallPolicy::EnableVoLtePolicy(int32_t slotId)
267 {
268 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
269 TELEPHONY_LOGE("invalid slotId!");
270 return CALL_ERR_INVALID_SLOT_ID;
271 }
272 return TELEPHONY_SUCCESS;
273 }
274
DisableVoLtePolicy(int32_t slotId)275 int32_t CallPolicy::DisableVoLtePolicy(int32_t slotId)
276 {
277 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
278 TELEPHONY_LOGE("invalid slotId!");
279 return CALL_ERR_INVALID_SLOT_ID;
280 }
281 return TELEPHONY_SUCCESS;
282 }
283
IsVoLteEnabledPolicy(int32_t slotId)284 int32_t CallPolicy::IsVoLteEnabledPolicy(int32_t slotId)
285 {
286 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
287 TELEPHONY_LOGE("invalid slotId!");
288 return CALL_ERR_INVALID_SLOT_ID;
289 }
290 return TELEPHONY_SUCCESS;
291 }
292
VoNRStatePolicy(int32_t slotId,int32_t state)293 int32_t CallPolicy::VoNRStatePolicy(int32_t slotId, int32_t state)
294 {
295 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
296 TELEPHONY_LOGE("invalid slotId!");
297 return CALL_ERR_INVALID_SLOT_ID;
298 }
299 if (state != static_cast<int32_t>(VoNRState::VONR_STATE_ON) &&
300 state != static_cast<int32_t>(VoNRState::VONR_STATE_OFF)) {
301 TELEPHONY_LOGE("invalid state!");
302 return TELEPHONY_ERR_ARGUMENT_INVALID;
303 }
304 return TELEPHONY_SUCCESS;
305 }
306
GetCallWaitingPolicy(int32_t slotId)307 int32_t CallPolicy::GetCallWaitingPolicy(int32_t slotId)
308 {
309 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
310 TELEPHONY_LOGE("invalid slotId!");
311 return CALL_ERR_INVALID_SLOT_ID;
312 }
313 return TELEPHONY_SUCCESS;
314 }
315
SetCallWaitingPolicy(int32_t slotId)316 int32_t CallPolicy::SetCallWaitingPolicy(int32_t slotId)
317 {
318 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
319 TELEPHONY_LOGE("invalid slotId!");
320 return CALL_ERR_INVALID_SLOT_ID;
321 }
322 return TELEPHONY_SUCCESS;
323 }
324
GetCallRestrictionPolicy(int32_t slotId)325 int32_t CallPolicy::GetCallRestrictionPolicy(int32_t slotId)
326 {
327 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
328 TELEPHONY_LOGE("invalid slotId!");
329 return CALL_ERR_INVALID_SLOT_ID;
330 }
331 return TELEPHONY_SUCCESS;
332 }
333
SetCallRestrictionPolicy(int32_t slotId)334 int32_t CallPolicy::SetCallRestrictionPolicy(int32_t slotId)
335 {
336 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
337 TELEPHONY_LOGE("invalid slotId!");
338 return CALL_ERR_INVALID_SLOT_ID;
339 }
340 return TELEPHONY_SUCCESS;
341 }
342
GetCallTransferInfoPolicy(int32_t slotId)343 int32_t CallPolicy::GetCallTransferInfoPolicy(int32_t slotId)
344 {
345 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
346 TELEPHONY_LOGE("invalid slotId!");
347 return CALL_ERR_INVALID_SLOT_ID;
348 }
349 return TELEPHONY_SUCCESS;
350 }
351
SetCallTransferInfoPolicy(int32_t slotId)352 int32_t CallPolicy::SetCallTransferInfoPolicy(int32_t slotId)
353 {
354 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
355 TELEPHONY_LOGE("invalid slotId!");
356 return CALL_ERR_INVALID_SLOT_ID;
357 }
358 return TELEPHONY_SUCCESS;
359 }
360
SetCallPreferenceModePolicy(int32_t slotId)361 int32_t CallPolicy::SetCallPreferenceModePolicy(int32_t slotId)
362 {
363 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
364 TELEPHONY_LOGE("invalid slotId!");
365 return CALL_ERR_INVALID_SLOT_ID;
366 }
367 return TELEPHONY_SUCCESS;
368 }
369
GetImsConfigPolicy(int32_t slotId)370 int32_t CallPolicy::GetImsConfigPolicy(int32_t slotId)
371 {
372 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
373 TELEPHONY_LOGE("invalid slotId!");
374 return CALL_ERR_INVALID_SLOT_ID;
375 }
376 return TELEPHONY_SUCCESS;
377 }
378
SetImsConfigPolicy(int32_t slotId)379 int32_t CallPolicy::SetImsConfigPolicy(int32_t slotId)
380 {
381 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
382 TELEPHONY_LOGE("invalid slotId!");
383 return CALL_ERR_INVALID_SLOT_ID;
384 }
385 return TELEPHONY_SUCCESS;
386 }
387
GetImsFeatureValuePolicy(int32_t slotId)388 int32_t CallPolicy::GetImsFeatureValuePolicy(int32_t slotId)
389 {
390 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
391 TELEPHONY_LOGE("invalid slotId!");
392 return CALL_ERR_INVALID_SLOT_ID;
393 }
394 return TELEPHONY_SUCCESS;
395 }
396
SetImsFeatureValuePolicy(int32_t slotId)397 int32_t CallPolicy::SetImsFeatureValuePolicy(int32_t slotId)
398 {
399 if (IsValidSlotId(slotId) != TELEPHONY_SUCCESS) {
400 TELEPHONY_LOGE("invalid slotId!");
401 return CALL_ERR_INVALID_SLOT_ID;
402 }
403 return TELEPHONY_SUCCESS;
404 }
405
InviteToConferencePolicy(int32_t callId,std::vector<std::string> & numberList)406 int32_t CallPolicy::InviteToConferencePolicy(int32_t callId, std::vector<std::string> &numberList)
407 {
408 if (!IsCallExist(callId)) {
409 TELEPHONY_LOGE("callId is invalid, callId:%{public}d", callId);
410 return TELEPHONY_ERR_ARGUMENT_INVALID;
411 }
412 // check number legality
413 if (numberList.empty()) {
414 TELEPHONY_LOGE("empty phone number list!");
415 return CALL_ERR_PHONE_NUMBER_EMPTY;
416 }
417 for (size_t index = 0; index < numberList.size(); ++index) {
418 if (numberList[index].empty()) {
419 TELEPHONY_LOGE("empty phone number !");
420 return CALL_ERR_PHONE_NUMBER_EMPTY;
421 }
422 if (numberList[index].length() > kMaxNumberLen) {
423 TELEPHONY_LOGE("phone number too long !");
424 return CALL_ERR_NUMBER_OUT_OF_RANGE;
425 }
426 }
427 if (DelayedSingleton<ImsConference>::GetInstance()->GetMainCall() != callId) {
428 TELEPHONY_LOGE("conference with main callId %{public}d not exist", callId);
429 return CALL_ERR_CONFERENCE_NOT_EXISTS;
430 }
431 return TELEPHONY_SUCCESS;
432 }
433
CloseUnFinishedUssdPolicy(int32_t slotId)434 int32_t CallPolicy::CloseUnFinishedUssdPolicy(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 } // namespace Telephony
443 } // namespace OHOS
444