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 "network_search_manager.h"
22 #include "network_search_types.h"
23 #include "parameter.h"
24 #include "sim_manager.h"
25 #include "string_ex.h"
26 #include "system_ability_definition.h"
27 #include "telephony_common_utils.h"
28 #include "telephony_errors.h"
29 #include "telephony_log_wrapper.h"
30 #include "telephony_permission.h"
31
32 namespace OHOS {
33 namespace Telephony {
34 const bool G_REGISTER_RESULT =
35 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<CoreService>::GetInstance().get());
36
CoreService()37 CoreService::CoreService() : SystemAbility(TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID, true) {}
38
~CoreService()39 CoreService::~CoreService() {}
40
OnStart()41 void CoreService::OnStart()
42 {
43 bindTime_ =
44 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
45 .count();
46 if (state_ == ServiceRunningState::STATE_RUNNING) {
47 TELEPHONY_LOGE("CoreService has already started.");
48 return;
49 }
50
51 if (!registerToService_) {
52 bool ret = Publish(DelayedSingleton<CoreService>::GetInstance().get());
53 if (!ret) {
54 TELEPHONY_LOGE("CoreService::Init Publish failed!");
55 return;
56 }
57 registerToService_ = true;
58 }
59
60 if (!Init()) {
61 TELEPHONY_LOGE("failed to init CoreService");
62 return;
63 }
64 state_ = ServiceRunningState::STATE_RUNNING;
65 endTime_ =
66 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
67 .count();
68 TELEPHONY_LOGI("CoreService start success");
69 }
70
Init()71 bool CoreService::Init()
72 {
73 TELEPHONY_LOGI("CoreService::Init");
74 telRilManager_ = std::make_shared<TelRilManager>();
75 if (telRilManager_ != nullptr) {
76 if (!telRilManager_->OnInit()) {
77 TELEPHONY_LOGE("TelRilManager init is failed!");
78 return false;
79 }
80 }
81 CoreManagerInner::GetInstance().SetTelRilMangerObj(telRilManager_);
82 int32_t slotCount = GetMaxSimCount();
83 simManager_ = std::make_shared<SimManager>(telRilManager_);
84 if (simManager_ != nullptr) {
85 simManager_->OnInit(slotCount);
86 } else {
87 TELEPHONY_LOGE("SimManager init is failed!");
88 return false;
89 }
90 // connect ims_service
91 DelayedSingleton<ImsCoreServiceClient>::GetInstance()->Init();
92 networkSearchManager_ = std::make_shared<NetworkSearchManager>(telRilManager_, simManager_);
93 if (networkSearchManager_ != nullptr) {
94 if (!networkSearchManager_->OnInit()) {
95 TELEPHONY_LOGE("NetworkSearchManager init is failed!");
96 return false;
97 }
98 }
99 simManager_->SetNetworkSearchManager(networkSearchManager_);
100 CoreManagerInner::GetInstance().OnInit(networkSearchManager_, simManager_, telRilManager_);
101 TELEPHONY_LOGI("CoreService::Init success");
102 return true;
103 }
104
OnStop()105 void CoreService::OnStop()
106 {
107 state_ = ServiceRunningState::STATE_NOT_START;
108 registerToService_ = false;
109 DelayedSingleton<ImsCoreServiceClient>::GetInstance()->UnInit();
110 telRilManager_->DeInit();
111 TELEPHONY_LOGI("CoreService Stop success");
112 }
113
GetServiceRunningState()114 int32_t CoreService::GetServiceRunningState()
115 {
116 return static_cast<int32_t>(state_);
117 }
118
GetPsRadioTech(int32_t slotId,int32_t & psRadioTech)119 int32_t CoreService::GetPsRadioTech(int32_t slotId, int32_t &psRadioTech)
120 {
121 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
122 TELEPHONY_LOGE("permission denied!");
123 return TELEPHONY_ERR_PERMISSION_ERR;
124 }
125 if (networkSearchManager_ == nullptr) {
126 TELEPHONY_LOGE("networkSearchManager_ is null");
127 return TELEPHONY_ERR_LOCAL_PTR_NULL;
128 }
129 return networkSearchManager_->GetPsRadioTech(slotId, psRadioTech);
130 }
131
GetCsRadioTech(int32_t slotId,int32_t & csRadioTech)132 int32_t CoreService::GetCsRadioTech(int32_t slotId, int32_t &csRadioTech)
133 {
134 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
135 TELEPHONY_LOGE("permission denied!");
136 return TELEPHONY_ERR_PERMISSION_ERR;
137 }
138 if (networkSearchManager_ == nullptr) {
139 TELEPHONY_LOGE("networkSearchManager_ is null");
140 return TELEPHONY_ERR_LOCAL_PTR_NULL;
141 }
142 return networkSearchManager_->GetCsRadioTech(slotId, csRadioTech);
143 }
144
SetNetworkSelectionMode(int32_t slotId,int32_t selectMode,const sptr<NetworkInformation> & networkInformation,bool resumeSelection,const sptr<INetworkSearchCallback> & callback)145 int32_t CoreService::SetNetworkSelectionMode(int32_t slotId, int32_t selectMode,
146 const sptr<NetworkInformation> &networkInformation, bool resumeSelection,
147 const sptr<INetworkSearchCallback> &callback)
148 {
149 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
150 TELEPHONY_LOGE("permission denied!");
151 return TELEPHONY_ERR_PERMISSION_ERR;
152 }
153 if (networkSearchManager_ == nullptr) {
154 TELEPHONY_LOGE("networkSearchManager_ is null");
155 return TELEPHONY_ERR_LOCAL_PTR_NULL;
156 }
157 TELEPHONY_LOGI("CoreService::SetNetworkSelectionMode selectMode:%{public}d", selectMode);
158 return networkSearchManager_->SetNetworkSelectionMode(
159 slotId, selectMode, networkInformation, resumeSelection, callback);
160 }
161
GetSignalInfoList(int32_t slotId,std::vector<sptr<SignalInformation>> & signals)162 int32_t CoreService::GetSignalInfoList(int32_t slotId, std::vector<sptr<SignalInformation>> &signals)
163 {
164 if (networkSearchManager_ == nullptr) {
165 TELEPHONY_LOGE("networkSearchManager_ is null");
166 return TELEPHONY_ERR_LOCAL_PTR_NULL;
167 }
168 return networkSearchManager_->GetSignalInfoList(slotId, signals);
169 }
170
GetOperatorNumeric(int32_t slotId)171 std::u16string CoreService::GetOperatorNumeric(int32_t slotId)
172 {
173 if (networkSearchManager_ == nullptr) {
174 TELEPHONY_LOGE("networkSearchManager_ is null");
175 return std::u16string();
176 }
177 return networkSearchManager_->GetOperatorNumeric(slotId);
178 }
179
GetOperatorName(int32_t slotId,std::u16string & operatorName)180 int32_t CoreService::GetOperatorName(int32_t slotId, std::u16string &operatorName)
181 {
182 if (networkSearchManager_ == nullptr) {
183 TELEPHONY_LOGE("networkSearchManager_ is null");
184 return TELEPHONY_ERR_LOCAL_PTR_NULL;
185 }
186 return networkSearchManager_->GetOperatorName(slotId, operatorName);
187 }
188
GetNetworkState(int32_t slotId,sptr<NetworkState> & networkState)189 int32_t CoreService::GetNetworkState(int32_t slotId, sptr<NetworkState> &networkState)
190 {
191 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
192 TELEPHONY_LOGE("permission denied!");
193 return TELEPHONY_ERR_PERMISSION_ERR;
194 }
195 if (networkSearchManager_ == nullptr) {
196 TELEPHONY_LOGE("networkSearchManager_ is null");
197 return TELEPHONY_ERR_LOCAL_PTR_NULL;
198 }
199 return networkSearchManager_->GetNetworkStatus(slotId, networkState);
200 }
201
SetRadioState(int32_t slotId,bool isOn,const sptr<INetworkSearchCallback> & callback)202 int32_t CoreService::SetRadioState(int32_t slotId, bool isOn, const sptr<INetworkSearchCallback> &callback)
203 {
204 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
205 TELEPHONY_LOGE("permission denied!");
206 return TELEPHONY_ERR_PERMISSION_ERR;
207 }
208 if (networkSearchManager_ == nullptr) {
209 TELEPHONY_LOGE("networkSearchManager_ is null");
210 return TELEPHONY_ERR_LOCAL_PTR_NULL;
211 }
212 TELEPHONY_LOGI("CoreService::SetRadioState --> slotId:%{public}d, isOn:%{public}d", slotId, isOn);
213 return networkSearchManager_->SetRadioState(slotId, isOn, 0, callback);
214 }
215
GetRadioState(int32_t slotId,const sptr<INetworkSearchCallback> & callback)216 int32_t CoreService::GetRadioState(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
217 {
218 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
219 TELEPHONY_LOGE("permission denied!");
220 return TELEPHONY_ERR_PERMISSION_ERR;
221 }
222 if (networkSearchManager_ == nullptr) {
223 TELEPHONY_LOGE("networkSearchManager_ is null");
224 return TELEPHONY_ERR_LOCAL_PTR_NULL;
225 }
226 return networkSearchManager_->GetRadioState(slotId, callback);
227 }
228
GetIsoCountryCodeForNetwork(int32_t slotId,std::u16string & countryCode)229 int32_t CoreService::GetIsoCountryCodeForNetwork(int32_t slotId, std::u16string &countryCode)
230 {
231 if (networkSearchManager_ == nullptr) {
232 TELEPHONY_LOGE("networkSearchManager_ is null");
233 return TELEPHONY_ERR_LOCAL_PTR_NULL;
234 }
235 return networkSearchManager_->GetIsoCountryCodeForNetwork(slotId, countryCode);
236 }
237
GetImei(int32_t slotId,std::u16string & imei)238 int32_t CoreService::GetImei(int32_t slotId, std::u16string &imei)
239 {
240 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
241 TELEPHONY_LOGE("permission denied!");
242 return TELEPHONY_ERR_PERMISSION_ERR;
243 }
244 if (networkSearchManager_ == nullptr) {
245 TELEPHONY_LOGE("networkSearchManager_ is null");
246 return TELEPHONY_ERR_LOCAL_PTR_NULL;
247 }
248 return networkSearchManager_->GetImei(slotId, imei);
249 }
250
GetMeid(int32_t slotId,std::u16string & meid)251 int32_t CoreService::GetMeid(int32_t slotId, std::u16string &meid)
252 {
253 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
254 TELEPHONY_LOGE("permission denied!");
255 return TELEPHONY_ERR_PERMISSION_ERR;
256 }
257 if (networkSearchManager_ == nullptr) {
258 TELEPHONY_LOGE("networkSearchManager_ is null");
259 return TELEPHONY_ERR_LOCAL_PTR_NULL;
260 }
261 return networkSearchManager_->GetMeid(slotId, meid);
262 }
263
GetUniqueDeviceId(int32_t slotId,std::u16string & deviceId)264 int32_t CoreService::GetUniqueDeviceId(int32_t slotId, std::u16string &deviceId)
265 {
266 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
267 TELEPHONY_LOGE("permission denied!");
268 return TELEPHONY_ERR_PERMISSION_ERR;
269 }
270 if (networkSearchManager_ == nullptr) {
271 TELEPHONY_LOGE("networkSearchManager_ is null");
272 return TELEPHONY_ERR_LOCAL_PTR_NULL;
273 }
274 return networkSearchManager_->GetUniqueDeviceId(slotId, deviceId);
275 }
276
IsNrSupported(int32_t slotId)277 bool CoreService::IsNrSupported(int32_t slotId)
278 {
279 if (networkSearchManager_ == nullptr) {
280 TELEPHONY_LOGE("networkSearchManager_ is null");
281 return false;
282 }
283 return networkSearchManager_->IsNrSupported(slotId);
284 }
285
GetNrOptionMode(int32_t slotId,NrMode & mode)286 int32_t CoreService::GetNrOptionMode(int32_t slotId, NrMode &mode)
287 {
288 if (networkSearchManager_ == nullptr) {
289 TELEPHONY_LOGE("networkSearchManager_ is null");
290 return TELEPHONY_ERR_LOCAL_PTR_NULL;
291 }
292 return networkSearchManager_->GetNrOptionMode(slotId, mode);
293 }
294
HasSimCard(int32_t slotId,bool & hasSimCard)295 int32_t CoreService::HasSimCard(int32_t slotId, bool &hasSimCard)
296 {
297 TELEPHONY_LOGD("CoreService::HasSimCard(), slotId = %{public}d", slotId);
298 if (simManager_ == nullptr) {
299 TELEPHONY_LOGE("simManager_ is null");
300 return TELEPHONY_ERR_LOCAL_PTR_NULL;
301 }
302 return simManager_->HasSimCard(slotId, hasSimCard);
303 }
304
GetSimState(int32_t slotId,SimState & simState)305 int32_t CoreService::GetSimState(int32_t slotId, SimState &simState)
306 {
307 TELEPHONY_LOGD("CoreService::GetSimState(), slotId = %{public}d", slotId);
308 if (simManager_ == nullptr) {
309 TELEPHONY_LOGE("simManager_ is null");
310 return TELEPHONY_ERR_LOCAL_PTR_NULL;
311 }
312
313 return simManager_->GetSimState(slotId, simState);
314 }
315
GetCardType(int32_t slotId,CardType & cardType)316 int32_t CoreService::GetCardType(int32_t slotId, CardType &cardType)
317 {
318 TELEPHONY_LOGD("CoreService::GetCardType(), slotId = %{public}d", slotId);
319 if (simManager_ == nullptr) {
320 TELEPHONY_LOGE("simManager_ is null");
321 return TELEPHONY_ERR_LOCAL_PTR_NULL;
322 }
323
324 return simManager_->GetCardType(slotId, cardType);
325 }
326
GetISOCountryCodeForSim(int32_t slotId,std::u16string & countryCode)327 int32_t CoreService::GetISOCountryCodeForSim(int32_t slotId, std::u16string &countryCode)
328 {
329 TELEPHONY_LOGD("CoreService::GetISOCountryCodeForSim(), slotId = %{public}d", slotId);
330 if (simManager_ == nullptr) {
331 TELEPHONY_LOGE("simManager_ is null");
332 return TELEPHONY_ERR_LOCAL_PTR_NULL;
333 }
334
335 return simManager_->GetISOCountryCodeForSim(slotId, countryCode);
336 }
337
GetSimSpn(int32_t slotId,std::u16string & spn)338 int32_t CoreService::GetSimSpn(int32_t slotId, std::u16string &spn)
339 {
340 TELEPHONY_LOGD("CoreService::GetSimSpn(), slotId = %{public}d", slotId);
341 if (simManager_ == nullptr) {
342 TELEPHONY_LOGE("simManager_ is null");
343 return TELEPHONY_ERR_LOCAL_PTR_NULL;
344 }
345 return simManager_->GetSimSpn(slotId, spn);
346 }
347
GetSimIccId(int32_t slotId,std::u16string & iccId)348 int32_t CoreService::GetSimIccId(int32_t slotId, std::u16string &iccId)
349 {
350 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
351 TELEPHONY_LOGE("permission denied!");
352 return TELEPHONY_ERR_PERMISSION_ERR;
353 }
354 TELEPHONY_LOGD("CoreService::GetSimIccId(), slotId = %{public}d", slotId);
355 if (simManager_ == nullptr) {
356 TELEPHONY_LOGE("simManager_ is null");
357 return TELEPHONY_ERR_LOCAL_PTR_NULL;
358 }
359 return simManager_->GetSimIccId(slotId, iccId);
360 }
361
GetSimOperatorNumeric(int32_t slotId,std::u16string & operatorNumeric)362 int32_t CoreService::GetSimOperatorNumeric(int32_t slotId, std::u16string &operatorNumeric)
363 {
364 TELEPHONY_LOGD("CoreService::GetSimOperatorNumeric(), slotId = %{public}d", slotId);
365 if (simManager_ == nullptr) {
366 TELEPHONY_LOGE("simManager_ is null");
367 return TELEPHONY_ERR_LOCAL_PTR_NULL;
368 }
369 return simManager_->GetSimOperatorNumeric(slotId, operatorNumeric);
370 }
371
GetIMSI(int32_t slotId,std::u16string & imsi)372 int32_t CoreService::GetIMSI(int32_t slotId, std::u16string &imsi)
373 {
374 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
375 TELEPHONY_LOGE("permission denied!");
376 return TELEPHONY_ERR_PERMISSION_ERR;
377 }
378 TELEPHONY_LOGD("CoreService::GetIMSI(), slotId = %{public}d", slotId);
379 if (simManager_ == nullptr) {
380 TELEPHONY_LOGE("simManager_ is null");
381 return TELEPHONY_ERR_LOCAL_PTR_NULL;
382 }
383 return simManager_->GetIMSI(slotId, imsi);
384 }
385
IsSimActive(int32_t slotId)386 bool CoreService::IsSimActive(int32_t slotId)
387 {
388 TELEPHONY_LOGD("CoreService::IsSimActive(), slotId = %{public}d", slotId);
389 if (simManager_ == nullptr) {
390 TELEPHONY_LOGE("simManager_ is null");
391 return false;
392 }
393 return simManager_->IsSimActive(slotId);
394 }
395
GetSlotId(int32_t simId)396 int32_t CoreService::GetSlotId(int32_t simId)
397 {
398 TELEPHONY_LOGD("CoreService::GetSlotId(), simId = %{public}d", simId);
399 if (simManager_ == nullptr) {
400 TELEPHONY_LOGE("CoreService::GetSlotId(), simManager_ is nullptr!");
401 return TELEPHONY_ERROR;
402 }
403 return simManager_->GetSlotId(simId);
404 }
405
GetSimId(int32_t slotId)406 int32_t CoreService::GetSimId(int32_t slotId)
407 {
408 TELEPHONY_LOGD("CoreService::GetSimId(), slotId = %{public}d", slotId);
409 if (simManager_ == nullptr) {
410 TELEPHONY_LOGE("CoreService::GetSimId(), simManager_ is nullptr!");
411 return TELEPHONY_ERROR;
412 }
413 return simManager_->GetSimId(slotId);
414 }
415
GetNetworkSearchInformation(int32_t slotId,const sptr<INetworkSearchCallback> & callback)416 int32_t CoreService::GetNetworkSearchInformation(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
417 {
418 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
419 TELEPHONY_LOGE("permission denied!");
420 return TELEPHONY_ERR_PERMISSION_ERR;
421 }
422 if (networkSearchManager_ == nullptr) {
423 TELEPHONY_LOGE("networkSearchManager_ is null");
424 return TELEPHONY_ERR_LOCAL_PTR_NULL;
425 }
426 return networkSearchManager_->GetNetworkSearchInformation(slotId, callback);
427 }
428
GetNetworkSelectionMode(int32_t slotId,const sptr<INetworkSearchCallback> & callback)429 int32_t CoreService::GetNetworkSelectionMode(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
430 {
431 if (networkSearchManager_ == nullptr) {
432 TELEPHONY_LOGE("networkSearchManager_ is null");
433 return TELEPHONY_ERR_LOCAL_PTR_NULL;
434 }
435 return networkSearchManager_->GetNetworkSelectionMode(slotId, callback);
436 }
437
GetLocaleFromDefaultSim()438 std::u16string CoreService::GetLocaleFromDefaultSim()
439 {
440 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
441 TELEPHONY_LOGE("CoreService::GetLocaleFromDefaultSim, Permission denied!");
442 return std::u16string();
443 }
444 TELEPHONY_LOGD("CoreService::GetLocaleFromDefaultSim()");
445 if (simManager_ == nullptr) {
446 TELEPHONY_LOGE("simManager_ is null");
447 return std::u16string();
448 }
449 int32_t slotId = INVALID_VALUE;
450 simManager_->GetPrimarySlotId(slotId);
451 if (slotId < DEFAULT_SIM_SLOT_ID) {
452 slotId = DEFAULT_SIM_SLOT_ID;
453 }
454 return simManager_->GetLocaleFromDefaultSim(slotId);
455 }
456
GetSimGid1(int32_t slotId,std::u16string & gid1)457 int32_t CoreService::GetSimGid1(int32_t slotId, std::u16string &gid1)
458 {
459 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
460 TELEPHONY_LOGE("CoreService::GetSimGid1, Permission denied!");
461 return TELEPHONY_ERR_PERMISSION_ERR;
462 }
463 TELEPHONY_LOGD("CoreService::GetSimGid1(), slotId = %{public}d", slotId);
464 if (simManager_ == nullptr) {
465 TELEPHONY_LOGE("simManager_ is null");
466 return TELEPHONY_ERR_LOCAL_PTR_NULL;
467 }
468 return simManager_->GetSimGid1(slotId, gid1);
469 }
470
GetSimGid2(int32_t slotId)471 std::u16string CoreService::GetSimGid2(int32_t slotId)
472 {
473 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
474 TELEPHONY_LOGE("CoreService::GetSimGid2, Permission denied!");
475 return std::u16string();
476 }
477 TELEPHONY_LOGD("CoreService::GetSimGid2(), slotId = %{public}d", slotId);
478 if (simManager_ == nullptr) {
479 TELEPHONY_LOGE("simManager_ is null");
480 return std::u16string();
481 }
482 return simManager_->GetSimGid2(slotId);
483 }
484
GetSimEons(int32_t slotId,const std::string & plmn,int32_t lac,bool longNameRequired)485 std::u16string CoreService::GetSimEons(int32_t slotId, const std::string &plmn, int32_t lac, bool longNameRequired)
486 {
487 TELEPHONY_LOGD("CoreService::GetSimEons(), slotId = %{public}d", slotId);
488 if (simManager_ == nullptr) {
489 TELEPHONY_LOGE("CoreService::GetSimEons, Permission denied!");
490 return std::u16string();
491 }
492 return simManager_->GetSimEons(slotId, plmn, lac, longNameRequired);
493 }
494
GetSimAccountInfo(int32_t slotId,IccAccountInfo & info)495 int32_t CoreService::GetSimAccountInfo(int32_t slotId, IccAccountInfo &info)
496 {
497 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
498 TELEPHONY_LOGE("permission denied!");
499 return TELEPHONY_ERR_PERMISSION_ERR;
500 }
501 TELEPHONY_LOGD("CoreService::GetSimAccountInfo(), slotId = %{public}d", slotId);
502 if (simManager_ == nullptr) {
503 TELEPHONY_LOGE("simManager_ is null");
504 return TELEPHONY_ERR_LOCAL_PTR_NULL;
505 }
506 return simManager_->GetSimAccountInfo(slotId, info);
507 }
508
SetDefaultVoiceSlotId(int32_t slotId)509 int32_t CoreService::SetDefaultVoiceSlotId(int32_t slotId)
510 {
511 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
512 TELEPHONY_LOGE("permission denied!");
513 return TELEPHONY_ERR_PERMISSION_ERR;
514 }
515 TELEPHONY_LOGD("CoreService::SetDefaultVoiceSlotId(), slotId = %{public}d", slotId);
516 if (simManager_ == nullptr) {
517 TELEPHONY_LOGE("simManager_ is null");
518 return TELEPHONY_ERR_LOCAL_PTR_NULL;
519 }
520 return simManager_->SetDefaultVoiceSlotId(slotId);
521 }
522
GetDefaultVoiceSlotId()523 int32_t CoreService::GetDefaultVoiceSlotId()
524 {
525 TELEPHONY_LOGD("CoreService::GetDefaultVoiceSlotId()");
526 if (simManager_ == nullptr) {
527 TELEPHONY_LOGE("simManager_ is null");
528 return TELEPHONY_ERROR;
529 }
530 return simManager_->GetDefaultVoiceSlotId();
531 }
532
SetPrimarySlotId(int32_t slotId)533 int32_t CoreService::SetPrimarySlotId(int32_t slotId)
534 {
535 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
536 TELEPHONY_LOGE("permission denied!");
537 return TELEPHONY_ERR_PERMISSION_ERR;
538 }
539 TELEPHONY_LOGD("CoreService::SetPrimarySlotId(), slotId = %{public}d", slotId);
540 if (simManager_ == nullptr) {
541 TELEPHONY_LOGE("simManager_ is null");
542 return TELEPHONY_ERR_LOCAL_PTR_NULL;
543 }
544 return simManager_->SetPrimarySlotId(slotId);
545 }
546
GetPrimarySlotId(int32_t & slotId)547 int32_t CoreService::GetPrimarySlotId(int32_t &slotId)
548 {
549 TELEPHONY_LOGD("CoreService::GetPrimarySlotId()");
550 if (simManager_ == nullptr) {
551 TELEPHONY_LOGE("simManager_ is null");
552 return TELEPHONY_ERR_LOCAL_PTR_NULL;
553 }
554 return simManager_->GetPrimarySlotId(slotId);
555 }
556
SetShowNumber(int32_t slotId,const std::u16string & number)557 int32_t CoreService::SetShowNumber(int32_t slotId, const std::u16string &number)
558 {
559 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
560 TELEPHONY_LOGE("permission denied!");
561 return TELEPHONY_ERR_PERMISSION_ERR;
562 }
563 TELEPHONY_LOGD("CoreService::SetShowNumber(), slotId = %{public}d", slotId);
564 if (simManager_ == nullptr) {
565 TELEPHONY_LOGE("simManager_ is null");
566 return TELEPHONY_ERR_LOCAL_PTR_NULL;
567 }
568 return simManager_->SetShowNumber(slotId, number);
569 }
570
GetShowNumber(int32_t slotId,std::u16string & showNumber)571 int32_t CoreService::GetShowNumber(int32_t slotId, std::u16string &showNumber)
572 {
573 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
574 TELEPHONY_LOGE("permission denied!");
575 return TELEPHONY_ERR_PERMISSION_ERR;
576 }
577 TELEPHONY_LOGD("CoreService::GetShowNumber(), slotId = %{public}d", slotId);
578 if (simManager_ == nullptr) {
579 TELEPHONY_LOGE("simManager_ is null");
580 return TELEPHONY_ERR_LOCAL_PTR_NULL;
581 }
582 return simManager_->GetShowNumber(slotId, showNumber);
583 }
584
SetShowName(int32_t slotId,const std::u16string & name)585 int32_t CoreService::SetShowName(int32_t slotId, const std::u16string &name)
586 {
587 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
588 TELEPHONY_LOGE("permission denied!");
589 return TELEPHONY_ERR_PERMISSION_ERR;
590 }
591 TELEPHONY_LOGD("CoreService::SetShowName(), slotId = %{public}d", slotId);
592 if (simManager_ == nullptr) {
593 TELEPHONY_LOGE("simManager_ is null");
594 return TELEPHONY_ERR_LOCAL_PTR_NULL;
595 }
596 return simManager_->SetShowName(slotId, name);
597 }
598
GetShowName(int32_t slotId,std::u16string & showName)599 int32_t CoreService::GetShowName(int32_t slotId, std::u16string &showName)
600 {
601 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
602 TELEPHONY_LOGE("permission denied!");
603 return TELEPHONY_ERR_PERMISSION_ERR;
604 }
605 TELEPHONY_LOGD("CoreService::GetShowName(), slotId = %{public}d", slotId);
606 if (simManager_ == nullptr) {
607 TELEPHONY_LOGE("simManager_ is null");
608 return TELEPHONY_ERR_LOCAL_PTR_NULL;
609 }
610 return simManager_->GetShowName(slotId, showName);
611 }
612
GetActiveSimAccountInfoList(std::vector<IccAccountInfo> & iccAccountInfoList)613 int32_t CoreService::GetActiveSimAccountInfoList(std::vector<IccAccountInfo> &iccAccountInfoList)
614 {
615 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
616 TELEPHONY_LOGE("permission denied!");
617 return TELEPHONY_ERR_PERMISSION_ERR;
618 }
619 TELEPHONY_LOGD("CoreService::GetActiveSimAccountInfoList");
620 if (simManager_ == nullptr) {
621 TELEPHONY_LOGE("simManager_ is null");
622 return TELEPHONY_ERR_LOCAL_PTR_NULL;
623 }
624 return simManager_->GetActiveSimAccountInfoList(iccAccountInfoList);
625 }
626
GetOperatorConfigs(int32_t slotId,OperatorConfig & poc)627 int32_t CoreService::GetOperatorConfigs(int32_t slotId, OperatorConfig &poc)
628 {
629 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
630 TELEPHONY_LOGE("permission denied!");
631 return TELEPHONY_ERR_PERMISSION_ERR;
632 }
633 TELEPHONY_LOGD("CoreService::GetOperatorConfigs");
634 if (simManager_ == nullptr) {
635 TELEPHONY_LOGE("simManager_ is null");
636 return TELEPHONY_ERR_LOCAL_PTR_NULL;
637 }
638 return simManager_->GetOperatorConfigs(slotId, poc);
639 }
640
UnlockPin(const int32_t slotId,const std::u16string & pin,LockStatusResponse & response)641 int32_t CoreService::UnlockPin(const int32_t slotId, const std::u16string &pin, LockStatusResponse &response)
642 {
643 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
644 TELEPHONY_LOGE("permission denied!");
645 return TELEPHONY_ERR_PERMISSION_ERR;
646 }
647 TELEPHONY_LOGD("CoreService::UnlockPin(), pinLen = %{public}lu, slotId = %{public}d",
648 static_cast<unsigned long>(pin.length()), slotId);
649 if (simManager_ == nullptr) {
650 TELEPHONY_LOGE("simManager_ is null");
651 return TELEPHONY_ERR_LOCAL_PTR_NULL;
652 }
653 return simManager_->UnlockPin(slotId, Str16ToStr8(pin), response);
654 }
655
UnlockPuk(const int slotId,const std::u16string & newPin,const std::u16string & puk,LockStatusResponse & response)656 int32_t CoreService::UnlockPuk(
657 const int slotId, const std::u16string &newPin, const std::u16string &puk, LockStatusResponse &response)
658 {
659 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
660 TELEPHONY_LOGE("permission denied!");
661 return TELEPHONY_ERR_PERMISSION_ERR;
662 }
663 TELEPHONY_LOGI("CoreService::UnlockPuk(), newPinLen = %{public}lu, pukLen = %{public}lu, slotId = %{public}d",
664 static_cast<unsigned long>(newPin.length()), static_cast<unsigned long>(puk.length()), slotId);
665 if (simManager_ == nullptr) {
666 TELEPHONY_LOGE("simManager_ is null");
667 return TELEPHONY_ERR_LOCAL_PTR_NULL;
668 }
669 return simManager_->UnlockPuk(slotId, Str16ToStr8(newPin), Str16ToStr8(puk), response);
670 }
671
AlterPin(const int slotId,const std::u16string & newPin,const std::u16string & oldPin,LockStatusResponse & response)672 int32_t CoreService::AlterPin(
673 const int slotId, const std::u16string &newPin, const std::u16string &oldPin, LockStatusResponse &response)
674 {
675 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
676 TELEPHONY_LOGE("permission denied!");
677 return TELEPHONY_ERR_PERMISSION_ERR;
678 }
679 TELEPHONY_LOGI("CoreService::AlterPin(), newPinLen = %{public}lu, oldPinLen = %{public}lu, slotId = %{public}d",
680 static_cast<unsigned long>(newPin.length()), static_cast<unsigned long>(oldPin.length()), slotId);
681 if (simManager_ == nullptr) {
682 TELEPHONY_LOGE("simManager_ is null");
683 return TELEPHONY_ERR_LOCAL_PTR_NULL;
684 }
685 return simManager_->AlterPin(slotId, Str16ToStr8(newPin), Str16ToStr8(oldPin), response);
686 }
687
UnlockPin2(const int32_t slotId,const std::u16string & pin2,LockStatusResponse & response)688 int32_t CoreService::UnlockPin2(const int32_t slotId, const std::u16string &pin2, LockStatusResponse &response)
689 {
690 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
691 TELEPHONY_LOGE("permission denied!");
692 return TELEPHONY_ERR_PERMISSION_ERR;
693 }
694 TELEPHONY_LOGI("CoreService::UnlockPin2(), pin2Len = %{public}lu, slotId = %{public}d",
695 static_cast<unsigned long>(pin2.length()), slotId);
696 if (simManager_ == nullptr) {
697 TELEPHONY_LOGE("simManager_ is null");
698 return TELEPHONY_ERR_LOCAL_PTR_NULL;
699 }
700 return simManager_->UnlockPin2(slotId, Str16ToStr8(pin2), response);
701 }
702
UnlockPuk2(const int slotId,const std::u16string & newPin2,const std::u16string & puk2,LockStatusResponse & response)703 int32_t CoreService::UnlockPuk2(
704 const int slotId, const std::u16string &newPin2, const std::u16string &puk2, LockStatusResponse &response)
705 {
706 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
707 TELEPHONY_LOGE("permission denied!");
708 return TELEPHONY_ERR_PERMISSION_ERR;
709 }
710 TELEPHONY_LOGI("CoreService::UnlockPuk2(), newPin2Len = %{public}lu, puk2Len = %{public}lu, slotId = %{public}d",
711 static_cast<unsigned long>(newPin2.length()), static_cast<unsigned long>(puk2.length()), slotId);
712 if (simManager_ == nullptr) {
713 TELEPHONY_LOGE("simManager_ is null");
714 return TELEPHONY_ERR_LOCAL_PTR_NULL;
715 }
716 return simManager_->UnlockPuk2(slotId, Str16ToStr8(newPin2), Str16ToStr8(puk2), response);
717 }
718
AlterPin2(const int slotId,const std::u16string & newPin2,const std::u16string & oldPin2,LockStatusResponse & response)719 int32_t CoreService::AlterPin2(
720 const int slotId, const std::u16string &newPin2, const std::u16string &oldPin2, LockStatusResponse &response)
721 {
722 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
723 TELEPHONY_LOGE("permission denied!");
724 return TELEPHONY_ERR_PERMISSION_ERR;
725 }
726 TELEPHONY_LOGI("CoreService::AlterPin2(), newPin2Len = %{public}lu, oldPin2Len = %{public}lu, slotId = %{public}d",
727 static_cast<unsigned long>(newPin2.length()), static_cast<unsigned long>(oldPin2.length()), slotId);
728 if (simManager_ == nullptr) {
729 TELEPHONY_LOGE("simManager_ is null");
730 return TELEPHONY_ERR_LOCAL_PTR_NULL;
731 }
732 return simManager_->AlterPin2(slotId, Str16ToStr8(newPin2), Str16ToStr8(oldPin2), response);
733 }
734
SetLockState(int32_t slotId,const LockInfo & options,LockStatusResponse & response)735 int32_t CoreService::SetLockState(int32_t slotId, const LockInfo &options, LockStatusResponse &response)
736 {
737 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
738 TELEPHONY_LOGE("permission denied!");
739 return TELEPHONY_ERR_PERMISSION_ERR;
740 }
741 std::u16string strPin = options.password;
742 TELEPHONY_LOGI(
743 "CoreService::SetLockState(),lockType = %{public}d, pinLen = %{public}lu, lockState = %{public}d, slotId "
744 "= "
745 "%{public}d",
746 options.lockType, static_cast<unsigned long>(strPin.length()), options.lockState, slotId);
747 if (simManager_ == nullptr) {
748 TELEPHONY_LOGE("simManager_ is null");
749 return TELEPHONY_ERR_LOCAL_PTR_NULL;
750 }
751 return simManager_->SetLockState(slotId, options, response);
752 }
753
GetLockState(int32_t slotId,LockType lockType,LockState & lockState)754 int32_t CoreService::GetLockState(int32_t slotId, LockType lockType, LockState &lockState)
755 {
756 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
757 TELEPHONY_LOGE("CoreService::GetLockState, Permission denied!");
758 return TELEPHONY_ERR_PERMISSION_ERR;
759 }
760 TELEPHONY_LOGI("CoreService::GetLockState(), lockType = %{public}d, slotId = %{public}d", lockType, slotId);
761 if (simManager_ == nullptr) {
762 TELEPHONY_LOGE("simManager_ is null");
763 return TELEPHONY_ERR_LOCAL_PTR_NULL;
764 }
765 return simManager_->GetLockState(slotId, lockType, lockState);
766 }
767
RefreshSimState(int32_t slotId)768 int32_t CoreService::RefreshSimState(int32_t slotId)
769 {
770 TELEPHONY_LOGD("CoreService::RefreshSimState(), slotId = %{public}d", slotId);
771 if (simManager_ == nullptr) {
772 TELEPHONY_LOGE("simManager_ is null");
773 return TELEPHONY_ERROR;
774 }
775 return simManager_->RefreshSimState(slotId);
776 }
777
SetActiveSim(int32_t slotId,int32_t enable)778 int32_t CoreService::SetActiveSim(int32_t slotId, int32_t enable)
779 {
780 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
781 TELEPHONY_LOGE("permission denied!");
782 return TELEPHONY_ERR_PERMISSION_ERR;
783 }
784 TELEPHONY_LOGD("CoreService::SetActiveSim(), slotId = %{public}d", slotId);
785 if (simManager_ == nullptr) {
786 TELEPHONY_LOGE("simManager_ is null");
787 return TELEPHONY_ERR_LOCAL_PTR_NULL;
788 }
789 return simManager_->SetActiveSim(slotId, enable);
790 }
791
GetPreferredNetwork(int32_t slotId,const sptr<INetworkSearchCallback> & callback)792 int32_t CoreService::GetPreferredNetwork(int32_t slotId, const sptr<INetworkSearchCallback> &callback)
793 {
794 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
795 TELEPHONY_LOGE("permission denied!");
796 return TELEPHONY_ERR_PERMISSION_ERR;
797 }
798 if (networkSearchManager_ == nullptr) {
799 TELEPHONY_LOGE("networkSearchManager_ is null");
800 return TELEPHONY_ERR_LOCAL_PTR_NULL;
801 }
802 return networkSearchManager_->GetPreferredNetwork(slotId, callback);
803 }
804
SetPreferredNetwork(int32_t slotId,int32_t networkMode,const sptr<INetworkSearchCallback> & callback)805 int32_t CoreService::SetPreferredNetwork(
806 int32_t slotId, int32_t networkMode, const sptr<INetworkSearchCallback> &callback)
807 {
808 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
809 TELEPHONY_LOGE("permission denied!");
810 return TELEPHONY_ERR_PERMISSION_ERR;
811 }
812 if (networkSearchManager_ == nullptr) {
813 TELEPHONY_LOGE("networkSearchManager_ is null");
814 return TELEPHONY_ERR_LOCAL_PTR_NULL;
815 }
816 return networkSearchManager_->SetPreferredNetwork(slotId, networkMode, callback);
817 }
818
GetSimTelephoneNumber(int32_t slotId,std::u16string & telephoneNumber)819 int32_t CoreService::GetSimTelephoneNumber(int32_t slotId, std::u16string &telephoneNumber)
820 {
821 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
822 TELEPHONY_LOGE("permission denied!");
823 return TELEPHONY_ERR_PERMISSION_ERR;
824 }
825 TELEPHONY_LOGD("CoreService::GetSimTelephoneNumber(), slotId = %{public}d", slotId);
826 if (simManager_ == nullptr) {
827 TELEPHONY_LOGE("simManager_ is null");
828 return TELEPHONY_ERR_LOCAL_PTR_NULL;
829 }
830 return simManager_->GetSimTelephoneNumber(slotId, telephoneNumber);
831 }
832
GetSimTeleNumberIdentifier(const int32_t slotId)833 std::u16string CoreService::GetSimTeleNumberIdentifier(const int32_t slotId)
834 {
835 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
836 TELEPHONY_LOGE("CoreService::GetSimTeleNumberIdentifier, Permission denied!");
837 return std::u16string();
838 }
839 TELEPHONY_LOGD("CoreService::GetSimTeleNumberIdentifier(), slotId = %{public}d", slotId);
840 if (simManager_ == nullptr) {
841 TELEPHONY_LOGE("simManager_ is null");
842 return std::u16string();
843 }
844 return simManager_->GetSimTeleNumberIdentifier(slotId);
845 }
846
GetVoiceMailIdentifier(int32_t slotId,std::u16string & voiceMailIdentifier)847 int32_t CoreService::GetVoiceMailIdentifier(int32_t slotId, std::u16string &voiceMailIdentifier)
848 {
849 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
850 TELEPHONY_LOGE("permission denied!");
851 return TELEPHONY_ERR_PERMISSION_ERR;
852 }
853 TELEPHONY_LOGD("CoreService::GetVoiceMailIdentifier(), slotId = %{public}d", slotId);
854 if (simManager_ == nullptr) {
855 TELEPHONY_LOGE("simManager_ is null");
856 return TELEPHONY_ERR_LOCAL_PTR_NULL;
857 }
858 return simManager_->GetVoiceMailIdentifier(slotId, voiceMailIdentifier);
859 }
860
GetVoiceMailNumber(int32_t slotId,std::u16string & voiceMailNumber)861 int32_t CoreService::GetVoiceMailNumber(int32_t slotId, std::u16string &voiceMailNumber)
862 {
863 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
864 TELEPHONY_LOGE("permission denied!");
865 return TELEPHONY_ERR_PERMISSION_ERR;
866 }
867 TELEPHONY_LOGD("CoreService::GetVoiceMailNumber(), slotId = %{public}d", slotId);
868 if (simManager_ == nullptr) {
869 TELEPHONY_LOGE("simManager_ is null");
870 return TELEPHONY_ERR_LOCAL_PTR_NULL;
871 }
872 return simManager_->GetVoiceMailNumber(slotId, voiceMailNumber);
873 }
874
QueryIccDiallingNumbers(int slotId,int type,std::vector<std::shared_ptr<DiallingNumbersInfo>> & reslut)875 int32_t CoreService::QueryIccDiallingNumbers(
876 int slotId, int type, std::vector<std::shared_ptr<DiallingNumbersInfo>> &reslut)
877 {
878 if (!TelephonyPermission::CheckPermission(Permission::READ_CONTACTS)) {
879 TELEPHONY_LOGE("permission denied!");
880 return TELEPHONY_ERR_PERMISSION_ERR;
881 }
882 TELEPHONY_LOGD("CoreService::QueryIccDiallingNumbers");
883 if (simManager_ == nullptr) {
884 TELEPHONY_LOGE("simManager_ is null");
885 return TELEPHONY_ERR_LOCAL_PTR_NULL;
886 }
887 return simManager_->QueryIccDiallingNumbers(slotId, type, reslut);
888 }
889
AddIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)890 int32_t CoreService::AddIccDiallingNumbers(
891 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
892 {
893 if (!TelephonyPermission::CheckPermission(Permission::WRITE_CONTACTS)) {
894 TELEPHONY_LOGE("permission denied!");
895 return TELEPHONY_ERR_PERMISSION_ERR;
896 }
897 TELEPHONY_LOGD("CoreService::AddIccDiallingNumbers");
898 if (simManager_ == nullptr) {
899 TELEPHONY_LOGE("simManager_ is null");
900 return TELEPHONY_ERR_LOCAL_PTR_NULL;
901 }
902 return simManager_->AddIccDiallingNumbers(slotId, type, diallingNumber);
903 }
904
DelIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)905 int32_t CoreService::DelIccDiallingNumbers(
906 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
907 {
908 if (!TelephonyPermission::CheckPermission(Permission::WRITE_CONTACTS)) {
909 TELEPHONY_LOGE("permission denied!");
910 return TELEPHONY_ERR_PERMISSION_ERR;
911 }
912 TELEPHONY_LOGD("CoreService::DelIccDiallingNumbers");
913 if (simManager_ == nullptr) {
914 TELEPHONY_LOGE("simManager_ is null");
915 return TELEPHONY_ERR_LOCAL_PTR_NULL;
916 }
917 return simManager_->DelIccDiallingNumbers(slotId, type, diallingNumber);
918 }
919
UpdateIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)920 int32_t CoreService::UpdateIccDiallingNumbers(
921 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
922 {
923 if (!TelephonyPermission::CheckPermission(Permission::WRITE_CONTACTS)) {
924 TELEPHONY_LOGE("permission denied!");
925 return TELEPHONY_ERR_PERMISSION_ERR;
926 }
927 TELEPHONY_LOGD("CoreService::UpdateIccDiallingNumbers");
928 if (simManager_ == nullptr) {
929 TELEPHONY_LOGE("simManager_ is null");
930 return TELEPHONY_ERR_LOCAL_PTR_NULL;
931 }
932 return simManager_->UpdateIccDiallingNumbers(slotId, type, diallingNumber);
933 }
934
SetVoiceMailInfo(const int32_t slotId,const std::u16string & mailName,const std::u16string & mailNumber)935 int32_t CoreService::SetVoiceMailInfo(
936 const int32_t slotId, const std::u16string &mailName, const std::u16string &mailNumber)
937 {
938 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
939 TELEPHONY_LOGE("permission denied!");
940 return TELEPHONY_ERR_PERMISSION_ERR;
941 }
942 TELEPHONY_LOGD("CoreService::SetVoiceMailInfo(), slotId = %{public}d", slotId);
943 if (simManager_ == nullptr) {
944 TELEPHONY_LOGE("simManager_ is null");
945 return TELEPHONY_ERR_LOCAL_PTR_NULL;
946 }
947 return simManager_->SetVoiceMailInfo(slotId, mailName, mailNumber);
948 }
949
GetMaxSimCount()950 int32_t CoreService::GetMaxSimCount()
951 {
952 char simSlotCount[SYSPARA_SIZE] = { 0 };
953 GetParameter(TEL_SIM_SLOT_COUNT, DEFAULT_SLOT_COUNT, simSlotCount, SYSPARA_SIZE);
954 int32_t slotCount = std::atoi(simSlotCount);
955 return slotCount;
956 }
957
GetOpKey(int32_t slotId,std::u16string & opkey)958 int32_t CoreService::GetOpKey(int32_t slotId, std::u16string &opkey)
959 {
960 TELEPHONY_LOGD("CoreService::GetOpKey(), slotId = %{public}d", slotId);
961 if (simManager_ == nullptr) {
962 TELEPHONY_LOGE("simManager_ is null");
963 return TELEPHONY_ERR_LOCAL_PTR_NULL;
964 }
965 return simManager_->GetOpKey(slotId, opkey);
966 }
967
GetOpKeyExt(int32_t slotId,std::u16string & opkeyExt)968 int32_t CoreService::GetOpKeyExt(int32_t slotId, std::u16string &opkeyExt)
969 {
970 TELEPHONY_LOGD("CoreService::GetOpKeyExt(), slotId = %{public}d", slotId);
971 if (simManager_ == nullptr) {
972 TELEPHONY_LOGE("simManager_ is null");
973 return TELEPHONY_ERR_LOCAL_PTR_NULL;
974 }
975 return simManager_->GetOpKeyExt(slotId, opkeyExt);
976 }
977
GetOpName(int32_t slotId,std::u16string & opname)978 int32_t CoreService::GetOpName(int32_t slotId, std::u16string &opname)
979 {
980 TELEPHONY_LOGD("CoreService::GetOpName(), slotId = %{public}d", slotId);
981 if (simManager_ == nullptr) {
982 TELEPHONY_LOGE("simManager_ is null");
983 return TELEPHONY_ERR_LOCAL_PTR_NULL;
984 }
985 return simManager_->GetOpName(slotId, opname);
986 }
987
SendEnvelopeCmd(int32_t slotId,const std::string & cmd)988 int32_t CoreService::SendEnvelopeCmd(int32_t slotId, const std::string &cmd)
989 {
990 if (simManager_ == nullptr) {
991 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd simManager_ is nullptr");
992 return TELEPHONY_ERR_LOCAL_PTR_NULL;
993 }
994 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
995 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd, Permission denied!");
996 return TELEPHONY_ERR_PERMISSION_ERR;
997 }
998 TELEPHONY_LOGD("CoreService::SendEnvelopeCmd(), slotId = %{public}d", slotId);
999 return simManager_->SendEnvelopeCmd(slotId, cmd);
1000 }
1001
SendTerminalResponseCmd(int32_t slotId,const std::string & cmd)1002 int32_t CoreService::SendTerminalResponseCmd(int32_t slotId, const std::string &cmd)
1003 {
1004 if (simManager_ == nullptr) {
1005 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd simManager_ is nullptr");
1006 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1007 }
1008 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1009 TELEPHONY_LOGE("CoreService::SendTerminalResponseCmd, Permission denied!");
1010 return TELEPHONY_ERR_PERMISSION_ERR;
1011 }
1012 TELEPHONY_LOGD("CoreService::SendTerminalResponseCmd(), slotId = %{public}d", slotId);
1013 return simManager_->SendTerminalResponseCmd(slotId, cmd);
1014 }
1015
SendCallSetupRequestResult(int32_t slotId,bool accept)1016 int32_t CoreService::SendCallSetupRequestResult(int32_t slotId, bool accept)
1017 {
1018 if (simManager_ == nullptr) {
1019 TELEPHONY_LOGE("CoreService::SendEnvelopeCmd simManager_ is nullptr");
1020 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1021 }
1022 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1023 TELEPHONY_LOGE("CoreService::SendCallSetupRequestResult, Permission denied!");
1024 return TELEPHONY_ERR_PERMISSION_ERR;
1025 }
1026 TELEPHONY_LOGD("CoreService::SendCallSetupRequestResult(), slotId = %{public}d", slotId);
1027 return simManager_->SendCallSetupRequestResult(slotId, accept);
1028 }
1029
UnlockSimLock(int32_t slotId,const PersoLockInfo & lockInfo,LockStatusResponse & response)1030 int32_t CoreService::UnlockSimLock(int32_t slotId, const PersoLockInfo &lockInfo, LockStatusResponse &response)
1031 {
1032 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
1033 TELEPHONY_LOGE("permission denied!");
1034 return TELEPHONY_ERR_PERMISSION_ERR;
1035 }
1036 TELEPHONY_LOGI(
1037 "CoreService::UnlockSimLock(), lockType = %{public}d, slotId = %{public}d", lockInfo.lockType, slotId);
1038 if (simManager_ == nullptr) {
1039 TELEPHONY_LOGE("simManager_ is null");
1040 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1041 }
1042 return simManager_->UnlockSimLock(slotId, lockInfo, response);
1043 }
1044
GetImsRegStatus(int32_t slotId,ImsServiceType imsSrvType,ImsRegInfo & info)1045 int32_t CoreService::GetImsRegStatus(int32_t slotId, ImsServiceType imsSrvType, ImsRegInfo &info)
1046 {
1047 TELEPHONY_LOGI("CoreService::GetImsRegStatus --> slotId:%{public}d, imsSrvType:%{public}d", slotId, imsSrvType);
1048 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1049 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1050 return TELEPHONY_ERR_PERMISSION_ERR;
1051 }
1052 if (networkSearchManager_ == nullptr) {
1053 TELEPHONY_LOGE("failed! network search manager is nullptr!");
1054 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1055 }
1056 return networkSearchManager_->GetImsRegStatus(slotId, imsSrvType, info);
1057 }
1058
GetCellInfoList(int32_t slotId,std::vector<sptr<CellInformation>> & cellInfo)1059 int32_t CoreService::GetCellInfoList(int32_t slotId, std::vector<sptr<CellInformation>> &cellInfo)
1060 {
1061 if (!TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
1062 return TELEPHONY_ERR_PERMISSION_ERR;
1063 }
1064 if (networkSearchManager_ == nullptr) {
1065 TELEPHONY_LOGE("networkSearchManager_ is null");
1066 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1067 }
1068 return networkSearchManager_->GetCellInfoList(slotId, cellInfo);
1069 }
1070
SendUpdateCellLocationRequest(int32_t slotId)1071 int32_t CoreService::SendUpdateCellLocationRequest(int32_t slotId)
1072 {
1073 if (!TelephonyPermission::CheckPermission(Permission::CELL_LOCATION)) {
1074 TELEPHONY_LOGE("CoreService::SendUpdateCellLocationRequest, Permission denied!");
1075 return TELEPHONY_ERR_PERMISSION_ERR;
1076 }
1077 if (networkSearchManager_ == nullptr) {
1078 TELEPHONY_LOGE("networkSearchManager_ is null");
1079 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1080 }
1081 return networkSearchManager_->SendUpdateCellLocationRequest(slotId);
1082 }
1083
HasOperatorPrivileges(const int32_t slotId,bool & hasOperatorPrivileges)1084 int32_t CoreService::HasOperatorPrivileges(const int32_t slotId, bool &hasOperatorPrivileges)
1085 {
1086 TELEPHONY_LOGD("CoreService::HasOperatorPrivileges(), slotId = %{public}d", slotId);
1087 if (simManager_ == nullptr) {
1088 TELEPHONY_LOGE("simManager_ is null");
1089 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1090 }
1091 return simManager_->HasOperatorPrivileges(slotId, hasOperatorPrivileges);
1092 }
1093
SimAuthentication(int32_t slotId,const std::string & aid,const std::string & authData,SimAuthenticationResponse & response)1094 int32_t CoreService::SimAuthentication(
1095 int32_t slotId, const std::string &aid, const std::string &authData, SimAuthenticationResponse &response)
1096 {
1097 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1098 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1099 return TELEPHONY_ERR_PERMISSION_ERR;
1100 }
1101 TELEPHONY_LOGD("CoreService::SimAuthentication(), slotId = %{public}d", slotId);
1102 if (simManager_ == nullptr) {
1103 TELEPHONY_LOGE("simManager_ is null");
1104 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1105 }
1106 return simManager_->SimAuthentication(slotId, aid, authData, response);
1107 }
1108
RegisterImsRegInfoCallback(int32_t slotId,ImsServiceType imsSrvType,const sptr<ImsRegInfoCallback> & callback)1109 int32_t CoreService::RegisterImsRegInfoCallback(
1110 int32_t slotId, ImsServiceType imsSrvType, const sptr<ImsRegInfoCallback> &callback)
1111 {
1112 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1113 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1114 return TELEPHONY_ERR_PERMISSION_ERR;
1115 }
1116 if (networkSearchManager_ == nullptr) {
1117 TELEPHONY_LOGE("failed! network search manager is nullptr!");
1118 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1119 }
1120 return networkSearchManager_->RegisterImsRegInfoCallback(slotId, imsSrvType, GetBundleName(), callback);
1121 }
1122
UnregisterImsRegInfoCallback(int32_t slotId,ImsServiceType imsSrvType)1123 int32_t CoreService::UnregisterImsRegInfoCallback(int32_t slotId, ImsServiceType imsSrvType)
1124 {
1125 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
1126 TELEPHONY_LOGE("Failed because no permission:GET_TELEPHONY_STATE");
1127 return TELEPHONY_ERR_PERMISSION_ERR;
1128 }
1129 if (networkSearchManager_ == nullptr) {
1130 TELEPHONY_LOGE("failed! network search manager is nullptr!");
1131 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1132 }
1133 return networkSearchManager_->UnregisterImsRegInfoCallback(slotId, imsSrvType, GetBundleName());
1134 }
1135
Dump(std::int32_t fd,const std::vector<std::u16string> & args)1136 int32_t CoreService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
1137 {
1138 if (fd < 0) {
1139 TELEPHONY_LOGE("dump fd invalid");
1140 return TELEPHONY_ERR_ARGUMENT_INVALID;
1141 }
1142 std::vector<std::string> argsInStr;
1143 for (const auto &arg : args) {
1144 TELEPHONY_LOGI("Dump args: %s", Str16ToStr8(arg).c_str());
1145 argsInStr.emplace_back(Str16ToStr8(arg));
1146 }
1147 std::string result;
1148 CoreServiceDumpHelper dumpHelper;
1149 if (dumpHelper.Dump(argsInStr, result)) {
1150 TELEPHONY_LOGI("%s", result.c_str());
1151 std::int32_t ret = dprintf(fd, "%s", result.c_str());
1152 if (ret < 0) {
1153 TELEPHONY_LOGE("dprintf to dump fd failed");
1154 return TELEPHONY_ERROR;
1155 }
1156 return 0;
1157 }
1158 TELEPHONY_LOGW("dumpHelper failed");
1159 return TELEPHONY_ERROR;
1160 }
1161
GetBindTime()1162 int64_t CoreService::GetBindTime()
1163 {
1164 return bindTime_;
1165 }
1166
GetEndTime()1167 int64_t CoreService::GetEndTime()
1168 {
1169 return endTime_;
1170 }
1171
GetSpendTime()1172 int64_t CoreService::GetSpendTime()
1173 {
1174 return endTime_ - bindTime_;
1175 }
1176 } // namespace Telephony
1177 } // namespace OHOS
1178