1 /*
2 * Copyright (C) 2021 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 "cellular_call_supplement.h"
17
18 #include "securec.h"
19 #include "cellular_call_register.h"
20 #include "standardize_utils.h"
21 #include "telephony_log_wrapper.h"
22
23 namespace OHOS {
24 namespace Telephony {
operator ""_hash(char const * p,size_t s)25 constexpr unsigned long long operator"" _hash(char const *p, size_t s)
26 {
27 return StandardizeUtils::HashCompileTime(p);
28 }
29
GetClip(int32_t slotId,const MMIData & mmiData)30 void CellularCallSupplement::GetClip(int32_t slotId, const MMIData &mmiData)
31 {
32 const std::string interrogate = "*#";
33 if (!mmiData.actionString.empty() && mmiData.actionString == interrogate) {
34 supplementRequest_.InquireClipRequest(slotId);
35 }
36 }
37
GetClir(int32_t slotId,const MMIData & mmiData)38 void CellularCallSupplement::GetClir(int32_t slotId, const MMIData &mmiData)
39 {
40 const std::string interrogate = "*#";
41 const std::string activate = "*";
42 const std::string deactivate = "#";
43 if (mmiData.actionString.empty()) {
44 TELEPHONY_LOGE("GetClir return, actionString is empty!");
45 return;
46 }
47 if (mmiData.actionString == activate) {
48 supplementRequest_.SetClirRequest(slotId, ACTIVATE_ACTION);
49 } else if (mmiData.actionString == deactivate) {
50 supplementRequest_.SetClirRequest(slotId, DEACTIVATE_ACTION);
51 } else if (mmiData.actionString == interrogate) {
52 supplementRequest_.InquireClirRequest(slotId);
53 }
54 }
55
DealCallTransfer(int32_t slotId,const MMIData & mmiData)56 void CellularCallSupplement::DealCallTransfer(int32_t slotId, const MMIData &mmiData)
57 {
58 const std::string interrogate = "*#";
59 int32_t serviceCode = ObtainServiceCode(mmiData.serviceInfoB);
60 int32_t cause = ObtainCause(mmiData.serviceCode);
61 if (!mmiData.actionString.empty() && mmiData.actionString == interrogate) {
62 supplementRequest_.GetCallTransferRequest(slotId, cause);
63 return;
64 }
65 std::string phoneNumber = mmiData.serviceInfoA;
66 int32_t callForwardAction;
67 if (mmiData.actionString.empty()) {
68 TELEPHONY_LOGE("DealCallTransfer return, actionString is empty!");
69 return;
70 }
71
72 // 3GPP TS 24.082 V4.0.0 (2001-03) 1 Call Forwarding Unconditional (CFU)
73 // 3GPP TS 24.082 V4.0.0 (2001-03) 2 Call Forwarding on mobile subscriber Busy (CFB)
74 // 3GPP TS 24.082 V4.0.0 (2001-03) 3 Call Forwarding on No Reply (CFNRy)
75 // 3GPP TS 24.082 V4.0.0 (2001-03) 4 Call Forwarding on mobile subscriber Not Reachable (CFNRc)
76 switch (StandardizeUtils::Hash_(mmiData.actionString.c_str())) {
77 case "*"_hash:
78 if (phoneNumber.empty()) {
79 callForwardAction = (int32_t)CallTransferSettingType::CALL_TRANSFER_ENABLE;
80 } else {
81 callForwardAction = (int32_t)CallTransferSettingType::CALL_TRANSFER_REGISTRATION;
82 }
83 break;
84 case "#"_hash:
85 callForwardAction = (int32_t)CallTransferSettingType::CALL_TRANSFER_DISABLE;
86 break;
87 case "**"_hash:
88 callForwardAction = (int32_t)CallTransferSettingType::CALL_TRANSFER_REGISTRATION;
89 break;
90 case "##"_hash:
91 callForwardAction = (int32_t)CallTransferSettingType::CALL_TRANSFER_ERASURE;
92 break;
93 default:
94 TELEPHONY_LOGE("DealCallTransfer return, actionString out of range, please check!");
95 return;
96 }
97 supplementRequest_.SetCallTransferRequest(slotId, callForwardAction, cause, phoneNumber, serviceCode);
98 }
99
ObtainServiceCode(const std::string & serviceInfoB)100 int32_t CellularCallSupplement::ObtainServiceCode(const std::string &serviceInfoB)
101 {
102 if (serviceInfoB.empty()) {
103 TELEPHONY_LOGE("ObtainServiceCode return, serviceInfoB is empty!");
104 return NONE;
105 }
106 int32_t intServiceInfoB = atoi(serviceInfoB.c_str());
107 switch (intServiceInfoB) {
108 case ALL_TELE_SERVICES:
109 return SHORT_MESSAGE_SERVICE + FAX + VOICE;
110 case TELE_SERVICES:
111 return VOICE;
112 case ALL_DATA_TELE_SERVICES:
113 return SHORT_MESSAGE_SERVICE + FAX;
114 case FACSIMILE_SERVICES:
115 return FAX;
116 case SHORT_MESSAGE_SERVICES:
117 return SHORT_MESSAGE_SERVICE;
118 case ALL_TELE_SERVICES_EXCEPT_SMS:
119 return FAX + VOICE;
120 case ALL_BEARER_SERVICES:
121 return DATA_CIRCUIT_ASYNC + DATA_CIRCUIT_SYNC;
122 case ALL_ASYNC_SERVICES:
123 return DEDICATED_PAD_ACCESS + DATA_CIRCUIT_ASYNC;
124 case ALL_SYNC_SERVICES:
125 return DEDICATED_PACKET_ACCESS + DATA_CIRCUIT_SYNC;
126 case ALL_DATA_CIRCUIT_SYNC:
127 return DATA_CIRCUIT_SYNC;
128 case ALL_DATA_CIRCUIT_ASYNC:
129 return DATA_CIRCUIT_ASYNC;
130 case ALL_GPRS_BEARER_SERVICES:
131 return DEDICATED_PACKET_ACCESS;
132 default:
133 TELEPHONY_LOGE("ObtainServiceCode return, serviceInfoB out of range, please check!");
134 return NONE;
135 }
136 }
137
ObtainCause(const std::string & actionStr)138 int32_t CellularCallSupplement::ObtainCause(const std::string &actionStr)
139 {
140 if (actionStr.empty()) {
141 TELEPHONY_LOGE("ObtainCause return, actionStr is empty!");
142 return TELEPHONY_ERROR;
143 }
144
145 /*
146 * 3GPP TS 22.030 V4.0.0 (2001-03) Annex B (normative): Codes for defined Supplementary Services
147 * CFU 21
148 * CF Busy 67
149 * CF No Reply 61
150 * CF Not Reachable 62
151 * all CF 002
152 * all conditional CF 004
153 */
154 switch (StandardizeUtils::Hash_(actionStr.c_str())) {
155 case "21"_hash:
156 return (int32_t)CallTransferType::TRANSFER_TYPE_UNCONDITIONAL;
157 case "67"_hash:
158 return (int32_t)CallTransferType::TRANSFER_TYPE_BUSY;
159 case "62"_hash:
160 return (int32_t)CallTransferType::TRANSFER_TYPE_NO_REPLY;
161 case "61"_hash:
162 return (int32_t)CallTransferType::TRANSFER_TYPE_NOT_REACHABLE;
163 default:
164 TELEPHONY_LOGE("ObtainCause return, actionStr out of range!");
165 return TELEPHONY_ERROR;
166 }
167 }
168
DealCallRestriction(int32_t slotId,const MMIData & mmiData)169 void CellularCallSupplement::DealCallRestriction(int32_t slotId, const MMIData &mmiData)
170 {
171 std::string infoA = mmiData.serviceInfoA;
172 std::string facType = ObtainBarringInstallation(mmiData.serviceInfoC);
173 const std::string interrogate = "*#";
174 const std::string activate = "*";
175 const std::string deactivate = "#";
176 if (mmiData.actionString.empty()) {
177 TELEPHONY_LOGE("DealCallRestriction return, actionString is empty!");
178 return;
179 }
180 if (mmiData.actionString == interrogate) {
181 supplementRequest_.GetCallRestrictionRequest(slotId, facType);
182 } else if (mmiData.actionString == activate || mmiData.actionString == deactivate) {
183 supplementRequest_.SetCallRestrictionRequest(slotId, facType, mmiData.actionString == activate, infoA);
184 }
185 }
186
ObtainBarringInstallation(const std::string & serviceInfoC)187 std::string CellularCallSupplement::ObtainBarringInstallation(const std::string &serviceInfoC)
188 {
189 if (serviceInfoC.empty()) {
190 TELEPHONY_LOGE("ObtainBarringInstallation return, serviceInfoC is empty!");
191 return std::string();
192 }
193
194 /*
195 * 27007-430_2001 7.4 Facility lock +CLCK
196 * Supplementary Service Service Code SIA SIB SIC
197 * 22.088
198 * BAOC 33 PW BS -
199 * BAOIC 331 PW BS -
200 * BAOIC exc home 332 PW BS -
201 * BAIC 35 PW BS -
202 * BAIC roaming 351 PW BS -
203 * all Barring Serv. 330 PW BS -
204 * Outg. Barr. Serv. 333 PW BS
205 * Inc. Barr. Serv. 353 PW BS
206 */
207 switch (StandardizeUtils::Hash_(serviceInfoC.c_str())) {
208 case "33"_hash:
209 // "AO" BAOC (Barr All Outgoing Calls) (refer 3GPP TS 22.088 [6] clause 1)
210 return BARR_ALL_OUTGOING_CALLS;
211 case "331"_hash:
212 // "OI" BOIC (Barr Outgoing International Calls) (refer 3GPP TS 22.088 [6] clause 1)
213 return BARR_OUTGOING_INTERNATIONAL_CALLS;
214 case "332"_hash:
215 // "OX" BOIC exHC (Barr Outgoing International Calls except to Home Country)
216 // (refer 3GPP TS 22.088 [6] clause 1)
217 return BARR_OUTGOING_INTERNATIONAL_CALLS_EXCLUDING_HOME;
218 case "351"_hash:
219 // "IR" BIC Roam (Barr Incoming Calls when Roaming outside the home country)
220 // (refer 3GPP TS 22.088 [6] clause 2)
221 return BARR_INCOMING_CALLS_OUTSIDE_HOME;
222 case "35"_hash:
223 // "AI" BAIC (Barr All Incoming Calls) (refer 3GPP TS 22.088 [6] clause 2)
224 return BARR_ALL_INCOMING_CALLS;
225 case "330"_hash:
226 // "AB" All Barring services (refer 3GPP TS 22.030 [19]) (applicable only for <mode>=0)
227 return ALL_BARRING_SERVICES;
228 case "333"_hash:
229 // "AG" All outGoing barring services (refer 3GPP TS 22.030 [19]) (applicable only for <mode>=0)
230 return ALL_OUTGOING_BARRING_SERVICES;
231 case "353"_hash:
232 // "AC" All inComing barring services (refer 3GPP TS 22.030 [19]) (applicable only for <mode>=0)
233 return ALL_INCOMING_BARRING_SERVICES;
234 default:
235 TELEPHONY_LOGE("ObtainBarringInstallation return, serviceInfoC out of range!");
236 return std::string();
237 }
238 }
239
DealCallWaiting(int32_t slotId,const MMIData & mmiData)240 void CellularCallSupplement::DealCallWaiting(int32_t slotId, const MMIData &mmiData)
241 {
242 if (mmiData.actionString.empty()) {
243 TELEPHONY_LOGE("DealCallWaiting return, actionString is empty!");
244 return;
245 }
246 const std::string activate = "*";
247 const std::string deactivate = "#";
248 const std::string interrogate = "*#";
249 if (mmiData.actionString == activate || mmiData.actionString == deactivate) {
250 supplementRequest_.SetCallWaitingRequest(slotId, mmiData.actionString == activate);
251 } else if (mmiData.actionString == interrogate) {
252 supplementRequest_.GetCallWaitingRequest(slotId);
253 }
254 }
255
EventGetCallWaiting(CallWaitResult & waitingInfo)256 void CellularCallSupplement::EventGetCallWaiting(CallWaitResult &waitingInfo)
257 {
258 CallWaitResponse callWaitResponse;
259 callWaitResponse.result = waitingInfo.result;
260
261 /*
262 * <n> (sets/shows the result code presentation status in the TA):
263 * 0 disable
264 * 1 enable
265 */
266 callWaitResponse.status = waitingInfo.status;
267 callWaitResponse.classCw = waitingInfo.classCw;
268 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
269 TELEPHONY_LOGE("EventGetCallWaiting return, GetInstance is nullptr.");
270 return;
271 }
272 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportGetWaitingResult(callWaitResponse);
273 }
274
EventSetCallWaiting(HRilRadioResponseInfo & responseInfo)275 void CellularCallSupplement::EventSetCallWaiting(HRilRadioResponseInfo &responseInfo)
276 {
277 CallWaitResponse callWaitResponse;
278 callWaitResponse.result = static_cast<int32_t>(responseInfo.error);
279 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
280 TELEPHONY_LOGE("EventSetCallWaiting return, GetInstance is nullptr.");
281 return;
282 }
283 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportSetWaitingResult((int32_t)responseInfo.error);
284 }
285
EventGetCallTransferInfo(CallForwardQueryResult & queryResult)286 void CellularCallSupplement::EventGetCallTransferInfo(CallForwardQueryResult &queryResult)
287 {
288 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
289 TELEPHONY_LOGE("EventGetCallTransferInfo return, GetInstance is nullptr.");
290 return;
291 }
292
293 // 3GPP TS 27.007 V3.9.0 (2001-06) 7.11 Call forwarding number and conditions +CCFC
294 CallTransferResponse response;
295 if (memset_s(&response, sizeof(response), 0, sizeof(response)) != EOK) {
296 TELEPHONY_LOGE("EventGetCallTransferInfo return, memset_s fail.");
297 return;
298 }
299
300 // <number>: string type phone number of forwarding address in format specified by <type>
301 size_t cpyLen = strlen(queryResult.number.c_str()) + 1;
302 if (strcpy_s(response.number, cpyLen, queryResult.number.c_str()) != EOK) {
303 TELEPHONY_LOGE("EventGetCallTransferInfo return, strcpy_s fail.");
304 return;
305 }
306
307 response.result = queryResult.result;
308
309 /*
310 * <status>:0 not active; 1 active
311 * */
312 response.status = queryResult.status;
313
314 /*
315 * <classx> is a sum of integers each representing a class of information (default 7):
316 * 1 voice (telephony)
317 * 2 data (refers to all bearer services)
318 * 4 fax (facsimile services)
319 * 8 short message service
320 * 16 data circuit sync
321 * 32 data circuit async
322 * 64 dedicated packet access
323 * 128 dedicated PAD access
324 */
325 response.classx = queryResult.classx;
326 // <type>: type of address octet in integer format (refer GSM 04.08 [8] subclause 10.5.4.7);
327 // default 145 when dialling string includes international access code character "+", otherwise 129
328 response.type = queryResult.type;
329
330 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportGetTransferResult(response);
331 }
332
EventSetCallTransferInfo(HRilRadioResponseInfo & responseInfo)333 void CellularCallSupplement::EventSetCallTransferInfo(HRilRadioResponseInfo &responseInfo)
334 {
335 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
336 TELEPHONY_LOGE("EventSetCallTransferInfo return, GetInstance is nullptr.");
337 return;
338 }
339 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportSetTransferResult((int32_t)responseInfo.error);
340 }
341
EventGetCallRestriction(const CallRestrictionResult & result)342 void CellularCallSupplement::EventGetCallRestriction(const CallRestrictionResult &result)
343 {
344 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
345 TELEPHONY_LOGE("EventGetCallRestriction return, GetInstance is nullptr.");
346 return;
347 }
348 CallRestrictionResponse response;
349 response.result = result.result;
350
351 /*
352 * <status>:0 not active 1 active
353 */
354 response.status = result.status;
355 response.classCw = result.classCw;
356
357 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportGetRestrictionResult(response);
358 }
359
EventSetCallRestriction(HRilRadioResponseInfo & info)360 void CellularCallSupplement::EventSetCallRestriction(HRilRadioResponseInfo &info)
361 {
362 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
363 TELEPHONY_LOGE("EventSetCallRestriction return, GetInstance is nullptr.");
364 return;
365 }
366 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportSetRestrictionResult((int32_t)info.error);
367 }
368
SetCallTransferInfo(int32_t slotId,const CallTransferInfo & cfInfo)369 int32_t CellularCallSupplement::SetCallTransferInfo(int32_t slotId, const CallTransferInfo &cfInfo)
370 {
371 if (!PhoneTypeGsmOrNot(slotId)) {
372 TELEPHONY_LOGE("SetCallTransferInfo return, network type is not supported!");
373 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
374 }
375 if (strlen(cfInfo.transferNum) == 0) {
376 TELEPHONY_LOGE("SetCallTransferInfo return, transferNum is empty!");
377 return CALL_ERR_PHONE_NUMBER_EMPTY;
378 }
379
380 /*
381 * <reason>:
382 * 0 unconditional
383 * 1 mobile busy
384 * 2 no reply
385 * 3 not reachable
386 * 4 all call forwarding (refer 3GPP TS 22.030 [19])
387 * 5 all conditional call forwarding (refer 3GPP TS 22.030 [19])
388 * <mode>:
389 * 0 disable
390 * 1 enable
391 * 2 query status
392 * 3 registration
393 * 4 erasure
394 */
395 if (cfInfo.type > CallTransferType::TRANSFER_TYPE_NOT_REACHABLE ||
396 cfInfo.type < CallTransferType::TRANSFER_TYPE_UNCONDITIONAL ||
397 cfInfo.settingType > CallTransferSettingType::CALL_TRANSFER_ERASURE ||
398 cfInfo.settingType < CallTransferSettingType::CALL_TRANSFER_DISABLE) {
399 TELEPHONY_LOGE("SetCallTransferInfo return, parameter out of range!");
400 return CALL_ERR_PARAMETER_OUT_OF_RANGE;
401 }
402
403 std::string dialString(cfInfo.transferNum);
404 return supplementRequest_.SetCallTransferRequest(
405 slotId, (int32_t)cfInfo.settingType, (int32_t)cfInfo.type, dialString, 1);
406 }
407
GetCallTransferInfo(int32_t slotId,CallTransferType type)408 int32_t CellularCallSupplement::GetCallTransferInfo(int32_t slotId, CallTransferType type)
409 {
410 if (!PhoneTypeGsmOrNot(slotId)) {
411 TELEPHONY_LOGE("GetCallTransferInfo return, network type is not supported!");
412 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
413 }
414
415 /*
416 * When querying the status of a network service (<mode>=2) the response line for 'not active' case
417 * (<status>=0) should be returned only if service is not active for any <class>
418 */
419 return supplementRequest_.GetCallTransferRequest(slotId, (int32_t)type);
420 }
421
PhoneTypeGsmOrNot(int32_t slotId)422 bool CellularCallSupplement::PhoneTypeGsmOrNot(int32_t slotId)
423 {
424 return moduleServiceUtils_.GetNetworkStatus(slotId) == PhoneType::PHONE_TYPE_IS_GSM;
425 }
426
SetCallWaiting(int32_t slotId,bool activate)427 int32_t CellularCallSupplement::SetCallWaiting(int32_t slotId, bool activate)
428 {
429 /*
430 * <n> (sets/shows the result code presentation status in the TA):
431 * 0 disable
432 * 1 enable
433 */
434 if (!PhoneTypeGsmOrNot(slotId)) {
435 TELEPHONY_LOGE("SetCallWaiting return, network type is not supported!");
436 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
437 }
438 return supplementRequest_.SetCallWaitingRequest(slotId, activate);
439 }
440
GetCallWaiting(int32_t slotId)441 int32_t CellularCallSupplement::GetCallWaiting(int32_t slotId)
442 {
443 if (!PhoneTypeGsmOrNot(slotId)) {
444 TELEPHONY_LOGE("GetCallWaiting return, network type is not supported!");
445 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
446 }
447 return supplementRequest_.GetCallWaitingRequest(slotId);
448 }
449
SetCallRestriction(int32_t slotId,const CallRestrictionInfo & cRInfo)450 int32_t CellularCallSupplement::SetCallRestriction(int32_t slotId, const CallRestrictionInfo &cRInfo)
451 {
452 /*
453 * <fac> values reserved by the present document:
454 * "SC" SIM (lock SIM/UICC card) (SIM/UICC asks password in ME power up and when this lock command issued)
455 * "AO" BAOC (Barr All Outgoing Calls) (refer 3GPP TS 22.088 [6] clause 1)
456 * "OI" BOIC (Barr Outgoing International Calls) (refer 3GPP TS 22.088 [6] clause 1)
457 * "OX" BOIC exHC (Barr Outgoing International Calls except to Home Country) (refer 3GPP TS 22.088 [6] clause 1)
458 * "AI" BAIC (Barr All Incoming Calls) (refer 3GPP TS 22.088 [6] clause 2)
459 * "IR" BIC Roam (Barr Incoming Calls when Roaming outside the home country) (refer 3GPP TS 22.088 [6] clause 2)
460 * "AB" All Barring services (refer 3GPP TS 22.030 [19]) (applicable only for <mode>=0)
461 * "AG" All outGoing barring services (refer 3GPP TS 22.030 [19]) (applicable only for <mode>=0)
462 * "AC" All inComing barring services (refer 3GPP TS 22.030 [19]) (applicable only for <mode>=0)
463 */
464 if (!PhoneTypeGsmOrNot(slotId)) {
465 TELEPHONY_LOGE("SetCallRestriction return, network type is not supported!");
466 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
467 }
468
469 std::string fac;
470 switch (cRInfo.fac) {
471 case CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING:
472 fac = BARR_ALL_OUTGOING_CALLS;
473 break;
474 case CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL:
475 fac = BARR_OUTGOING_INTERNATIONAL_CALLS;
476 break;
477 case CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME:
478 fac = BARR_OUTGOING_INTERNATIONAL_CALLS_EXCLUDING_HOME;
479 break;
480 case CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING:
481 fac = BARR_ALL_INCOMING_CALLS;
482 break;
483 case CallRestrictionType::RESTRICTION_TYPE_ROAMING_INCOMING:
484 fac = BARR_INCOMING_CALLS_OUTSIDE_HOME;
485 break;
486 case CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS:
487 fac = ALL_BARRING_SERVICES;
488 break;
489 case CallRestrictionType::RESTRICTION_TYPE_OUTGOING_SERVICES:
490 fac = ALL_OUTGOING_BARRING_SERVICES;
491 break;
492 case CallRestrictionType::RESTRICTION_TYPE_INCOMING_SERVICES:
493 fac = ALL_INCOMING_BARRING_SERVICES;
494 break;
495 default:
496 TELEPHONY_LOGE("SetCallRestriction return, fac parameter out of range!");
497 return CALL_ERR_PARAMETER_OUT_OF_RANGE;
498 }
499 if (cRInfo.mode < CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION ||
500 cRInfo.mode > CallRestrictionMode::RESTRICTION_MODE_ACTIVATION) {
501 TELEPHONY_LOGE("SetCallRestriction return, mode parameter out of range!");
502 return CALL_ERR_PARAMETER_OUT_OF_RANGE;
503 }
504 std::string info(cRInfo.password);
505 return supplementRequest_.SetCallRestrictionRequest(slotId, fac, (int32_t)cRInfo.mode, info);
506 }
507
GetCallRestriction(int32_t slotId,CallRestrictionType facType)508 int32_t CellularCallSupplement::GetCallRestriction(int32_t slotId, CallRestrictionType facType)
509 {
510 if (!PhoneTypeGsmOrNot(slotId)) {
511 TELEPHONY_LOGE("GetCallRestriction return, network type is not supported!");
512 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
513 }
514 std::string fac;
515 switch (facType) {
516 case CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING:
517 fac = BARR_ALL_OUTGOING_CALLS;
518 break;
519 case CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL:
520 fac = BARR_OUTGOING_INTERNATIONAL_CALLS;
521 break;
522 case CallRestrictionType::RESTRICTION_TYPE_INTERNATIONAL_EXCLUDING_HOME:
523 fac = BARR_OUTGOING_INTERNATIONAL_CALLS_EXCLUDING_HOME;
524 break;
525 case CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING:
526 fac = BARR_ALL_INCOMING_CALLS;
527 break;
528 case CallRestrictionType::RESTRICTION_TYPE_ROAMING_INCOMING:
529 fac = BARR_INCOMING_CALLS_OUTSIDE_HOME;
530 break;
531 case CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS:
532 fac = ALL_BARRING_SERVICES;
533 break;
534 case CallRestrictionType::RESTRICTION_TYPE_OUTGOING_SERVICES:
535 fac = ALL_OUTGOING_BARRING_SERVICES;
536 break;
537 case CallRestrictionType::RESTRICTION_TYPE_INCOMING_SERVICES:
538 fac = ALL_INCOMING_BARRING_SERVICES;
539 break;
540 default:
541 TELEPHONY_LOGE("GetCallRestriction return, parameter out of range!");
542 return CALL_ERR_PARAMETER_OUT_OF_RANGE;
543 }
544 return supplementRequest_.GetCallRestrictionRequest(slotId, fac);
545 }
546
EventGetClip(GetClipResult & getClipResult)547 void CellularCallSupplement::EventGetClip(GetClipResult &getClipResult)
548 {
549 ClipResponse clipResponse;
550 clipResponse.result = getClipResult.result;
551 clipResponse.action = getClipResult.action;
552 clipResponse.clipStat = getClipResult.clipStat;
553 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
554 TELEPHONY_LOGE("EventGetClip return, GetInstance is nullptr.");
555 return;
556 }
557 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportGetClipResult(clipResponse);
558 }
559
EventGetClir(GetClirResult & result)560 void CellularCallSupplement::EventGetClir(GetClirResult &result)
561 {
562 ClirResponse response;
563 // 3GPP TS 27.007 V3.9.0 (2001-06) 7.7 Calling line identification restriction +CLIR
564 response.result = result.result;
565 response.action = result.action;
566 response.clirStat = result.clirStat;
567 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
568 TELEPHONY_LOGE("EventGetClir return, GetInstance is nullptr.");
569 return;
570 }
571 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportGetClirResult(response);
572 }
573
EventSetClir(HRilRadioResponseInfo & info)574 void CellularCallSupplement::EventSetClir(HRilRadioResponseInfo &info)
575 {
576 TELEPHONY_LOGI("CellularCallSupplement::EventSetClir entry");
577 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
578 TELEPHONY_LOGE("EventSetClir return, GetInstance is nullptr.");
579 return;
580 }
581 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportSetClirResult(static_cast<int32_t>(info.error));
582 }
583
SendUssd(int32_t slotId,const std::string & msg)584 int32_t CellularCallSupplement::SendUssd(int32_t slotId, const std::string &msg)
585 {
586 TELEPHONY_LOGI("CellularCallSupplement::SendUssd entry");
587 if (!PhoneTypeGsmOrNot(slotId)) {
588 TELEPHONY_LOGE("SendUssd return, network type is not supported!");
589 return CALL_ERR_UNSUPPORTED_NETWORK_TYPE;
590 }
591 return supplementRequest_.SendUssdRequest(slotId, msg);
592 }
593
EventSendUssd(HRilRadioResponseInfo & responseInfo)594 void CellularCallSupplement::EventSendUssd(HRilRadioResponseInfo &responseInfo)
595 {
596 TELEPHONY_LOGI("CellularCallSupplement::EventSendUssd entry");
597 if (DelayedSingleton<CellularCallRegister>::GetInstance() == nullptr) {
598 TELEPHONY_LOGE("EventSendUssd return, GetInstance is nullptr.");
599 return;
600 }
601 DelayedSingleton<CellularCallRegister>::GetInstance()->ReportSendUssdResult(
602 static_cast<int32_t>(responseInfo.error));
603 }
604 } // namespace Telephony
605 } // namespace OHOS
606