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 "core_service.h"
17
18 #include "core_manager_inner.h"
19 #include "core_service_dump_helper.h"
20 #include "ims_core_service_client.h"
21 #include "ipc_skeleton.h"
22 #include "network_search_manager.h"
23 #include "network_search_types.h"
24 #include "parameter.h"
25 #include "sim_manager.h"
26 #include "string_ex.h"
27 #include "system_ability_definition.h"
28 #include "telephony_common_utils.h"
29 #include "telephony_errors.h"
30 #include "telephony_ext_wrapper.h"
31 #include "telephony_log_wrapper.h"
32 #include "telephony_permission.h"
33
34 namespace OHOS {
35 namespace Telephony {
36 namespace {
37 const int32_t MAX_IPC_THREAD_NUM = 6;
38 }
39 const bool G_REGISTER_RESULT =
40 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<CoreService>::GetInstance().get());
41
CoreService()42 CoreService::CoreService() : SystemAbility(TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID, true) {}
43
~CoreService()44 CoreService::~CoreService() {}
45
OnStart()46 void CoreService::OnStart()
47 {
48 bindTime_ =
49 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
50 .count();
51 if (state_ == ServiceRunningState::STATE_RUNNING) {
52 TELEPHONY_LOGE("CoreService has already started.");
53 return;
54 }
55
56 if (!registerToService_) {
57 bool ret = Publish(DelayedSingleton<CoreService>::GetInstance().get());
58 if (!ret) {
59 TELEPHONY_LOGE("CoreService::Init Publish failed!");
60 return;
61 }
62 registerToService_ = true;
63 }
64 IPCSkeleton::SetMaxWorkThreadNum(MAX_IPC_THREAD_NUM);
65 if (!Init()) {
66 TELEPHONY_LOGE("failed to init CoreService");
67 return;
68 }
69 state_ = ServiceRunningState::STATE_RUNNING;
70 endTime_ =
71 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
72 .count();
73 TELEPHONY_LOGI("CoreService start success");
74 }
75
Init()76 bool CoreService::Init()
77 {
78 TELEPHONY_LOGI("CoreService::Init");
79 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
80 TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
81 #endif
82 telRilManager_ = std::make_shared<TelRilManager>();
83 if (telRilManager_ != nullptr) {
84 if (!telRilManager_->OnInit()) {
85 TELEPHONY_LOGE("TelRilManager init is failed!");
86 return false;
87 }
88 }
89 CoreManagerInner::GetInstance().SetTelRilMangerObj(telRilManager_);
90 int32_t slotCount = GetMaxSimCount();
91 simManager_ = std::make_shared<SimManager>(telRilManager_);
92 if (simManager_ != nullptr) {
93 simManager_->OnInit(slotCount);
94 } else {
95 TELEPHONY_LOGE("SimManager init is failed!");
96 return false;
97 }
98 // connect ims_service
99 DelayedSingleton<ImsCoreServiceClient>::GetInstance()->Init();
100 networkSearchManager_ = std::make_shared<NetworkSearchManager>(telRilManager_, simManager_);
101 if (networkSearchManager_ != nullptr) {
102 if (!networkSearchManager_->OnInit()) {
103 TELEPHONY_LOGE("NetworkSearchManager init is failed!");
104 return false;
105 }
106 }
107 CoreManagerInner::GetInstance().OnInit(networkSearchManager_, simManager_, telRilManager_);
108 TELEPHONY_LOGI("CoreService::Init success");
109 return true;
110 }
111
OnStop()112 void CoreService::OnStop()
113 {
114 state_ = ServiceRunningState::STATE_NOT_START;
115 registerToService_ = false;
116 DelayedSingleton<ImsCoreServiceClient>::GetInstance()->UnInit();
117 telRilManager_->DeInit();
118 TELEPHONY_LOGI("CoreService Stop success");
119 }
120
GetServiceRunningState()121 int32_t CoreService::GetServiceRunningState()
122 {
123 return static_cast<int32_t>(state_);
124 }
125
GetPsRadioTech(int32_t slotId,int32_t & psRadioTech)126 int32_t CoreService::GetPsRadioTech(int32_t slotId, int32_t &psRadioTech)
127 {
128 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
129 TELEPHONY_LOGE("permission denied!");
130 return TELEPHONY_ERR_PERMISSION_ERR;
131 }
132 if (networkSearchManager_ == nullptr) {
133 TELEPHONY_LOGE("networkSearchManager_ is null");
134 return TELEPHONY_ERR_LOCAL_PTR_NULL;
135 }
136 return networkSearchManager_->GetPsRadioTech(slotId, psRadioTech);
137 }
138
GetCsRadioTech(int32_t slotId,int32_t & csRadioTech)139 int32_t CoreService::GetCsRadioTech(int32_t slotId, int32_t &csRadioTech)
140 {
141 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
142 TELEPHONY_LOGE("permission denied!");
143 return TELEPHONY_ERR_PERMISSION_ERR;
144 }
145 if (networkSearchManager_ == nullptr) {
146 TELEPHONY_LOGE("networkSearchManager_ is null");
147 return TELEPHONY_ERR_LOCAL_PTR_NULL;
148 }
149 return networkSearchManager_->GetCsRadioTech(slotId, csRadioTech);
150 }
151
SetNetworkSelectionMode(int32_t slotId,int32_t selectMode,const sptr<NetworkInformation> & networkInformation,bool resumeSelection,const sptr<INetworkSearchCallback> & callback)152 int32_t CoreService::SetNetworkSelectionMode(int32_t slotId, int32_t selectMode,
153 const sptr<NetworkInformation> &networkInformation, bool resumeSelection,
154 const sptr<INetworkSearchCallback> &callback)
155 {
156 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
157 TELEPHONY_LOGE("Non-system applications use system APIs!");
158 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
159 }
160 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
161 TELEPHONY_LOGE("permission denied!");
162 return TELEPHONY_ERR_PERMISSION_ERR;
163 }
164 if (networkSearchManager_ == nullptr) {
165 TELEPHONY_LOGE("networkSearchManager_ is null");
166 return TELEPHONY_ERR_LOCAL_PTR_NULL;
167 }
168 TELEPHONY_LOGI("CoreService::SetNetworkSelectionMode selectMode:%{public}d", selectMode);
169 return networkSearchManager_->SetNetworkSelectionMode(
170 slotId, selectMode, networkInformation, resumeSelection, callback);
171 }
172
GetSignalInfoList(int32_t slotId,std::vector<sptr<SignalInformation>> & signals)173 int32_t CoreService::GetSignalInfoList(int32_t slotId, std::vector<sptr<SignalInformation>> &signals)
174 {
175 if (networkSearchManager_ == nullptr) {
176 TELEPHONY_LOGE("networkSearchManager_ is null");
177 return TELEPHONY_ERR_LOCAL_PTR_NULL;
178 }
179 return networkSearchManager_->GetSignalInfoList(slotId, signals);
180 }
181
GetOperatorNumeric(int32_t slotId)182 std::u16string CoreService::GetOperatorNumeric(int32_t slotId)
183 {
184 if (networkSearchManager_ == nullptr) {
185 TELEPHONY_LOGE("networkSearchManager_ is null");
186 return std::u16string();
187 }
188 return networkSearchManager_->GetOperatorNumeric(slotId);
189 }
190
GetOperatorName(int32_t slotId,std::u16string & operatorName)191 int32_t CoreService::GetOperatorName(int32_t slotId, std::u16string &operatorName)
192 {
193 if (networkSearchManager_ == nullptr) {
194 TELEPHONY_LOGE("networkSearchManager_ is null");
195 return TELEPHONY_ERR_LOCAL_PTR_NULL;
196 }
197 return networkSearchManager_->GetOperatorName(slotId, operatorName);
198 }
199
GetNetworkState(int32_t slotId,sptr<NetworkState> & networkState)200 int32_t CoreService::GetNetworkState(int32_t slotId, sptr<NetworkState> &networkState)
201 {
202 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
203 TELEPHONY_LOGE("permission denied!");
204 return TELEPHONY_ERR_PERMISSION_ERR;
205 }
206 if (networkSearchManager_ == nullptr) {
207 TELEPHONY_LOGE("networkSearchManager_ is null");
208 return TELEPHONY_ERR_LOCAL_PTR_NULL;
209 }
210 return networkSearchManager_->GetNetworkStatus(slotId, networkState);
211 }
212
SetRadioState(int32_t slotId,bool isOn,const sptr<INetworkSearchCallback> & callback)213 int32_t CoreService::SetRadioState(int32_t slotId, bool isOn, const sptr<INetworkSearchCallback> &callback)
214 {
215 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
216 TELEPHONY_LOGE("Non-system applications use system APIs!");
217 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
218 }
219 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
220 TELEPHONY_LOGE("permission denied!");
221 return TELEPHONY_ERR_PERMISSION_ERR;
222 }
223 if (networkSearchManager_ == nullptr) {
224 TELEPHONY_LOGE("networkSearchManager_ is null");
225 return TELEPHONY_ERR_LOCAL_PTR_NULL;
226 }
227 TELEPHONY_LOGI("CoreService::SetRadioState --> slotId:%{public}d, isOn:%{public}d", slotId, isOn);
228 return networkSearchManager_->SetRadioState(slotId, isOn, 0, callback);
229 }
230
GetRadioState(int32_t slotId,const sptr<INetworkSearchCallback> & callback)231 int32_t CoreService::GetRadioState(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
232 {
233 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
234 TELEPHONY_LOGE("permission denied!");
235 return TELEPHONY_ERR_PERMISSION_ERR;
236 }
237 if (networkSearchManager_ == nullptr) {
238 TELEPHONY_LOGE("networkSearchManager_ is null");
239 return TELEPHONY_ERR_LOCAL_PTR_NULL;
240 }
241 return networkSearchManager_->GetRadioState(slotId, callback);
242 }
243
GetIsoCountryCodeForNetwork(int32_t slotId,std::u16string & countryCode)244 int32_t CoreService::GetIsoCountryCodeForNetwork(int32_t slotId, std::u16string &countryCode)
245 {
246 if (networkSearchManager_ == nullptr) {
247 TELEPHONY_LOGE("networkSearchManager_ is null");
248 return TELEPHONY_ERR_LOCAL_PTR_NULL;
249 }
250 return networkSearchManager_->GetIsoCountryCodeForNetwork(slotId, countryCode);
251 }
252
GetImei(int32_t slotId,std::u16string & imei)253 int32_t CoreService::GetImei(int32_t slotId, std::u16string &imei)
254 {
255 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
256 TELEPHONY_LOGE("Non-system applications use system APIs!");
257 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
258 }
259 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
260 TELEPHONY_LOGE("permission denied!");
261 return TELEPHONY_ERR_PERMISSION_ERR;
262 }
263 if (networkSearchManager_ == nullptr) {
264 TELEPHONY_LOGE("networkSearchManager_ is null");
265 return TELEPHONY_ERR_LOCAL_PTR_NULL;
266 }
267 return networkSearchManager_->GetImei(slotId, imei);
268 }
269
GetMeid(int32_t slotId,std::u16string & meid)270 int32_t CoreService::GetMeid(int32_t slotId, std::u16string &meid)
271 {
272 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
273 TELEPHONY_LOGE("Non-system applications use system APIs!");
274 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
275 }
276 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
277 TELEPHONY_LOGE("permission denied!");
278 return TELEPHONY_ERR_PERMISSION_ERR;
279 }
280 if (networkSearchManager_ == nullptr) {
281 TELEPHONY_LOGE("networkSearchManager_ is null");
282 return TELEPHONY_ERR_LOCAL_PTR_NULL;
283 }
284 return networkSearchManager_->GetMeid(slotId, meid);
285 }
286
GetUniqueDeviceId(int32_t slotId,std::u16string & deviceId)287 int32_t CoreService::GetUniqueDeviceId(int32_t slotId, std::u16string &deviceId)
288 {
289 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
290 TELEPHONY_LOGE("Non-system applications use system APIs!");
291 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
292 }
293 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
294 TELEPHONY_LOGE("permission denied!");
295 return TELEPHONY_ERR_PERMISSION_ERR;
296 }
297 if (networkSearchManager_ == nullptr) {
298 TELEPHONY_LOGE("networkSearchManager_ is null");
299 return TELEPHONY_ERR_LOCAL_PTR_NULL;
300 }
301 return networkSearchManager_->GetUniqueDeviceId(slotId, deviceId);
302 }
303
IsNrSupported(int32_t slotId)304 bool CoreService::IsNrSupported(int32_t slotId)
305 {
306 if (networkSearchManager_ == nullptr) {
307 TELEPHONY_LOGE("networkSearchManager_ is null");
308 return false;
309 }
310 return networkSearchManager_->IsNrSupported(slotId);
311 }
312
SetNrOptionMode(int32_t slotId,int32_t mode,const sptr<INetworkSearchCallback> & callback)313 int32_t CoreService::SetNrOptionMode(int32_t slotId, int32_t mode, const sptr<INetworkSearchCallback> &callback)
314 {
315 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
316 TELEPHONY_LOGE("Non-system applications use system APIs!");
317 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
318 }
319 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
320 TELEPHONY_LOGE("permission denied!");
321 return TELEPHONY_ERR_PERMISSION_ERR;
322 }
323 if (networkSearchManager_ == nullptr) {
324 TELEPHONY_LOGE("networkSearchManager_ is null");
325 return TELEPHONY_ERR_LOCAL_PTR_NULL;
326 }
327 return networkSearchManager_->SetNrOptionMode(slotId, mode, callback);
328 }
329
GetNrOptionMode(int32_t slotId,const sptr<INetworkSearchCallback> & callback)330 int32_t CoreService::GetNrOptionMode(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
331 {
332 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
333 TELEPHONY_LOGE("Non-system applications use system APIs!");
334 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
335 }
336 if (networkSearchManager_ == nullptr) {
337 TELEPHONY_LOGE("networkSearchManager_ is null");
338 return TELEPHONY_ERR_LOCAL_PTR_NULL;
339 }
340 return networkSearchManager_->GetNrOptionMode(slotId, callback);
341 }
342
HasSimCard(int32_t slotId,bool & hasSimCard)343 int32_t CoreService::HasSimCard(int32_t slotId, bool &hasSimCard)
344 {
345 TELEPHONY_LOGD("CoreService::HasSimCard(), slotId = %{public}d", slotId);
346 if (simManager_ == nullptr) {
347 TELEPHONY_LOGE("simManager_ is null");
348 return TELEPHONY_ERR_LOCAL_PTR_NULL;
349 }
350 return simManager_->HasSimCard(slotId, hasSimCard);
351 }
352
GetSimState(int32_t slotId,SimState & simState)353 int32_t CoreService::GetSimState(int32_t slotId, SimState &simState)
354 {
355 TELEPHONY_LOGD("CoreService::GetSimState(), slotId = %{public}d", slotId);
356 if (simManager_ == nullptr) {
357 TELEPHONY_LOGE("simManager_ is null");
358 return TELEPHONY_ERR_LOCAL_PTR_NULL;
359 }
360
361 return simManager_->GetSimState(slotId, simState);
362 }
363
GetDsdsMode(int32_t & dsdsMode)364 int32_t CoreService::GetDsdsMode(int32_t &dsdsMode)
365 {
366 TELEPHONY_LOGI("CoreService::GetDsdsMode()");
367 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
368 TELEPHONY_LOGE("Non-system applications use system APIs!");
369 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
370 }
371 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
372 TELEPHONY_LOGE("permission denied!");
373 return TELEPHONY_ERR_PERMISSION_ERR;
374 }
375 if (simManager_ == nullptr) {
376 TELEPHONY_LOGE("simManager_ is null");
377 return TELEPHONY_ERR_LOCAL_PTR_NULL;
378 }
379
380 return simManager_->GetDsdsMode(dsdsMode);
381 }
382
GetCardType(int32_t slotId,CardType & cardType)383 int32_t CoreService::GetCardType(int32_t slotId, CardType &cardType)
384 {
385 TELEPHONY_LOGD("CoreService::GetCardType(), slotId = %{public}d", slotId);
386 if (simManager_ == nullptr) {
387 TELEPHONY_LOGE("simManager_ is null");
388 return TELEPHONY_ERR_LOCAL_PTR_NULL;
389 }
390
391 return simManager_->GetCardType(slotId, cardType);
392 }
393
GetISOCountryCodeForSim(int32_t slotId,std::u16string & countryCode)394 int32_t CoreService::GetISOCountryCodeForSim(int32_t slotId, std::u16string &countryCode)
395 {
396 TELEPHONY_LOGD("CoreService::GetISOCountryCodeForSim(), slotId = %{public}d", slotId);
397 if (simManager_ == nullptr) {
398 TELEPHONY_LOGE("simManager_ is null");
399 return TELEPHONY_ERR_LOCAL_PTR_NULL;
400 }
401
402 return simManager_->GetISOCountryCodeForSim(slotId, countryCode);
403 }
404
GetSimSpn(int32_t slotId,std::u16string & spn)405 int32_t CoreService::GetSimSpn(int32_t slotId, std::u16string &spn)
406 {
407 TELEPHONY_LOGD("CoreService::GetSimSpn(), slotId = %{public}d", slotId);
408 if (simManager_ == nullptr) {
409 TELEPHONY_LOGE("simManager_ is null");
410 return TELEPHONY_ERR_LOCAL_PTR_NULL;
411 }
412 return simManager_->GetSimSpn(slotId, spn);
413 }
414
GetSimIccId(int32_t slotId,std::u16string & iccId)415 int32_t CoreService::GetSimIccId(int32_t slotId, std::u16string &iccId)
416 {
417 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
418 TELEPHONY_LOGE("Non-system applications use system APIs!");
419 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
420 }
421 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
422 TELEPHONY_LOGE("permission denied!");
423 return TELEPHONY_ERR_PERMISSION_ERR;
424 }
425 TELEPHONY_LOGD("CoreService::GetSimIccId(), slotId = %{public}d", slotId);
426 if (simManager_ == nullptr) {
427 TELEPHONY_LOGE("simManager_ is null");
428 return TELEPHONY_ERR_LOCAL_PTR_NULL;
429 }
430 return simManager_->GetSimIccId(slotId, iccId);
431 }
432
GetSimOperatorNumeric(int32_t slotId,std::u16string & operatorNumeric)433 int32_t CoreService::GetSimOperatorNumeric(int32_t slotId, std::u16string &operatorNumeric)
434 {
435 TELEPHONY_LOGD("CoreService::GetSimOperatorNumeric(), slotId = %{public}d", slotId);
436 if (simManager_ == nullptr) {
437 TELEPHONY_LOGE("simManager_ is null");
438 return TELEPHONY_ERR_LOCAL_PTR_NULL;
439 }
440 return simManager_->GetSimOperatorNumeric(slotId, operatorNumeric);
441 }
442
GetIMSI(int32_t slotId,std::u16string & imsi)443 int32_t CoreService::GetIMSI(int32_t slotId, std::u16string &imsi)
444 {
445 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
446 TELEPHONY_LOGE("Non-system applications use system APIs!");
447 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
448 }
449 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
450 TELEPHONY_LOGE("permission denied!");
451 return TELEPHONY_ERR_PERMISSION_ERR;
452 }
453 TELEPHONY_LOGD("CoreService::GetIMSI(), slotId = %{public}d", slotId);
454 if (simManager_ == nullptr) {
455 TELEPHONY_LOGE("simManager_ is null");
456 return TELEPHONY_ERR_LOCAL_PTR_NULL;
457 }
458 return simManager_->GetIMSI(slotId, imsi);
459 }
460
IsCTSimCard(int32_t slotId,bool & isCTSimCard)461 int32_t CoreService::IsCTSimCard(int32_t slotId, bool &isCTSimCard)
462 {
463 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
464 TELEPHONY_LOGE("Non-system applications use system APIs!");
465 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
466 }
467 TELEPHONY_LOGD("CoreService::IsCTSimCard(), slotId = %{public}d", slotId);
468 if (simManager_ == nullptr) {
469 TELEPHONY_LOGE("simManager_ is null");
470 return TELEPHONY_ERR_LOCAL_PTR_NULL;
471 }
472 return simManager_->IsCTSimCard(slotId, isCTSimCard);
473 }
474
IsSimActive(int32_t slotId)475 bool CoreService::IsSimActive(int32_t slotId)
476 {
477 TELEPHONY_LOGD("CoreService::IsSimActive(), slotId = %{public}d", slotId);
478 if (simManager_ == nullptr) {
479 TELEPHONY_LOGE("simManager_ is null");
480 return false;
481 }
482 return simManager_->IsSimActive(slotId);
483 }
484
GetSlotId(int32_t simId)485 int32_t CoreService::GetSlotId(int32_t simId)
486 {
487 TELEPHONY_LOGD("CoreService::GetSlotId(), simId = %{public}d", simId);
488 if (simManager_ == nullptr) {
489 TELEPHONY_LOGE("CoreService::GetSlotId(), simManager_ is nullptr!");
490 return TELEPHONY_ERR_LOCAL_PTR_NULL;
491 }
492 return simManager_->GetSlotId(simId);
493 }
494
GetSimId(int32_t slotId)495 int32_t CoreService::GetSimId(int32_t slotId)
496 {
497 TELEPHONY_LOGD("CoreService::GetSimId(), slotId = %{public}d", slotId);
498 if (simManager_ == nullptr) {
499 TELEPHONY_LOGE("CoreService::GetSimId(), simManager_ is nullptr!");
500 return TELEPHONY_ERROR;
501 }
502 return simManager_->GetSimId(slotId);
503 }
504
GetNetworkSearchInformation(int32_t slotId,const sptr<INetworkSearchCallback> & callback)505 int32_t CoreService::GetNetworkSearchInformation(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
506 {
507 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
508 TELEPHONY_LOGE("Non-system applications use system APIs!");
509 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
510 }
511 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
512 TELEPHONY_LOGE("permission denied!");
513 return TELEPHONY_ERR_PERMISSION_ERR;
514 }
515 if (networkSearchManager_ == nullptr) {
516 TELEPHONY_LOGE("networkSearchManager_ is null");
517 return TELEPHONY_ERR_LOCAL_PTR_NULL;
518 }
519 return networkSearchManager_->GetNetworkSearchInformation(slotId, callback);
520 }
521
GetNetworkSelectionMode(int32_t slotId,const sptr<INetworkSearchCallback> & callback)522 int32_t CoreService::GetNetworkSelectionMode(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
523 {
524 if (networkSearchManager_ == nullptr) {
525 TELEPHONY_LOGE("networkSearchManager_ is null");
526 return TELEPHONY_ERR_LOCAL_PTR_NULL;
527 }
528 return networkSearchManager_->GetNetworkSelectionMode(slotId, callback);
529 }
530
GetLocaleFromDefaultSim()531 std::u16string CoreService::GetLocaleFromDefaultSim()
532 {
533 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
534 TELEPHONY_LOGE("CoreService::GetLocaleFromDefaultSim, Permission denied!");
535 return std::u16string();
536 }
537 TELEPHONY_LOGD("CoreService::GetLocaleFromDefaultSim()");
538 if (simManager_ == nullptr) {
539 TELEPHONY_LOGE("simManager_ is null");
540 return std::u16string();
541 }
542 int32_t slotId = INVALID_VALUE;
543 simManager_->GetPrimarySlotId(slotId);
544 if (slotId < DEFAULT_SIM_SLOT_ID) {
545 slotId = DEFAULT_SIM_SLOT_ID;
546 }
547 return simManager_->GetLocaleFromDefaultSim(slotId);
548 }
549
GetSimGid1(int32_t slotId,std::u16string & gid1)550 int32_t CoreService::GetSimGid1(int32_t slotId, std::u16string &gid1)
551 {
552 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
553 TELEPHONY_LOGE("Non-system applications use system APIs!");
554 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
555 }
556 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
557 TELEPHONY_LOGE("CoreService::GetSimGid1, Permission denied!");
558 return TELEPHONY_ERR_PERMISSION_ERR;
559 }
560 TELEPHONY_LOGD("CoreService::GetSimGid1(), slotId = %{public}d", slotId);
561 if (simManager_ == nullptr) {
562 TELEPHONY_LOGE("simManager_ is null");
563 return TELEPHONY_ERR_LOCAL_PTR_NULL;
564 }
565 return simManager_->GetSimGid1(slotId, gid1);
566 }
567
GetSimGid2(int32_t slotId)568 std::u16string CoreService::GetSimGid2(int32_t slotId)
569 {
570 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
571 TELEPHONY_LOGE("CoreService::GetSimGid2, Permission denied!");
572 return std::u16string();
573 }
574 TELEPHONY_LOGD("CoreService::GetSimGid2(), slotId = %{public}d", slotId);
575 if (simManager_ == nullptr) {
576 TELEPHONY_LOGE("simManager_ is null");
577 return std::u16string();
578 }
579 return simManager_->GetSimGid2(slotId);
580 }
581
GetSimEons(int32_t slotId,const std::string & plmn,int32_t lac,bool longNameRequired)582 std::u16string CoreService::GetSimEons(int32_t slotId, const std::string &plmn, int32_t lac, bool longNameRequired)
583 {
584 TELEPHONY_LOGD("CoreService::GetSimEons(), slotId = %{public}d", slotId);
585 if (simManager_ == nullptr) {
586 TELEPHONY_LOGE("CoreService::GetSimEons, Permission denied!");
587 return std::u16string();
588 }
589 return simManager_->GetSimEons(slotId, plmn, lac, longNameRequired);
590 }
591
GetSimAccountInfo(int32_t slotId,IccAccountInfo & info)592 int32_t CoreService::GetSimAccountInfo(int32_t slotId, IccAccountInfo &info)
593 {
594 bool denied = false;
595 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
596 TELEPHONY_LOGE("permission denied!");
597 denied = true;
598 }
599 TELEPHONY_LOGD("CoreService::GetSimAccountInfo(), slotId = %{public}d", slotId);
600 if (simManager_ == nullptr) {
601 TELEPHONY_LOGE("simManager_ is null");
602 return TELEPHONY_ERR_LOCAL_PTR_NULL;
603 }
604 return simManager_->GetSimAccountInfo(slotId, denied, info);
605 }
606
SetDefaultVoiceSlotId(int32_t slotId)607 int32_t CoreService::SetDefaultVoiceSlotId(int32_t slotId)
608 {
609 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
610 TELEPHONY_LOGE("Non-system applications use system APIs!");
611 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
612 }
613 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
614 TELEPHONY_LOGE("permission denied!");
615 return TELEPHONY_ERR_PERMISSION_ERR;
616 }
617 TELEPHONY_LOGD("CoreService::SetDefaultVoiceSlotId(), slotId = %{public}d", slotId);
618 if (simManager_ == nullptr) {
619 TELEPHONY_LOGE("simManager_ is null");
620 return TELEPHONY_ERR_LOCAL_PTR_NULL;
621 }
622 return simManager_->SetDefaultVoiceSlotId(slotId);
623 }
624
GetDefaultVoiceSlotId()625 int32_t CoreService::GetDefaultVoiceSlotId()
626 {
627 TELEPHONY_LOGD("CoreService::GetDefaultVoiceSlotId()");
628 if (simManager_ == nullptr) {
629 TELEPHONY_LOGE("simManager_ is null");
630 return TELEPHONY_ERROR;
631 }
632 return simManager_->GetDefaultVoiceSlotId();
633 }
634
GetDefaultVoiceSimId(int32_t & simId)635 int32_t CoreService::GetDefaultVoiceSimId(int32_t &simId)
636 {
637 TELEPHONY_LOGD("start");
638 if (simManager_ == nullptr) {
639 TELEPHONY_LOGE("simManager_ is null");
640 return TELEPHONY_ERR_LOCAL_PTR_NULL;
641 }
642 return simManager_->GetDefaultVoiceSimId(simId);
643 }
644
SetPrimarySlotId(int32_t slotId)645 int32_t CoreService::SetPrimarySlotId(int32_t slotId)
646 {
647 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
648 TELEPHONY_LOGE("Non-system applications use system APIs!");
649 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
650 }
651 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
652 TELEPHONY_LOGE("permission denied!");
653 return TELEPHONY_ERR_PERMISSION_ERR;
654 }
655 TELEPHONY_LOGD("CoreService::SetPrimarySlotId(), slotId = %{public}d", slotId);
656 if (simManager_ == nullptr) {
657 TELEPHONY_LOGE("simManager_ is null");
658 return TELEPHONY_ERR_LOCAL_PTR_NULL;
659 }
660 bool hasSim = false;
661 simManager_->HasSimCard(slotId, hasSim);
662 if (!hasSim) {
663 TELEPHONY_LOGE("has no sim");
664 return TELEPHONY_ERR_NO_SIM_CARD;
665 }
666 if (!simManager_->IsSimActive(slotId)) {
667 TELEPHONY_LOGE("sim is not active");
668 return TELEPHONY_ERR_SLOTID_INVALID;
669 }
670 return simManager_->SetPrimarySlotId(slotId);
671 }
672
GetPrimarySlotId(int32_t & slotId)673 int32_t CoreService::GetPrimarySlotId(int32_t &slotId)
674 {
675 TELEPHONY_LOGD("CoreService::GetPrimarySlotId()");
676 if (simManager_ == nullptr) {
677 TELEPHONY_LOGE("simManager_ is null");
678 return TELEPHONY_ERR_LOCAL_PTR_NULL;
679 }
680 return simManager_->GetPrimarySlotId(slotId);
681 }
682
SetShowNumber(int32_t slotId,const std::u16string & number)683 int32_t CoreService::SetShowNumber(int32_t slotId, const std::u16string &number)
684 {
685 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
686 TELEPHONY_LOGE("Non-system applications use system APIs!");
687 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
688 }
689 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
690 TELEPHONY_LOGE("permission denied!");
691 return TELEPHONY_ERR_PERMISSION_ERR;
692 }
693 TELEPHONY_LOGD("CoreService::SetShowNumber(), slotId = %{public}d", slotId);
694 if (simManager_ == nullptr) {
695 TELEPHONY_LOGE("simManager_ is null");
696 return TELEPHONY_ERR_LOCAL_PTR_NULL;
697 }
698 return simManager_->SetShowNumber(slotId, number);
699 }
700
GetShowNumber(int32_t slotId,std::u16string & showNumber)701 int32_t CoreService::GetShowNumber(int32_t slotId, std::u16string &showNumber)
702 {
703 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
704 TELEPHONY_LOGE("Non-system applications use system APIs!");
705 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
706 }
707 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
708 TELEPHONY_LOGE("permission denied!");
709 return TELEPHONY_ERR_PERMISSION_ERR;
710 }
711 TELEPHONY_LOGD("CoreService::GetShowNumber(), slotId = %{public}d", slotId);
712 if (simManager_ == nullptr) {
713 TELEPHONY_LOGE("simManager_ is null");
714 return TELEPHONY_ERR_LOCAL_PTR_NULL;
715 }
716 return simManager_->GetShowNumber(slotId, showNumber);
717 }
718
SetShowName(int32_t slotId,const std::u16string & name)719 int32_t CoreService::SetShowName(int32_t slotId, const std::u16string &name)
720 {
721 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
722 TELEPHONY_LOGE("Non-system applications use system APIs!");
723 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
724 }
725 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
726 TELEPHONY_LOGE("permission denied!");
727 return TELEPHONY_ERR_PERMISSION_ERR;
728 }
729 TELEPHONY_LOGD("CoreService::SetShowName(), slotId = %{public}d", slotId);
730 if (simManager_ == nullptr) {
731 TELEPHONY_LOGE("simManager_ is null");
732 return TELEPHONY_ERR_LOCAL_PTR_NULL;
733 }
734 return simManager_->SetShowName(slotId, name);
735 }
736
GetShowName(int32_t slotId,std::u16string & showName)737 int32_t CoreService::GetShowName(int32_t slotId, std::u16string &showName)
738 {
739 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
740 TELEPHONY_LOGE("Non-system applications use system APIs!");
741 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
742 }
743 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
744 TELEPHONY_LOGE("permission denied!");
745 return TELEPHONY_ERR_PERMISSION_ERR;
746 }
747 TELEPHONY_LOGD("CoreService::GetShowName(), slotId = %{public}d", slotId);
748 if (simManager_ == nullptr) {
749 TELEPHONY_LOGE("simManager_ is null");
750 return TELEPHONY_ERR_LOCAL_PTR_NULL;
751 }
752 return simManager_->GetShowName(slotId, showName);
753 }
754
GetActiveSimAccountInfoList(std::vector<IccAccountInfo> & iccAccountInfoList)755 int32_t CoreService::GetActiveSimAccountInfoList(std::vector<IccAccountInfo> &iccAccountInfoList)
756 {
757 bool denied = false;
758 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
759 TELEPHONY_LOGE("permission denied!");
760 denied = true;
761 }
762 TELEPHONY_LOGD("CoreService::GetActiveSimAccountInfoList");
763 if (simManager_ == nullptr) {
764 TELEPHONY_LOGE("simManager_ is null");
765 return TELEPHONY_ERR_LOCAL_PTR_NULL;
766 }
767 return simManager_->GetActiveSimAccountInfoList(denied, iccAccountInfoList);
768 }
769
GetOperatorConfigs(int32_t slotId,OperatorConfig & poc)770 int32_t CoreService::GetOperatorConfigs(int32_t slotId, OperatorConfig &poc)
771 {
772 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
773 TELEPHONY_LOGE("Non-system applications use system APIs!");
774 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
775 }
776 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
777 TELEPHONY_LOGE("permission denied!");
778 return TELEPHONY_ERR_PERMISSION_ERR;
779 }
780 TELEPHONY_LOGD("CoreService::GetOperatorConfigs");
781 if (simManager_ == nullptr) {
782 TELEPHONY_LOGE("simManager_ is null");
783 return TELEPHONY_ERR_LOCAL_PTR_NULL;
784 }
785 return simManager_->GetOperatorConfigs(slotId, poc);
786 }
787
UnlockPin(const int32_t slotId,const std::u16string & pin,LockStatusResponse & response)788 int32_t CoreService::UnlockPin(const int32_t slotId, const std::u16string &pin, LockStatusResponse &response)
789 {
790 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
791 TELEPHONY_LOGE("Non-system applications use system APIs!");
792 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
793 }
794 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
795 TELEPHONY_LOGE("permission denied!");
796 return TELEPHONY_ERR_PERMISSION_ERR;
797 }
798 TELEPHONY_LOGD("CoreService::UnlockPin(), pinLen = %{public}lu, slotId = %{public}d",
799 static_cast<unsigned long>(pin.length()), slotId);
800 if (simManager_ == nullptr) {
801 TELEPHONY_LOGE("simManager_ is null");
802 return TELEPHONY_ERR_LOCAL_PTR_NULL;
803 }
804 return simManager_->UnlockPin(slotId, Str16ToStr8(pin), response);
805 }
806
UnlockPuk(const int slotId,const std::u16string & newPin,const std::u16string & puk,LockStatusResponse & response)807 int32_t CoreService::UnlockPuk(
808 const int slotId, const std::u16string &newPin, const std::u16string &puk, LockStatusResponse &response)
809 {
810 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
811 TELEPHONY_LOGE("Non-system applications use system APIs!");
812 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
813 }
814 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
815 TELEPHONY_LOGE("permission denied!");
816 return TELEPHONY_ERR_PERMISSION_ERR;
817 }
818 TELEPHONY_LOGI("CoreService::UnlockPuk(), newPinLen = %{public}lu, pukLen = %{public}lu, slotId = %{public}d",
819 static_cast<unsigned long>(newPin.length()), static_cast<unsigned long>(puk.length()), slotId);
820 if (simManager_ == nullptr) {
821 TELEPHONY_LOGE("simManager_ is null");
822 return TELEPHONY_ERR_LOCAL_PTR_NULL;
823 }
824 return simManager_->UnlockPuk(slotId, Str16ToStr8(newPin), Str16ToStr8(puk), response);
825 }
826
AlterPin(const int slotId,const std::u16string & newPin,const std::u16string & oldPin,LockStatusResponse & response)827 int32_t CoreService::AlterPin(
828 const int slotId, const std::u16string &newPin, const std::u16string &oldPin, LockStatusResponse &response)
829 {
830 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
831 TELEPHONY_LOGE("Non-system applications use system APIs!");
832 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
833 }
834 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
835 TELEPHONY_LOGE("permission denied!");
836 return TELEPHONY_ERR_PERMISSION_ERR;
837 }
838 TELEPHONY_LOGI("CoreService::AlterPin(), newPinLen = %{public}lu, oldPinLen = %{public}lu, slotId = %{public}d",
839 static_cast<unsigned long>(newPin.length()), static_cast<unsigned long>(oldPin.length()), slotId);
840 if (simManager_ == nullptr) {
841 TELEPHONY_LOGE("simManager_ is null");
842 return TELEPHONY_ERR_LOCAL_PTR_NULL;
843 }
844 return simManager_->AlterPin(slotId, Str16ToStr8(newPin), Str16ToStr8(oldPin), response);
845 }
846
UnlockPin2(const int32_t slotId,const std::u16string & pin2,LockStatusResponse & response)847 int32_t CoreService::UnlockPin2(const int32_t slotId, const std::u16string &pin2, LockStatusResponse &response)
848 {
849 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
850 TELEPHONY_LOGE("Non-system applications use system APIs!");
851 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
852 }
853 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
854 TELEPHONY_LOGE("permission denied!");
855 return TELEPHONY_ERR_PERMISSION_ERR;
856 }
857 TELEPHONY_LOGI("CoreService::UnlockPin2(), pin2Len = %{public}lu, slotId = %{public}d",
858 static_cast<unsigned long>(pin2.length()), slotId);
859 if (simManager_ == nullptr) {
860 TELEPHONY_LOGE("simManager_ is null");
861 return TELEPHONY_ERR_LOCAL_PTR_NULL;
862 }
863 return simManager_->UnlockPin2(slotId, Str16ToStr8(pin2), response);
864 }
865
UnlockPuk2(const int slotId,const std::u16string & newPin2,const std::u16string & puk2,LockStatusResponse & response)866 int32_t CoreService::UnlockPuk2(
867 const int slotId, const std::u16string &newPin2, const std::u16string &puk2, LockStatusResponse &response)
868 {
869 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
870 TELEPHONY_LOGE("Non-system applications use system APIs!");
871 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
872 }
873 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
874 TELEPHONY_LOGE("permission denied!");
875 return TELEPHONY_ERR_PERMISSION_ERR;
876 }
877 TELEPHONY_LOGI("CoreService::UnlockPuk2(), newPin2Len = %{public}lu, puk2Len = %{public}lu, slotId = %{public}d",
878 static_cast<unsigned long>(newPin2.length()), static_cast<unsigned long>(puk2.length()), slotId);
879 if (simManager_ == nullptr) {
880 TELEPHONY_LOGE("simManager_ is null");
881 return TELEPHONY_ERR_LOCAL_PTR_NULL;
882 }
883 return simManager_->UnlockPuk2(slotId, Str16ToStr8(newPin2), Str16ToStr8(puk2), response);
884 }
885
AlterPin2(const int slotId,const std::u16string & newPin2,const std::u16string & oldPin2,LockStatusResponse & response)886 int32_t CoreService::AlterPin2(
887 const int slotId, const std::u16string &newPin2, const std::u16string &oldPin2, LockStatusResponse &response)
888 {
889 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
890 TELEPHONY_LOGE("Non-system applications use system APIs!");
891 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
892 }
893 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
894 TELEPHONY_LOGE("permission denied!");
895 return TELEPHONY_ERR_PERMISSION_ERR;
896 }
897 TELEPHONY_LOGI("CoreService::AlterPin2(), newPin2Len = %{public}lu, oldPin2Len = %{public}lu, slotId = %{public}d",
898 static_cast<unsigned long>(newPin2.length()), static_cast<unsigned long>(oldPin2.length()), slotId);
899 if (simManager_ == nullptr) {
900 TELEPHONY_LOGE("simManager_ is null");
901 return TELEPHONY_ERR_LOCAL_PTR_NULL;
902 }
903 return simManager_->AlterPin2(slotId, Str16ToStr8(newPin2), Str16ToStr8(oldPin2), response);
904 }
905
SetLockState(int32_t slotId,const LockInfo & options,LockStatusResponse & response)906 int32_t CoreService::SetLockState(int32_t slotId, const LockInfo &options, LockStatusResponse &response)
907 {
908 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
909 TELEPHONY_LOGE("Non-system applications use system APIs!");
910 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
911 }
912 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
913 TELEPHONY_LOGE("permission denied!");
914 return TELEPHONY_ERR_PERMISSION_ERR;
915 }
916 std::u16string strPin = options.password;
917 TELEPHONY_LOGI(
918 "CoreService::SetLockState(),lockType = %{public}d, pinLen = %{public}lu, lockState = %{public}d, slotId "
919 "= "
920 "%{public}d",
921 options.lockType, static_cast<unsigned long>(strPin.length()), options.lockState, slotId);
922 if (simManager_ == nullptr) {
923 TELEPHONY_LOGE("simManager_ is null");
924 return TELEPHONY_ERR_LOCAL_PTR_NULL;
925 }
926 return simManager_->SetLockState(slotId, options, response);
927 }
928
GetLockState(int32_t slotId,LockType lockType,LockState & lockState)929 int32_t CoreService::GetLockState(int32_t slotId, LockType lockType, LockState &lockState)
930 {
931 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
932 TELEPHONY_LOGE("Non-system applications use system APIs!");
933 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
934 }
935 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
936 TELEPHONY_LOGE("CoreService::GetLockState, Permission denied!");
937 return TELEPHONY_ERR_PERMISSION_ERR;
938 }
939 TELEPHONY_LOGI("CoreService::GetLockState(), lockType = %{public}d, slotId = %{public}d", lockType, slotId);
940 if (simManager_ == nullptr) {
941 TELEPHONY_LOGE("simManager_ is null");
942 return TELEPHONY_ERR_LOCAL_PTR_NULL;
943 }
944 return simManager_->GetLockState(slotId, lockType, lockState);
945 }
946
RefreshSimState(int32_t slotId)947 int32_t CoreService::RefreshSimState(int32_t slotId)
948 {
949 TELEPHONY_LOGD("CoreService::RefreshSimState(), slotId = %{public}d", slotId);
950 if (simManager_ == nullptr) {
951 TELEPHONY_LOGE("simManager_ is null");
952 return TELEPHONY_ERROR;
953 }
954 return simManager_->RefreshSimState(slotId);
955 }
956
SetActiveSim(int32_t slotId,int32_t enable)957 int32_t CoreService::SetActiveSim(int32_t slotId, int32_t enable)
958 {
959 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
960 TELEPHONY_LOGE("Non-system applications use system APIs!");
961 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
962 }
963 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
964 TELEPHONY_LOGE("permission denied!");
965 return TELEPHONY_ERR_PERMISSION_ERR;
966 }
967 TELEPHONY_LOGD("CoreService::SetActiveSim(), slotId = %{public}d", slotId);
968 if (simManager_ == nullptr) {
969 TELEPHONY_LOGE("simManager_ is null");
970 return TELEPHONY_ERR_LOCAL_PTR_NULL;
971 }
972 return simManager_->SetActiveSim(slotId, enable);
973 }
974
GetPreferredNetwork(int32_t slotId,const sptr<INetworkSearchCallback> & callback)975 int32_t CoreService::GetPreferredNetwork(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
976 {
977 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
978 TELEPHONY_LOGE("Non-system applications use system APIs!");
979 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
980 }
981 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
982 TELEPHONY_LOGE("permission denied!");
983 return TELEPHONY_ERR_PERMISSION_ERR;
984 }
985 if (networkSearchManager_ == nullptr) {
986 TELEPHONY_LOGE("networkSearchManager_ is null");
987 return TELEPHONY_ERR_LOCAL_PTR_NULL;
988 }
989 return networkSearchManager_->GetPreferredNetwork(slotId, callback);
990 }
991
SetPreferredNetwork(int32_t slotId,int32_t networkMode,const sptr<INetworkSearchCallback> & callback)992 int32_t CoreService::SetPreferredNetwork(
993 int32_t slotId, int32_t networkMode, const sptr<INetworkSearchCallback> &callback)
994 {
995 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
996 TELEPHONY_LOGE("Non-system applications use system APIs!");
997 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
998 }
999 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1000 TELEPHONY_LOGE("permission denied!");
1001 return TELEPHONY_ERR_PERMISSION_ERR;
1002 }
1003 if (networkSearchManager_ == nullptr) {
1004 TELEPHONY_LOGE("networkSearchManager_ is null");
1005 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1006 }
1007 return networkSearchManager_->SetPreferredNetwork(slotId, networkMode, callback);
1008 }
1009
GetNetworkCapability(int32_t slotId,int32_t networkCapabilityType,int32_t & networkCapabilityState)1010 int32_t CoreService::GetNetworkCapability(
1011 int32_t slotId, int32_t networkCapabilityType, int32_t &networkCapabilityState)
1012 {
1013 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1014 TELEPHONY_LOGE("Non-system applications use system APIs!");
1015 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1016 }
1017 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1018 TELEPHONY_LOGE("permission denied!");
1019 return TELEPHONY_ERR_PERMISSION_ERR;
1020 }
1021 if (networkSearchManager_ == nullptr) {
1022 TELEPHONY_LOGE("networkSearchManager_ is null");
1023 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1024 }
1025 return networkSearchManager_->GetNetworkCapability(slotId, networkCapabilityType, networkCapabilityState);
1026 }
1027
SetNetworkCapability(int32_t slotId,int32_t networkCapabilityType,int32_t networkCapabilityState)1028 int32_t CoreService::SetNetworkCapability(int32_t slotId, int32_t networkCapabilityType, int32_t networkCapabilityState)
1029 {
1030 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1031 TELEPHONY_LOGE("Non-system applications use system APIs!");
1032 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1033 }
1034 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1035 TELEPHONY_LOGE("permission denied!");
1036 return TELEPHONY_ERR_PERMISSION_ERR;
1037 }
1038 if (networkSearchManager_ == nullptr) {
1039 TELEPHONY_LOGE("networkSearchManager_ is null");
1040 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1041 }
1042 return networkSearchManager_->SetNetworkCapability(slotId, networkCapabilityType, networkCapabilityState);
1043 }
1044
GetSimTelephoneNumber(int32_t slotId,std::u16string & telephoneNumber)1045 int32_t CoreService::GetSimTelephoneNumber(int32_t slotId, std::u16string &telephoneNumber)
1046 {
1047 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1048 TELEPHONY_LOGE("Non-system applications use system APIs!");
1049 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1050 }
1051 if ((!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) &&
1052 (!TelephonyPermission::CheckPermission(Permission::GET_PHONE_NUMBERS))) {
1053 TELEPHONY_LOGE("permission denied!");
1054 return TELEPHONY_ERR_PERMISSION_ERR;
1055 }
1056 TELEPHONY_LOGD("CoreService::GetSimTelephoneNumber(), slotId = %{public}d", slotId);
1057 if (simManager_ == nullptr) {
1058 TELEPHONY_LOGE("simManager_ is null");
1059 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1060 }
1061 return simManager_->GetSimTelephoneNumber(slotId, telephoneNumber);
1062 }
1063
GetSimTeleNumberIdentifier(const int32_t slotId)1064 std::u16string CoreService::GetSimTeleNumberIdentifier(const int32_t slotId)
1065 {
1066 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1067 TELEPHONY_LOGE("CoreService::GetSimTeleNumberIdentifier, Permission denied!");
1068 return std::u16string();
1069 }
1070 TELEPHONY_LOGD("CoreService::GetSimTeleNumberIdentifier(), slotId = %{public}d", slotId);
1071 if (simManager_ == nullptr) {
1072 TELEPHONY_LOGE("simManager_ is null");
1073 return std::u16string();
1074 }
1075 return simManager_->GetSimTeleNumberIdentifier(slotId);
1076 }
1077
GetVoiceMailIdentifier(int32_t slotId,std::u16string & voiceMailIdentifier)1078 int32_t CoreService::GetVoiceMailIdentifier(int32_t slotId, std::u16string &voiceMailIdentifier)
1079 {
1080 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1081 TELEPHONY_LOGE("Non-system applications use system APIs!");
1082 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1083 }
1084 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1085 TELEPHONY_LOGE("permission denied!");
1086 return TELEPHONY_ERR_PERMISSION_ERR;
1087 }
1088 TELEPHONY_LOGD("CoreService::GetVoiceMailIdentifier(), slotId = %{public}d", slotId);
1089 if (simManager_ == nullptr) {
1090 TELEPHONY_LOGE("simManager_ is null");
1091 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1092 }
1093 return simManager_->GetVoiceMailIdentifier(slotId, voiceMailIdentifier);
1094 }
1095
GetVoiceMailNumber(int32_t slotId,std::u16string & voiceMailNumber)1096 int32_t CoreService::GetVoiceMailNumber(int32_t slotId, std::u16string &voiceMailNumber)
1097 {
1098 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1099 TELEPHONY_LOGE("Non-system applications use system APIs!");
1100 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1101 }
1102 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1103 TELEPHONY_LOGE("permission denied!");
1104 return TELEPHONY_ERR_PERMISSION_ERR;
1105 }
1106 TELEPHONY_LOGD("CoreService::GetVoiceMailNumber(), slotId = %{public}d", slotId);
1107 if (simManager_ == nullptr) {
1108 TELEPHONY_LOGE("simManager_ is null");
1109 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1110 }
1111 return simManager_->GetVoiceMailNumber(slotId, voiceMailNumber);
1112 }
1113
GetVoiceMailCount(int32_t slotId,int32_t & voiceMailCount)1114 int32_t CoreService::GetVoiceMailCount(int32_t slotId, int32_t &voiceMailCount)
1115 {
1116 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1117 TELEPHONY_LOGE("Non-system applications use system APIs!");
1118 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1119 }
1120 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1121 TELEPHONY_LOGE("permission denied!");
1122 return TELEPHONY_ERR_PERMISSION_ERR;
1123 }
1124 TELEPHONY_LOGI("CoreService::GetVoiceMailCount(), slotId = %{public}d", slotId);
1125 if (simManager_ == nullptr) {
1126 TELEPHONY_LOGE("simManager_ is null");
1127 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1128 }
1129 return simManager_->GetVoiceMailCount(slotId, voiceMailCount);
1130 }
1131
SetVoiceMailCount(int32_t slotId,int32_t voiceMailCount)1132 int32_t CoreService::SetVoiceMailCount(int32_t slotId, int32_t voiceMailCount)
1133 {
1134 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1135 TELEPHONY_LOGE("permission denied!");
1136 return TELEPHONY_ERR_PERMISSION_ERR;
1137 }
1138 TELEPHONY_LOGI("CoreService::SetVoiceMailCount(), slotId = %{public}d", slotId);
1139 if (simManager_ == nullptr) {
1140 TELEPHONY_LOGE("simManager_ is null");
1141 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1142 }
1143 return simManager_->SetVoiceMailCount(slotId, voiceMailCount);
1144 }
1145
SetVoiceCallForwarding(int32_t slotId,bool enable,const std::string & number)1146 int32_t CoreService::SetVoiceCallForwarding(int32_t slotId, bool enable, const std::string &number)
1147 {
1148 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1149 TELEPHONY_LOGE("permission denied!");
1150 return TELEPHONY_ERR_PERMISSION_ERR;
1151 }
1152 TELEPHONY_LOGI("CoreService::SetVoiceCallForwarding(), slotId = %{public}d", slotId);
1153 if (simManager_ == nullptr) {
1154 TELEPHONY_LOGE("simManager_ is null");
1155 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1156 }
1157 return simManager_->SetVoiceCallForwarding(slotId, enable, number);
1158 }
1159
QueryIccDiallingNumbers(int slotId,int type,std::vector<std::shared_ptr<DiallingNumbersInfo>> & reslut)1160 int32_t CoreService::QueryIccDiallingNumbers(
1161 int slotId, int type, std::vector<std::shared_ptr<DiallingNumbersInfo>> &reslut)
1162 {
1163 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1164 TELEPHONY_LOGE("Non-system applications use system APIs!");
1165 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1166 }
1167 if (!TelephonyPermission::CheckPermission(Permission::READ_CONTACTS)) {
1168 TELEPHONY_LOGE("permission denied!");
1169 return TELEPHONY_ERR_PERMISSION_ERR;
1170 }
1171 TELEPHONY_LOGD("CoreService::QueryIccDiallingNumbers");
1172 if (simManager_ == nullptr) {
1173 TELEPHONY_LOGE("simManager_ is null");
1174 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1175 }
1176 return simManager_->QueryIccDiallingNumbers(slotId, type, reslut);
1177 }
1178
AddIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)1179 int32_t CoreService::AddIccDiallingNumbers(
1180 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
1181 {
1182 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1183 TELEPHONY_LOGE("Non-system applications use system APIs!");
1184 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1185 }
1186 if (!TelephonyPermission::CheckPermission(Permission::WRITE_CONTACTS)) {
1187 TELEPHONY_LOGE("permission denied!");
1188 return TELEPHONY_ERR_PERMISSION_ERR;
1189 }
1190 TELEPHONY_LOGD("CoreService::AddIccDiallingNumbers");
1191 if (simManager_ == nullptr) {
1192 TELEPHONY_LOGE("simManager_ is null");
1193 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1194 }
1195 return simManager_->AddIccDiallingNumbers(slotId, type, diallingNumber);
1196 }
1197
DelIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)1198 int32_t CoreService::DelIccDiallingNumbers(
1199 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
1200 {
1201 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1202 TELEPHONY_LOGE("Non-system applications use system APIs!");
1203 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1204 }
1205 if (!TelephonyPermission::CheckPermission(Permission::WRITE_CONTACTS)) {
1206 TELEPHONY_LOGE("permission denied!");
1207 return TELEPHONY_ERR_PERMISSION_ERR;
1208 }
1209 TELEPHONY_LOGD("CoreService::DelIccDiallingNumbers");
1210 if (simManager_ == nullptr) {
1211 TELEPHONY_LOGE("simManager_ is null");
1212 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1213 }
1214 return simManager_->DelIccDiallingNumbers(slotId, type, diallingNumber);
1215 }
1216
UpdateIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)1217 int32_t CoreService::UpdateIccDiallingNumbers(
1218 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
1219 {
1220 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1221 TELEPHONY_LOGE("Non-system applications use system APIs!");
1222 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1223 }
1224 if (!TelephonyPermission::CheckPermission(Permission::WRITE_CONTACTS)) {
1225 TELEPHONY_LOGE("permission denied!");
1226 return TELEPHONY_ERR_PERMISSION_ERR;
1227 }
1228 TELEPHONY_LOGD("CoreService::UpdateIccDiallingNumbers");
1229 if (simManager_ == nullptr) {
1230 TELEPHONY_LOGE("simManager_ is null");
1231 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1232 }
1233 return simManager_->UpdateIccDiallingNumbers(slotId, type, diallingNumber);
1234 }
1235
SetVoiceMailInfo(const int32_t slotId,const std::u16string & mailName,const std::u16string & mailNumber)1236 int32_t CoreService::SetVoiceMailInfo(
1237 const int32_t slotId, const std::u16string &mailName, const std::u16string &mailNumber)
1238 {
1239 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1240 TELEPHONY_LOGE("Non-system applications use system APIs!");
1241 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1242 }
1243 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1244 TELEPHONY_LOGE("permission denied!");
1245 return TELEPHONY_ERR_PERMISSION_ERR;
1246 }
1247 TELEPHONY_LOGD("CoreService::SetVoiceMailInfo(), slotId = %{public}d", slotId);
1248 if (simManager_ == nullptr) {
1249 TELEPHONY_LOGE("simManager_ is null");
1250 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1251 }
1252 return simManager_->SetVoiceMailInfo(slotId, mailName, mailNumber);
1253 }
1254
GetMaxSimCount()1255 int32_t CoreService::GetMaxSimCount()
1256 {
1257 return SIM_SLOT_COUNT;
1258 }
1259
GetOpKey(int32_t slotId,std::u16string & opkey)1260 int32_t CoreService::GetOpKey(int32_t slotId, std::u16string &opkey)
1261 {
1262 TELEPHONY_LOGD("CoreService::GetOpKey(), slotId = %{public}d", slotId);
1263 if (simManager_ == nullptr) {
1264 TELEPHONY_LOGE("simManager_ is null");
1265 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1266 }
1267 return simManager_->GetOpKey(slotId, opkey);
1268 }
1269
GetOpKeyExt(int32_t slotId,std::u16string & opkeyExt)1270 int32_t CoreService::GetOpKeyExt(int32_t slotId, std::u16string &opkeyExt)
1271 {
1272 TELEPHONY_LOGD("CoreService::GetOpKeyExt(), slotId = %{public}d", slotId);
1273 if (simManager_ == nullptr) {
1274 TELEPHONY_LOGE("simManager_ is null");
1275 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1276 }
1277 return simManager_->GetOpKeyExt(slotId, opkeyExt);
1278 }
1279
GetOpName(int32_t slotId,std::u16string & opname)1280 int32_t CoreService::GetOpName(int32_t slotId, std::u16string &opname)
1281 {
1282 TELEPHONY_LOGD("CoreService::GetOpName(), slotId = %{public}d", slotId);
1283 if (simManager_ == nullptr) {
1284 TELEPHONY_LOGE("simManager_ is null");
1285 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1286 }
1287 return simManager_->GetOpName(slotId, opname);
1288 }
1289
SendEnvelopeCmd(int32_t slotId,const std::string & cmd)1290 int32_t CoreService::SendEnvelopeCmd(int32_t slotId, const std::string &cmd)
1291 {
1292 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1293 TELEPHONY_LOGE("Non-system applications use system APIs!");
1294 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1295 }
1296 if (simManager_ == nullptr) {
1297 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd simManager_ is nullptr");
1298 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1299 }
1300 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1301 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd, Permission denied!");
1302 return TELEPHONY_ERR_PERMISSION_ERR;
1303 }
1304 TELEPHONY_LOGD("CoreService::SendEnvelopeCmd(), slotId = %{public}d", slotId);
1305 return simManager_->SendEnvelopeCmd(slotId, cmd);
1306 }
1307
SendTerminalResponseCmd(int32_t slotId,const std::string & cmd)1308 int32_t CoreService::SendTerminalResponseCmd(int32_t slotId, const std::string &cmd)
1309 {
1310 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1311 TELEPHONY_LOGE("Non-system applications use system APIs!");
1312 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1313 }
1314 if (simManager_ == nullptr) {
1315 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd simManager_ is nullptr");
1316 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1317 }
1318 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1319 TELEPHONY_LOGE("CoreService::SendTerminalResponseCmd, Permission denied!");
1320 return TELEPHONY_ERR_PERMISSION_ERR;
1321 }
1322 TELEPHONY_LOGD("CoreService::SendTerminalResponseCmd(), slotId = %{public}d", slotId);
1323 return simManager_->SendTerminalResponseCmd(slotId, cmd);
1324 }
1325
SendCallSetupRequestResult(int32_t slotId,bool accept)1326 int32_t CoreService::SendCallSetupRequestResult(int32_t slotId, bool accept)
1327 {
1328 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1329 TELEPHONY_LOGE("Non-system applications use system APIs!");
1330 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1331 }
1332 if (simManager_ == nullptr) {
1333 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd simManager_ is nullptr");
1334 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1335 }
1336 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1337 TELEPHONY_LOGE("CoreService::SendCallSetupRequestResult, Permission denied!");
1338 return TELEPHONY_ERR_PERMISSION_ERR;
1339 }
1340 TELEPHONY_LOGD("CoreService::SendCallSetupRequestResult(), slotId = %{public}d", slotId);
1341 return simManager_->SendCallSetupRequestResult(slotId, accept);
1342 }
1343
UnlockSimLock(int32_t slotId,const PersoLockInfo & lockInfo,LockStatusResponse & response)1344 int32_t CoreService::UnlockSimLock(int32_t slotId, const PersoLockInfo &lockInfo, LockStatusResponse &response)
1345 {
1346 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1347 TELEPHONY_LOGE("Non-system applications use system APIs!");
1348 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1349 }
1350 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1351 TELEPHONY_LOGE("permission denied!");
1352 return TELEPHONY_ERR_PERMISSION_ERR;
1353 }
1354 TELEPHONY_LOGI(
1355 "CoreService::UnlockSimLock(), lockType = %{public}d, slotId = %{public}d", lockInfo.lockType, slotId);
1356 if (simManager_ == nullptr) {
1357 TELEPHONY_LOGE("simManager_ is null");
1358 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1359 }
1360 return simManager_->UnlockSimLock(slotId, lockInfo, response);
1361 }
1362
GetImsRegStatus(int32_t slotId,ImsServiceType imsSrvType,ImsRegInfo & info)1363 int32_t CoreService::GetImsRegStatus(int32_t slotId, ImsServiceType imsSrvType, ImsRegInfo &info)
1364 {
1365 TELEPHONY_LOGI("CoreService::GetImsRegStatus --> slotId:%{public}d, imsSrvType:%{public}d", slotId, imsSrvType);
1366 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1367 TELEPHONY_LOGE("Non-system applications use system APIs!");
1368 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1369 }
1370 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1371 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1372 return TELEPHONY_ERR_PERMISSION_ERR;
1373 }
1374 if (networkSearchManager_ == nullptr) {
1375 TELEPHONY_LOGE("failed! network search manager is nullptr!");
1376 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1377 }
1378 return networkSearchManager_->GetImsRegStatus(slotId, imsSrvType, info);
1379 }
1380
GetCellInfoList(int32_t slotId,std::vector<sptr<CellInformation>> & cellInfo)1381 int32_t CoreService::GetCellInfoList(int32_t slotId, std::vector<sptr<CellInformation>> &cellInfo)
1382 {
1383 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1384 TELEPHONY_LOGE("Non-system applications use system APIs!");
1385 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1386 }
1387 if (!TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
1388 return TELEPHONY_ERR_PERMISSION_ERR;
1389 }
1390 if (networkSearchManager_ == nullptr) {
1391 TELEPHONY_LOGE("networkSearchManager_ is null");
1392 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1393 }
1394 return networkSearchManager_->GetCellInfoList(slotId, cellInfo);
1395 }
1396
SendUpdateCellLocationRequest(int32_t slotId)1397 int32_t CoreService::SendUpdateCellLocationRequest(int32_t slotId)
1398 {
1399 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1400 TELEPHONY_LOGE("Non-system applications use system APIs!");
1401 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1402 }
1403 if (!TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
1404 TELEPHONY_LOGE("CoreService::SendUpdateCellLocationRequest, Permission denied!");
1405 return TELEPHONY_ERR_PERMISSION_ERR;
1406 }
1407 if (networkSearchManager_ == nullptr) {
1408 TELEPHONY_LOGE("networkSearchManager_ is null");
1409 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1410 }
1411 return networkSearchManager_->SendUpdateCellLocationRequest(slotId);
1412 }
1413
HasOperatorPrivileges(const int32_t slotId,bool & hasOperatorPrivileges)1414 int32_t CoreService::HasOperatorPrivileges(const int32_t slotId, bool &hasOperatorPrivileges)
1415 {
1416 TELEPHONY_LOGD("CoreService::HasOperatorPrivileges(), slotId = %{public}d", slotId);
1417 if (simManager_ == nullptr) {
1418 TELEPHONY_LOGE("simManager_ is null");
1419 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1420 }
1421 return simManager_->HasOperatorPrivileges(slotId, hasOperatorPrivileges);
1422 }
1423
SimAuthentication(int32_t slotId,AuthType authType,const std::string & authData,SimAuthenticationResponse & response)1424 int32_t CoreService::SimAuthentication(
1425 int32_t slotId, AuthType authType, const std::string &authData, SimAuthenticationResponse &response)
1426 {
1427 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1428 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1429 return TELEPHONY_ERR_PERMISSION_ERR;
1430 }
1431 TELEPHONY_LOGD("CoreService::SimAuthentication(), slotId = %{public}d", slotId);
1432 if (simManager_ == nullptr) {
1433 TELEPHONY_LOGE("simManager_ is null");
1434 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1435 }
1436 return simManager_->SimAuthentication(slotId, authType, authData, response);
1437 }
1438
RegisterImsRegInfoCallback(int32_t slotId,ImsServiceType imsSrvType,const sptr<ImsRegInfoCallback> & callback)1439 int32_t CoreService::RegisterImsRegInfoCallback(
1440 int32_t slotId, ImsServiceType imsSrvType, const sptr<ImsRegInfoCallback> &callback)
1441 {
1442 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1443 TELEPHONY_LOGE("Non-system applications use system APIs!");
1444 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1445 }
1446 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1447 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1448 return TELEPHONY_ERR_PERMISSION_ERR;
1449 }
1450 if (networkSearchManager_ == nullptr) {
1451 TELEPHONY_LOGE("failed! network search manager is nullptr!");
1452 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1453 }
1454 return networkSearchManager_->RegisterImsRegInfoCallback(slotId, imsSrvType, GetBundleName(), callback);
1455 }
1456
UnregisterImsRegInfoCallback(int32_t slotId,ImsServiceType imsSrvType)1457 int32_t CoreService::UnregisterImsRegInfoCallback(int32_t slotId, ImsServiceType imsSrvType)
1458 {
1459 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1460 TELEPHONY_LOGE("Non-system applications use system APIs!");
1461 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1462 }
1463 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1464 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1465 return TELEPHONY_ERR_PERMISSION_ERR;
1466 }
1467 if (networkSearchManager_ == nullptr) {
1468 TELEPHONY_LOGE("failed! network search manager is nullptr!");
1469 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1470 }
1471 return networkSearchManager_->UnregisterImsRegInfoCallback(slotId, imsSrvType, GetBundleName());
1472 }
1473
GetBasebandVersion(int32_t slotId,std::string & version)1474 int32_t CoreService::GetBasebandVersion(int32_t slotId, std::string &version)
1475 {
1476 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1477 TELEPHONY_LOGE("Non-system applications use system APIs!");
1478 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1479 }
1480 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1481 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1482 return TELEPHONY_ERR_PERMISSION_ERR;
1483 }
1484 if (networkSearchManager_ == nullptr) {
1485 TELEPHONY_LOGE("networkSearchManager_ is null");
1486 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1487 }
1488 return networkSearchManager_->GetBasebandVersion(slotId, version);
1489 }
1490
FactoryReset(int32_t slotId)1491 int32_t CoreService::FactoryReset(int32_t slotId)
1492 {
1493 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1494 TELEPHONY_LOGE("Non-system applications use system APIs!");
1495 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1496 }
1497 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1498 TELEPHONY_LOGE("Permission denied!");
1499 return TELEPHONY_ERR_PERMISSION_ERR;
1500 }
1501 if (networkSearchManager_ == nullptr) {
1502 TELEPHONY_LOGE("networkSearchManager_ is null");
1503 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1504 }
1505 return networkSearchManager_->FactoryReset(slotId);
1506 }
1507
Dump(std::int32_t fd,const std::vector<std::u16string> & args)1508 int32_t CoreService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
1509 {
1510 if (fd < 0) {
1511 TELEPHONY_LOGE("dump fd invalid");
1512 return TELEPHONY_ERR_ARGUMENT_INVALID;
1513 }
1514 std::vector<std::string> argsInStr;
1515 for (const auto &arg : args) {
1516 TELEPHONY_LOGI("Dump args: %s", Str16ToStr8(arg).c_str());
1517 argsInStr.emplace_back(Str16ToStr8(arg));
1518 }
1519 std::string result;
1520 CoreServiceDumpHelper dumpHelper;
1521 if (dumpHelper.Dump(argsInStr, result)) {
1522 TELEPHONY_LOGI("%s", result.c_str());
1523 std::int32_t ret = dprintf(fd, "%s", result.c_str());
1524 if (ret < 0) {
1525 TELEPHONY_LOGE("dprintf to dump fd failed");
1526 return TELEPHONY_ERROR;
1527 }
1528 return 0;
1529 }
1530 TELEPHONY_LOGW("dumpHelper failed");
1531 return TELEPHONY_ERROR;
1532 }
1533
GetBindTime()1534 int64_t CoreService::GetBindTime()
1535 {
1536 return bindTime_;
1537 }
1538
GetEndTime()1539 int64_t CoreService::GetEndTime()
1540 {
1541 return endTime_;
1542 }
1543
GetSpendTime()1544 int64_t CoreService::GetSpendTime()
1545 {
1546 return endTime_ - bindTime_;
1547 }
1548
GetNrSsbIdInfo(int32_t slotId,const std::shared_ptr<NrSsbInformation> & nrSsbInformation)1549 int32_t CoreService::GetNrSsbIdInfo(int32_t slotId, const std::shared_ptr<NrSsbInformation> &nrSsbInformation)
1550 {
1551 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
1552 TELEPHONY_LOGE("Non-system applications use system APIs!");
1553 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
1554 }
1555 if (!TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
1556 TELEPHONY_LOGE("Do not support Permission::CELL_LOCATION");
1557 return TELEPHONY_ERR_PERMISSION_ERR;
1558 }
1559 if (networkSearchManager_ == nullptr) {
1560 TELEPHONY_LOGE("networkSearchManager_ is null");
1561 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1562 }
1563 return networkSearchManager_->GetNrSsbId(slotId, nrSsbInformation);
1564 }
1565 } // namespace Telephony
1566 } // namespace OHOS
1567