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 "sim_manager.h"
17
18 #include "core_service_errors.h"
19 #include "radio_event.h"
20 #include "telephony_errors.h"
21
22 namespace OHOS {
23 namespace Telephony {
SimManager(std::shared_ptr<ITelRilManager> telRilManager)24 SimManager::SimManager(std::shared_ptr<ITelRilManager> telRilManager) : telRilManager_(telRilManager)
25 {
26 TELEPHONY_LOGI("SimManager::SimManager()");
27 }
28
~SimManager()29 SimManager::~SimManager() {}
30
OnInit(int32_t slotCount)31 bool SimManager::OnInit(int32_t slotCount)
32 {
33 TELEPHONY_LOGI("SimManager OnInit, slotCount = %{public}d", slotCount);
34 slotCount_ = slotCount;
35 InitMultiSimObject();
36 InitSingleSimObject();
37 TELEPHONY_LOGD("SimManager OnInit success");
38 return true;
39 }
40
InitMultiSimObject()41 void SimManager::InitMultiSimObject()
42 {
43 // Program memory
44 simStateManager_.resize(slotCount_);
45 simFileManager_.resize(slotCount_);
46 simSmsManager_.resize(slotCount_);
47 simAccountManager_.resize(slotCount_);
48 iccDiallingNumbersManager_.resize(slotCount_);
49 stkManager_.resize(slotCount_);
50 // Many card create
51 for (int32_t slotId = 0; slotId < slotCount_; slotId++) {
52 simStateManager_[slotId] = std::make_shared<SimStateManager>(telRilManager_);
53 if (simStateManager_[slotId] != nullptr) {
54 simStateManager_[slotId]->Init(slotId);
55 }
56 simFileManager_[slotId] = SimFileManager::CreateInstance(std::weak_ptr<ITelRilManager>(telRilManager_),
57 std::weak_ptr<Telephony::SimStateManager>(simStateManager_[slotId]));
58 if (simFileManager_[slotId] != nullptr) {
59 simFileManager_[slotId]->Init(slotId);
60 }
61 simSmsManager_[slotId] =
62 std::make_shared<SimSmsManager>(telRilManager_, simFileManager_[slotId], simStateManager_[slotId]);
63 if (simSmsManager_[slotId] != nullptr) {
64 simSmsManager_[slotId]->Init(slotId);
65 }
66 simAccountManager_[slotId] =
67 std::make_shared<SimAccountManager>(telRilManager_, simStateManager_[slotId], simFileManager_[slotId]);
68 if (simAccountManager_[slotId] != nullptr) {
69 simAccountManager_[slotId]->Init(slotId);
70 }
71 iccDiallingNumbersManager_[slotId] = IccDiallingNumbersManager::CreateInstance(
72 std::weak_ptr<SimFileManager>(simFileManager_[slotId]), simStateManager_[slotId]);
73 if (iccDiallingNumbersManager_[slotId] != nullptr) {
74 iccDiallingNumbersManager_[slotId]->Init();
75 }
76 stkManager_[slotId] = std::make_shared<StkManager>(telRilManager_, simStateManager_[slotId]);
77 if (stkManager_[slotId] != nullptr) {
78 stkManager_[slotId]->Init(slotId);
79 }
80 if (simStateManager_[slotId] != nullptr) {
81 simStateManager_[slotId]->RefreshSimState(slotId);
82 }
83 }
84 }
85
InitSingleSimObject()86 void SimManager::InitSingleSimObject()
87 {
88 multiSimController_ = std::make_shared<MultiSimController>(telRilManager_, simStateManager_, simFileManager_);
89 if (multiSimController_ == nullptr) {
90 TELEPHONY_LOGE("SimManager::InitSingleSimObject multiSimController init failed");
91 return;
92 }
93 multiSimController_->Init();
94 std::vector<std::weak_ptr<Telephony::SimFileManager>> simFileManager;
95 for (auto simFile : simFileManager_) {
96 simFileManager.push_back(std::weak_ptr<Telephony::SimFileManager>(simFile));
97 }
98 multiSimMonitor_ = std::make_shared<MultiSimMonitor>(multiSimController_, simStateManager_, simFileManager);
99 if (multiSimMonitor_ == nullptr) {
100 TELEPHONY_LOGE("SimAccountManager:: multiSimMonitor is null");
101 return;
102 }
103 multiSimMonitor_->Init();
104 }
105
HasSimCard(int32_t slotId,bool & hasSimCard)106 int32_t SimManager::HasSimCard(int32_t slotId, bool &hasSimCard)
107 {
108 if ((!IsValidSlotId(slotId)) || (simStateManager_[slotId] == nullptr)) {
109 TELEPHONY_LOGE("simStateManager is null!");
110 return TELEPHONY_ERR_LOCAL_PTR_NULL;
111 }
112 if (simStateManager_[slotId]->HasSimCard()) {
113 hasSimCard = true;
114 return TELEPHONY_ERR_SUCCESS;
115 }
116 return TELEPHONY_ERR_SUCCESS;
117 }
118
HasSimCardInner(int32_t slotId)119 bool SimManager::HasSimCardInner(int32_t slotId)
120 {
121 bool hasSimCard = false;
122 HasSimCard(slotId, hasSimCard);
123 return hasSimCard;
124 }
125
GetSimState(int32_t slotId,SimState & simState)126 int32_t SimManager::GetSimState(int32_t slotId, SimState &simState)
127 {
128 if (!HasSimCardInner(slotId)) {
129 simState = SimState::SIM_STATE_NOT_PRESENT;
130 return TELEPHONY_ERR_SUCCESS;
131 }
132 simState = simStateManager_[slotId]->GetSimState();
133 return TELEPHONY_ERR_SUCCESS;
134 }
135
GetCardType(int32_t slotId,CardType & cardType)136 int32_t SimManager::GetCardType(int32_t slotId, CardType &cardType)
137 {
138 if (!HasSimCardInner(slotId)) {
139 TELEPHONY_LOGE("GetCardType has no sim card!");
140 return TELEPHONY_ERR_NO_SIM_CARD;
141 }
142 cardType = simStateManager_[slotId]->GetCardType();
143 return TELEPHONY_ERR_SUCCESS;
144 }
145
UnlockPin(int32_t slotId,const std::string & pin,LockStatusResponse & response)146 int32_t SimManager::UnlockPin(int32_t slotId, const std::string &pin, LockStatusResponse &response)
147 {
148 if (!HasSimCardInner(slotId)) {
149 TELEPHONY_LOGE("UnlockPin has no sim card!");
150 return TELEPHONY_ERR_NO_SIM_CARD;
151 }
152 return simStateManager_[slotId]->UnlockPin(slotId, pin, response);
153 }
154
UnlockPuk(int32_t slotId,const std::string & newPin,const std::string & puk,LockStatusResponse & response)155 int32_t SimManager::UnlockPuk(
156 int32_t slotId, const std::string &newPin, const std::string &puk, LockStatusResponse &response)
157 {
158 if (!HasSimCardInner(slotId)) {
159 TELEPHONY_LOGE("UnlockPuk has no sim card!");
160 return TELEPHONY_ERR_NO_SIM_CARD;
161 }
162 return simStateManager_[slotId]->UnlockPuk(slotId, newPin, puk, response);
163 }
164
AlterPin(int32_t slotId,const std::string & newPin,const std::string & oldPin,LockStatusResponse & response)165 int32_t SimManager::AlterPin(
166 int32_t slotId, const std::string &newPin, const std::string &oldPin, LockStatusResponse &response)
167 {
168 if (!HasSimCardInner(slotId)) {
169 TELEPHONY_LOGE("AlterPin has no sim card!");
170 return TELEPHONY_ERR_NO_SIM_CARD;
171 }
172 return simStateManager_[slotId]->AlterPin(slotId, newPin, oldPin, response);
173 }
174
SetLockState(int32_t slotId,const LockInfo & options,LockStatusResponse & response)175 int32_t SimManager::SetLockState(int32_t slotId, const LockInfo &options, LockStatusResponse &response)
176 {
177 if (!HasSimCardInner(slotId)) {
178 TELEPHONY_LOGE("SetLockState has no sim card!");
179 return TELEPHONY_ERR_NO_SIM_CARD;
180 }
181 return simStateManager_[slotId]->SetLockState(slotId, options, response);
182 }
183
GetLockState(int32_t slotId,LockType lockType,LockState & lockState)184 int32_t SimManager::GetLockState(int32_t slotId, LockType lockType, LockState &lockState)
185 {
186 if (!HasSimCardInner(slotId)) {
187 TELEPHONY_LOGE("GetLockState has no sim card!");
188 return TELEPHONY_ERR_NO_SIM_CARD;
189 }
190 return simStateManager_[slotId]->GetLockState(slotId, lockType, lockState);
191 }
192
RefreshSimState(int32_t slotId)193 int32_t SimManager::RefreshSimState(int32_t slotId)
194 {
195 if ((!IsValidSlotId(slotId)) || (simStateManager_[slotId] == nullptr)) {
196 TELEPHONY_LOGE("simStateManager is null!");
197 return TELEPHONY_ERROR;
198 }
199 return simStateManager_[slotId]->RefreshSimState(slotId);
200 }
201
UnlockPin2(int32_t slotId,const std::string & pin2,LockStatusResponse & response)202 int32_t SimManager::UnlockPin2(int32_t slotId, const std::string &pin2, LockStatusResponse &response)
203 {
204 if (!HasSimCardInner(slotId)) {
205 TELEPHONY_LOGE("UnlockPin2 has no sim card!");
206 return TELEPHONY_ERR_NO_SIM_CARD;
207 }
208 return simStateManager_[slotId]->UnlockPin2(slotId, pin2, response);
209 }
210
UnlockPuk2(int32_t slotId,const std::string & newPin2,const std::string & puk2,LockStatusResponse & response)211 int32_t SimManager::UnlockPuk2(
212 int32_t slotId, const std::string &newPin2, const std::string &puk2, LockStatusResponse &response)
213 {
214 if (!HasSimCardInner(slotId)) {
215 TELEPHONY_LOGE("UnlockPuk2 has no sim card!");
216 return TELEPHONY_ERR_NO_SIM_CARD;
217 }
218 return simStateManager_[slotId]->UnlockPuk2(slotId, newPin2, puk2, response);
219 }
220
AlterPin2(int32_t slotId,const std::string & newPin2,const std::string & oldPin2,LockStatusResponse & response)221 int32_t SimManager::AlterPin2(
222 int32_t slotId, const std::string &newPin2, const std::string &oldPin2, LockStatusResponse &response)
223 {
224 if (!HasSimCardInner(slotId)) {
225 TELEPHONY_LOGE("AlterPin2 has no sim card!");
226 return TELEPHONY_ERR_NO_SIM_CARD;
227 }
228 return simStateManager_[slotId]->AlterPin2(slotId, newPin2, oldPin2, response);
229 }
230
UnlockSimLock(int32_t slotId,const PersoLockInfo & lockInfo,LockStatusResponse & response)231 int32_t SimManager::UnlockSimLock(int32_t slotId, const PersoLockInfo &lockInfo, LockStatusResponse &response)
232 {
233 if (!HasSimCardInner(slotId)) {
234 TELEPHONY_LOGE("UnlockSimLock has no sim card!");
235 return TELEPHONY_ERR_NO_SIM_CARD;
236 }
237 return simStateManager_[slotId]->UnlockSimLock(slotId, lockInfo, response);
238 }
239
IsSimActive(int32_t slotId)240 bool SimManager::IsSimActive(int32_t slotId)
241 {
242 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
243 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
244 return false;
245 }
246 return multiSimController_->IsSimActive(slotId);
247 }
248
SetActiveSim(int32_t slotId,int32_t enable)249 int32_t SimManager::SetActiveSim(int32_t slotId, int32_t enable)
250 {
251 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
252 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
253 return TELEPHONY_ERR_LOCAL_PTR_NULL;
254 }
255 int32_t ret = multiSimController_->SetActiveSim(slotId, enable);
256 if (ret == TELEPHONY_ERR_SUCCESS && multiSimMonitor_ != nullptr) {
257 multiSimMonitor_->NotifySimAccountChanged();
258 }
259 return ret;
260 }
261
GetSimAccountInfo(int32_t slotId,bool denied,IccAccountInfo & info)262 int32_t SimManager::GetSimAccountInfo(int32_t slotId, bool denied, IccAccountInfo &info)
263 {
264 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
265 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
266 return TELEPHONY_ERR_LOCAL_PTR_NULL;
267 }
268 return multiSimController_->GetSimAccountInfo(slotId, denied, info);
269 }
270
SetDefaultVoiceSlotId(int32_t slotId)271 int32_t SimManager::SetDefaultVoiceSlotId(int32_t slotId)
272 {
273 if (!IsValidSlotIdForDefault(slotId)) {
274 TELEPHONY_LOGE("slotId is invalid for default.");
275 return TELEPHONY_ERR_SLOTID_INVALID;
276 }
277 if (multiSimController_ == nullptr) {
278 TELEPHONY_LOGE("multiSimController_ is nullptr.");
279 return TELEPHONY_ERR_LOCAL_PTR_NULL;
280 }
281 int32_t ret = multiSimController_->SetDefaultVoiceSlotId(slotId);
282 if (ret == TELEPHONY_ERR_SUCCESS && multiSimMonitor_ != nullptr) {
283 multiSimMonitor_->NotifySimAccountChanged();
284 }
285 return ret;
286 }
287
SetDefaultSmsSlotId(int32_t slotId)288 int32_t SimManager::SetDefaultSmsSlotId(int32_t slotId)
289 {
290 if (!IsValidSlotIdForDefault(slotId)) {
291 TELEPHONY_LOGE("slotId is invalid for default.");
292 return TELEPHONY_ERR_SLOTID_INVALID;
293 }
294 if (multiSimController_ == nullptr) {
295 TELEPHONY_LOGE("multiSimController_ is nullptr.");
296 return TELEPHONY_ERR_LOCAL_PTR_NULL;
297 }
298 int32_t ret = multiSimController_->SetDefaultSmsSlotId(slotId);
299 if (ret == TELEPHONY_ERR_SUCCESS && multiSimMonitor_ != nullptr) {
300 multiSimMonitor_->NotifySimAccountChanged();
301 }
302 return ret;
303 }
304
SetDefaultCellularDataSlotId(int32_t slotId)305 int32_t SimManager::SetDefaultCellularDataSlotId(int32_t slotId)
306 {
307 if (!IsValidSlotId(slotId)) {
308 TELEPHONY_LOGE("slotId is invalid for default.");
309 return TELEPHONY_ERR_SLOTID_INVALID;
310 }
311 if (multiSimController_ == nullptr) {
312 TELEPHONY_LOGE("multiSimController_ is nullptr.");
313 return TELEPHONY_ERR_LOCAL_PTR_NULL;
314 }
315 int32_t ret = multiSimController_->SetDefaultCellularDataSlotId(slotId);
316 if (ret == TELEPHONY_ERR_SUCCESS && multiSimMonitor_ != nullptr) {
317 multiSimMonitor_->NotifySimAccountChanged();
318 }
319 return ret;
320 }
321
SetPrimarySlotId(int32_t slotId)322 int32_t SimManager::SetPrimarySlotId(int32_t slotId)
323 {
324 if (!IsValidSlotId(slotId)) {
325 TELEPHONY_LOGE("slotId is invalid for default.");
326 return TELEPHONY_ERR_SLOTID_INVALID;
327 }
328 if (multiSimController_ == nullptr) {
329 TELEPHONY_LOGE("multiSimController_ is nullptr.");
330 return TELEPHONY_ERR_LOCAL_PTR_NULL;
331 }
332 int32_t ret = multiSimController_->SetPrimarySlotId(slotId);
333 if (ret == TELEPHONY_ERR_SUCCESS && multiSimMonitor_ != nullptr) {
334 multiSimMonitor_->NotifySimAccountChanged();
335 }
336 return ret;
337 }
338
SetShowNumber(int32_t slotId,const std::u16string & number)339 int32_t SimManager::SetShowNumber(int32_t slotId, const std::u16string &number)
340 {
341 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
342 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
343 return TELEPHONY_ERR_LOCAL_PTR_NULL;
344 }
345 return multiSimController_->SetShowNumber(slotId, number);
346 }
347
SetShowName(int32_t slotId,const std::u16string & name)348 int32_t SimManager::SetShowName(int32_t slotId, const std::u16string &name)
349 {
350 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
351 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
352 return TELEPHONY_ERR_LOCAL_PTR_NULL;
353 }
354 return multiSimController_->SetShowName(slotId, name);
355 }
356
GetDefaultVoiceSlotId()357 int32_t SimManager::GetDefaultVoiceSlotId()
358 {
359 if (slotCount_ == std::atoi(DEFAULT_SLOT_COUNT)) {
360 TELEPHONY_LOGI("default slotId is 0 for single card version");
361 return DEFAULT_SIM_SLOT_ID;
362 }
363 if (multiSimController_ == nullptr) {
364 TELEPHONY_LOGE("multiSimController_ is nullptr");
365 return TELEPHONY_ERROR;
366 }
367 return multiSimController_->GetDefaultVoiceSlotId();
368 }
369
GetDefaultVoiceSimId(int32_t & simId)370 int32_t SimManager::GetDefaultVoiceSimId(int32_t &simId)
371 {
372 if (multiSimController_ == nullptr) {
373 TELEPHONY_LOGE("multiSimController_ is nullptr");
374 return TELEPHONY_ERR_LOCAL_PTR_NULL;
375 }
376 int32_t result = multiSimController_->GetDefaultVoiceSlotId();
377 if (result < DEFAULT_SIM_SLOT_ID) {
378 TELEPHONY_LOGI("DefaultVoiceSlotId is invalid");
379 simId = INVALID_VALUE;
380 return TELEPHONY_ERR_SUCCESS;
381 }
382 int32_t defaultSimId = GetSimId(result);
383 if (defaultSimId <= DEFAULT_SIM_SLOT_ID) {
384 TELEPHONY_LOGI("simId is invalid");
385 simId = INVALID_VALUE;
386 } else {
387 simId = defaultSimId;
388 }
389 return TELEPHONY_ERR_SUCCESS;
390 }
391
GetDefaultSmsSlotId()392 int32_t SimManager::GetDefaultSmsSlotId()
393 {
394 if (slotCount_ == std::atoi(DEFAULT_SLOT_COUNT)) {
395 TELEPHONY_LOGI("default slotId is 0 for single card version");
396 return DEFAULT_SIM_SLOT_ID;
397 }
398 if (multiSimController_ == nullptr) {
399 TELEPHONY_LOGE("multiSimController_ is nullptr");
400 return TELEPHONY_ERROR;
401 }
402 return multiSimController_->GetDefaultSmsSlotId();
403 }
404
GetDefaultSmsSimId(int32_t & simId)405 int32_t SimManager::GetDefaultSmsSimId(int32_t &simId)
406 {
407 if (multiSimController_ == nullptr) {
408 TELEPHONY_LOGE("multiSimController_ is nullptr");
409 return TELEPHONY_ERR_LOCAL_PTR_NULL;
410 }
411 int32_t result = multiSimController_->GetDefaultSmsSlotId();
412 if (result < DEFAULT_SIM_SLOT_ID) {
413 TELEPHONY_LOGI("DefaultSmsSlotId is invalid");
414 simId = INVALID_VALUE;
415 return TELEPHONY_ERR_SUCCESS;
416 }
417 int32_t defaultSimId = GetSimId(result);
418 if (defaultSimId <= DEFAULT_SIM_SLOT_ID) {
419 TELEPHONY_LOGI("simId is invalid");
420 simId = INVALID_VALUE;
421 } else {
422 simId = defaultSimId;
423 }
424 return TELEPHONY_ERR_SUCCESS;
425 }
426
GetDefaultCellularDataSlotId()427 int32_t SimManager::GetDefaultCellularDataSlotId()
428 {
429 if (slotCount_ == std::atoi(DEFAULT_SLOT_COUNT)) {
430 TELEPHONY_LOGI("default slotId is 0 for single card version");
431 return DEFAULT_SIM_SLOT_ID;
432 }
433 if (multiSimController_ == nullptr) {
434 TELEPHONY_LOGE("multiSimController_ is nullptr");
435 return TELEPHONY_ERROR;
436 }
437 return multiSimController_->GetDefaultCellularDataSlotId();
438 }
439
GetDefaultCellularDataSimId(int32_t & simId)440 int32_t SimManager::GetDefaultCellularDataSimId(int32_t &simId)
441 {
442 if (multiSimController_ == nullptr) {
443 TELEPHONY_LOGE("multiSimController_ is nullptr");
444 return TELEPHONY_ERR_LOCAL_PTR_NULL;
445 }
446 int32_t result = multiSimController_->GetDefaultCellularDataSlotId();
447 if (result < DEFAULT_SIM_SLOT_ID) {
448 TELEPHONY_LOGE("DefaultCellularDataSlotId is invalid");
449 return TELEPHONY_ERR_NO_SIM_CARD;
450 }
451 int32_t defaultSimId = GetSimId(result);
452 if (defaultSimId <= DEFAULT_SIM_SLOT_ID) {
453 TELEPHONY_LOGE("simId is invalid");
454 return TELEPHONY_ERR_FAIL;
455 }
456 simId = defaultSimId;
457 return TELEPHONY_ERR_SUCCESS;
458 }
459
GetDsdsMode(int32_t & dsdsMode)460 int32_t SimManager::GetDsdsMode(int32_t &dsdsMode)
461 {
462 if (slotCount_ == std::atoi(DEFAULT_SLOT_COUNT)) {
463 TELEPHONY_LOGI(" default dsds mode is 0 for single card version");
464 dsdsMode = DSDS_MODE_V2;
465 return TELEPHONY_ERR_SUCCESS;
466 }
467 dsdsMode = dsdsMode_;
468 return TELEPHONY_ERR_SUCCESS;
469 }
470
SetDsdsMode(int32_t dsdsMode)471 int32_t SimManager::SetDsdsMode(int32_t dsdsMode)
472 {
473 dsdsMode_ = dsdsMode;
474 return TELEPHONY_ERR_SUCCESS;
475 }
476
GetPrimarySlotId(int32_t & slotId)477 int32_t SimManager::GetPrimarySlotId(int32_t &slotId)
478 {
479 if (slotCount_ == std::atoi(DEFAULT_SLOT_COUNT)) {
480 TELEPHONY_LOGI(" default slotId is 0 for single card version");
481 slotId = DEFAULT_SIM_SLOT_ID;
482 return TELEPHONY_ERR_SUCCESS;
483 }
484 if (multiSimController_ == nullptr) {
485 TELEPHONY_LOGE("multiSimController_ is nullptr");
486 return TELEPHONY_ERR_LOCAL_PTR_NULL;
487 }
488 slotId = multiSimController_->GetPrimarySlotId();
489 return TELEPHONY_ERR_SUCCESS;
490 }
491
GetShowNumber(int32_t slotId,std::u16string & showNumber)492 int32_t SimManager::GetShowNumber(int32_t slotId, std::u16string &showNumber)
493 {
494 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
495 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
496 return TELEPHONY_ERR_LOCAL_PTR_NULL;
497 }
498 return multiSimController_->GetShowNumber(slotId, showNumber);
499 }
500
GetShowName(int32_t slotId,std::u16string & showName)501 int32_t SimManager::GetShowName(int32_t slotId, std::u16string &showName)
502 {
503 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
504 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
505 return TELEPHONY_ERR_LOCAL_PTR_NULL;
506 }
507 return multiSimController_->GetShowName(slotId, showName);
508 }
509
GetActiveSimAccountInfoList(bool denied,std::vector<IccAccountInfo> & iccAccountInfoList)510 int32_t SimManager::GetActiveSimAccountInfoList(bool denied, std::vector<IccAccountInfo> &iccAccountInfoList)
511 {
512 if (multiSimController_ == nullptr) {
513 TELEPHONY_LOGE("multiSimController_ is nullptr");
514 return TELEPHONY_ERR_LOCAL_PTR_NULL;
515 }
516 return multiSimController_->GetActiveSimAccountInfoList(denied, iccAccountInfoList);
517 }
518
GetSlotId(int32_t simId)519 int32_t SimManager::GetSlotId(int32_t simId)
520 {
521 if (multiSimController_ == nullptr) {
522 TELEPHONY_LOGE("multiSimController_ is nullptr");
523 return TELEPHONY_ERROR;
524 }
525 return multiSimController_->GetSlotId(simId);
526 }
527
GetSimId(int32_t slotId)528 int32_t SimManager::GetSimId(int32_t slotId)
529 {
530 IccAccountInfo accountInfo;
531 if (GetSimAccountInfo(slotId, false, accountInfo) == TELEPHONY_ERR_SUCCESS) {
532 return accountInfo.simId;
533 }
534 TELEPHONY_LOGE("GetSimAccountInfo fail!");
535 return TELEPHONY_ERROR;
536 }
537
GetOperatorConfigs(int32_t slotId,OperatorConfig & poc)538 int32_t SimManager::GetOperatorConfigs(int32_t slotId, OperatorConfig &poc)
539 {
540 if ((!IsValidSlotId(slotId)) || (simAccountManager_[slotId] == nullptr)) {
541 TELEPHONY_LOGE("simAccountManager is null!");
542 return TELEPHONY_ERR_LOCAL_PTR_NULL;
543 }
544 return simAccountManager_[slotId]->GetOperatorConfigs(slotId, poc);
545 }
546
HasOperatorPrivileges(const int32_t slotId,bool & hasOperatorPrivileges)547 int32_t SimManager::HasOperatorPrivileges(const int32_t slotId, bool &hasOperatorPrivileges)
548 {
549 TELEPHONY_LOGI("SimManager::HasOperatorPrivileges slotId:%{public}d", slotId);
550 if ((!IsValidSlotId(slotId)) || (simAccountManager_[slotId] == nullptr)) {
551 TELEPHONY_LOGE("simAccountManager_ can not be null!");
552 return TELEPHONY_ERR_LOCAL_PTR_NULL;
553 }
554 return simAccountManager_[slotId]->HasOperatorPrivileges(slotId, hasOperatorPrivileges);
555 }
556
SimAuthentication(int32_t slotId,AuthType authType,const std::string & authData,SimAuthenticationResponse & response)557 int32_t SimManager::SimAuthentication(
558 int32_t slotId, AuthType authType, const std::string &authData, SimAuthenticationResponse &response)
559 {
560 if (!HasSimCardInner(slotId)) {
561 TELEPHONY_LOGE("SimAuthentication has no sim card!");
562 return TELEPHONY_ERR_NO_SIM_CARD;
563 }
564 if (!IsValidAuthType(authType)) {
565 TELEPHONY_LOGE("SimAuthentication authType is invalid!");
566 return TELEPHONY_ERR_ARGUMENT_INVALID;
567 }
568 if (simStateManager_[slotId] == nullptr) {
569 TELEPHONY_LOGE("simStateManager_ can not be null!");
570 return TELEPHONY_ERR_LOCAL_PTR_NULL;
571 }
572 return simStateManager_[slotId]->SimAuthentication(slotId, authType, authData, response);
573 }
574
SendSimMatchedOperatorInfo(int32_t slotId,int32_t state,const std::string & operName,const std::string & operKey)575 int32_t SimManager::SendSimMatchedOperatorInfo(
576 int32_t slotId, int32_t state, const std::string &operName, const std::string &operKey)
577 {
578 if (!HasSimCardInner(slotId)) {
579 TELEPHONY_LOGE("SendSimMatchedOperatorInfo has no sim card!");
580 return TELEPHONY_ERR_NO_SIM_CARD;
581 }
582 if (simStateManager_[slotId] == nullptr) {
583 TELEPHONY_LOGE("simStateManager_ can not be null!");
584 return TELEPHONY_ERR_LOCAL_PTR_NULL;
585 }
586 return simStateManager_[slotId]->SendSimMatchedOperatorInfo(slotId, state, operName, operKey);
587 }
588
GetRadioProtocolTech(int32_t slotId)589 int32_t SimManager::GetRadioProtocolTech(int32_t slotId)
590 {
591 TELEPHONY_LOGI("SimManager::GetRadioProtocolTech slotId:%{public}d", slotId);
592 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
593 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
594 return static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN);
595 }
596 return multiSimController_->GetRadioProtocolTech(slotId);
597 }
598
GetRadioProtocol(int32_t slotId)599 void SimManager::GetRadioProtocol(int32_t slotId)
600 {
601 TELEPHONY_LOGI("SimManager::GetRadioProtocol slotId:%{public}d", slotId);
602 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
603 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
604 return;
605 }
606 return multiSimController_->GetRadioProtocol(slotId);
607 }
608
SendEnvelopeCmd(int32_t slotId,const std::string & cmd)609 int32_t SimManager::SendEnvelopeCmd(int32_t slotId, const std::string &cmd)
610 {
611 if ((!IsValidSlotId(slotId)) || (stkManager_[slotId] == nullptr)) {
612 TELEPHONY_LOGE("stkManager is null!");
613 return TELEPHONY_ERR_LOCAL_PTR_NULL;
614 }
615 if (!HasSimCardInner(slotId)) {
616 TELEPHONY_LOGE("SendEnvelopeCmd has no sim card!");
617 return TELEPHONY_ERR_NO_SIM_CARD;
618 }
619 return stkManager_[slotId]->SendEnvelopeCmd(slotId, cmd);
620 }
621
SendTerminalResponseCmd(int32_t slotId,const std::string & cmd)622 int32_t SimManager::SendTerminalResponseCmd(int32_t slotId, const std::string &cmd)
623 {
624 if ((!IsValidSlotId(slotId)) || (stkManager_[slotId] == nullptr)) {
625 TELEPHONY_LOGE("stkManager is null!");
626 return TELEPHONY_ERR_LOCAL_PTR_NULL;
627 }
628 if (!HasSimCardInner(slotId)) {
629 TELEPHONY_LOGE("SendTerminalResponseCmd has no sim card!");
630 return TELEPHONY_ERR_NO_SIM_CARD;
631 }
632 return stkManager_[slotId]->SendTerminalResponseCmd(slotId, cmd);
633 }
634
SendCallSetupRequestResult(int32_t slotId,bool accept)635 int32_t SimManager::SendCallSetupRequestResult(int32_t slotId, bool accept)
636 {
637 if (!IsValidSlotId(slotId)) {
638 TELEPHONY_LOGE("slotId is invalid!");
639 return TELEPHONY_ERR_SLOTID_INVALID;
640 }
641 if (stkManager_[slotId] == nullptr) {
642 TELEPHONY_LOGE("stkManager is null!");
643 return TELEPHONY_ERR_LOCAL_PTR_NULL;
644 }
645 if (!HasSimCardInner(slotId)) {
646 TELEPHONY_LOGE("SendCallSetupRequestResult has no sim card!");
647 return TELEPHONY_ERR_NO_SIM_CARD;
648 }
649 return stkManager_[slotId]->SendCallSetupRequestResult(slotId, accept);
650 }
651
GetSimOperatorNumeric(int32_t slotId,std::u16string & operatorNumeric)652 int32_t SimManager::GetSimOperatorNumeric(int32_t slotId, std::u16string &operatorNumeric)
653 {
654 if (!HasSimCardInner(slotId)) {
655 TELEPHONY_LOGE("GetSimOperatorNumeric has no sim card!");
656 return TELEPHONY_ERR_NO_SIM_CARD;
657 }
658 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
659 TELEPHONY_LOGE("simFileManager is null!");
660 return TELEPHONY_ERR_LOCAL_PTR_NULL;
661 }
662 operatorNumeric = simFileManager_[slotId]->GetSimOperatorNumeric();
663 return TELEPHONY_ERR_SUCCESS;
664 }
665
GetISOCountryCodeForSim(int32_t slotId,std::u16string & countryCode)666 int32_t SimManager::GetISOCountryCodeForSim(int32_t slotId, std::u16string &countryCode)
667 {
668 if (!HasSimCardInner(slotId)) {
669 TELEPHONY_LOGE("GetISOCountryCodeForSim has no sim card!");
670 return TELEPHONY_ERR_NO_SIM_CARD;
671 }
672 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
673 TELEPHONY_LOGE("simFileManager is null!");
674 return TELEPHONY_ERR_LOCAL_PTR_NULL;
675 }
676 countryCode = simFileManager_[slotId]->GetISOCountryCodeForSim();
677 return TELEPHONY_ERR_SUCCESS;
678 }
679
GetSimSpn(int32_t slotId,std::u16string & spn)680 int32_t SimManager::GetSimSpn(int32_t slotId, std::u16string &spn)
681 {
682 if (!HasSimCardInner(slotId)) {
683 TELEPHONY_LOGE("GetSimSpn has no sim card!");
684 return TELEPHONY_ERR_NO_SIM_CARD;
685 }
686 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
687 TELEPHONY_LOGE("simFileManager is null");
688 return TELEPHONY_ERR_LOCAL_PTR_NULL;
689 }
690 spn = simFileManager_[slotId]->GetSimSpn();
691 return TELEPHONY_ERR_SUCCESS;
692 }
693
GetSimEons(int32_t slotId,const std::string & plmn,int32_t lac,bool longNameRequired)694 std::u16string SimManager::GetSimEons(int32_t slotId, const std::string &plmn, int32_t lac, bool longNameRequired)
695 {
696 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
697 TELEPHONY_LOGE("simFileManager is null");
698 return std::u16string();
699 }
700
701 return simFileManager_[slotId]->GetSimEons(plmn, lac, longNameRequired);
702 }
703
GetSimIccId(int32_t slotId,std::u16string & iccId)704 int32_t SimManager::GetSimIccId(int32_t slotId, std::u16string &iccId)
705 {
706 if (!HasSimCardInner(slotId)) {
707 TELEPHONY_LOGE("GetSimIccId has no sim card!");
708 return TELEPHONY_ERR_NO_SIM_CARD;
709 }
710 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
711 TELEPHONY_LOGE("simFileManager is null!");
712 return TELEPHONY_ERR_LOCAL_PTR_NULL;
713 }
714 iccId = simFileManager_[slotId]->GetSimIccId();
715 return TELEPHONY_ERR_SUCCESS;
716 }
717
GetIMSI(int32_t slotId,std::u16string & imsi)718 int32_t SimManager::GetIMSI(int32_t slotId, std::u16string &imsi)
719 {
720 if (!HasSimCardInner(slotId)) {
721 TELEPHONY_LOGE("GetIMSI has no sim card!");
722 return TELEPHONY_ERR_NO_SIM_CARD;
723 }
724 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
725 TELEPHONY_LOGE("simFileManager is null!");
726 return TELEPHONY_ERR_LOCAL_PTR_NULL;
727 }
728 imsi = simFileManager_[slotId]->GetIMSI();
729 return TELEPHONY_ERR_SUCCESS;
730 }
731
GetLocaleFromDefaultSim(int32_t slotId)732 std::u16string SimManager::GetLocaleFromDefaultSim(int32_t slotId)
733 {
734 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
735 TELEPHONY_LOGE("simFileManager is null!");
736 return u"";
737 }
738 return simFileManager_[slotId]->GetLocaleFromDefaultSim();
739 }
740
GetSimGid1(int32_t slotId,std::u16string & gid1)741 int32_t SimManager::GetSimGid1(int32_t slotId, std::u16string &gid1)
742 {
743 if (!HasSimCardInner(slotId)) {
744 TELEPHONY_LOGE("GetSimGid1 has no sim card!");
745 return TELEPHONY_ERR_NO_SIM_CARD;
746 }
747 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
748 TELEPHONY_LOGE("simFileManager is null!");
749 return TELEPHONY_ERR_LOCAL_PTR_NULL;
750 }
751 gid1 = simFileManager_[slotId]->GetSimGid1();
752 return TELEPHONY_ERR_SUCCESS;
753 }
754
GetSimGid2(int32_t slotId)755 std::u16string SimManager::GetSimGid2(int32_t slotId)
756 {
757 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
758 TELEPHONY_LOGE("simFileManager is null!");
759 return u"";
760 }
761 return simFileManager_[slotId]->GetSimGid2();
762 }
763
GetOpName(int32_t slotId,std::u16string & opname)764 int32_t SimManager::GetOpName(int32_t slotId, std::u16string &opname)
765 {
766 if (!IsValidSlotId(slotId)) {
767 TELEPHONY_LOGE("slotId is invalid! %{public}d", slotId);
768 return TELEPHONY_ERR_SLOTID_INVALID;
769 }
770 if (simFileManager_[slotId] == nullptr) {
771 TELEPHONY_LOGE("simFileManager is null! %{public}d", slotId);
772 return TELEPHONY_ERR_LOCAL_PTR_NULL;
773 }
774 opname = simFileManager_[slotId]->GetOpName();
775 return TELEPHONY_ERR_SUCCESS;
776 }
777
GetOpKey(int32_t slotId,std::u16string & opkey)778 int32_t SimManager::GetOpKey(int32_t slotId, std::u16string &opkey)
779 {
780 if (!IsValidSlotId(slotId)) {
781 TELEPHONY_LOGE("slotId is invalid! %{public}d", slotId);
782 return TELEPHONY_ERR_SLOTID_INVALID;
783 }
784 if (simFileManager_[slotId] == nullptr) {
785 TELEPHONY_LOGE("simFileManager is null! %{public}d", slotId);
786 return TELEPHONY_ERR_LOCAL_PTR_NULL;
787 }
788 opkey = simFileManager_[slotId]->GetOpKey();
789 return TELEPHONY_ERR_SUCCESS;
790 }
791
GetOpKeyExt(int32_t slotId,std::u16string & opkeyExt)792 int32_t SimManager::GetOpKeyExt(int32_t slotId, std::u16string &opkeyExt)
793 {
794 if (!IsValidSlotId(slotId)) {
795 TELEPHONY_LOGE("slotId is invalid! %{public}d", slotId);
796 return TELEPHONY_ERR_SLOTID_INVALID;
797 }
798 if (simFileManager_[slotId] == nullptr) {
799 TELEPHONY_LOGE("simFileManager is null! %{public}d", slotId);
800 return TELEPHONY_ERR_LOCAL_PTR_NULL;
801 }
802 opkeyExt = simFileManager_[slotId]->GetOpKeyExt();
803 return TELEPHONY_ERR_SUCCESS;
804 }
805
GetSimTelephoneNumber(int32_t slotId,std::u16string & telephoneNumber)806 int32_t SimManager::GetSimTelephoneNumber(int32_t slotId, std::u16string &telephoneNumber)
807 {
808 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
809 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
810 return TELEPHONY_ERR_LOCAL_PTR_NULL;
811 }
812 return multiSimController_->GetSimTelephoneNumber(slotId, telephoneNumber);
813 }
814
GetSimTeleNumberIdentifier(const int32_t slotId)815 std::u16string SimManager::GetSimTeleNumberIdentifier(const int32_t slotId)
816 {
817 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
818 TELEPHONY_LOGE("simFileManager is null!");
819 return u"";
820 }
821 return simFileManager_[slotId]->GetSimTeleNumberIdentifier();
822 }
823
GetVoiceMailIdentifier(int32_t slotId,std::u16string & voiceMailIdentifier)824 int32_t SimManager::GetVoiceMailIdentifier(int32_t slotId, std::u16string &voiceMailIdentifier)
825 {
826 if (!HasSimCardInner(slotId)) {
827 TELEPHONY_LOGE("GetVoiceMailIdentifier has no sim card!");
828 return TELEPHONY_ERR_NO_SIM_CARD;
829 }
830 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
831 TELEPHONY_LOGE("simFileManager is null!");
832 return TELEPHONY_ERR_LOCAL_PTR_NULL;
833 }
834 voiceMailIdentifier = simFileManager_[slotId]->GetVoiceMailIdentifier();
835 return TELEPHONY_ERR_SUCCESS;
836 }
837
GetVoiceMailNumber(int32_t slotId,std::u16string & voiceMailNumber)838 int32_t SimManager::GetVoiceMailNumber(int32_t slotId, std::u16string &voiceMailNumber)
839 {
840 if (!HasSimCardInner(slotId)) {
841 TELEPHONY_LOGE("GetVoiceMailNumber has no sim card!");
842 return TELEPHONY_ERR_NO_SIM_CARD;
843 }
844 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
845 TELEPHONY_LOGE("simFileManager is null!");
846 return TELEPHONY_ERR_LOCAL_PTR_NULL;
847 }
848 voiceMailNumber = simFileManager_[slotId]->GetVoiceMailNumber();
849 return TELEPHONY_ERR_SUCCESS;
850 }
851
GetVoiceMailCount(int32_t slotId,int32_t & voiceMailCount)852 int32_t SimManager::GetVoiceMailCount(int32_t slotId, int32_t &voiceMailCount)
853 {
854 if (!HasSimCardInner(slotId)) {
855 TELEPHONY_LOGE("GetVoiceMailCount has no sim card!");
856 return TELEPHONY_ERR_NO_SIM_CARD;
857 }
858 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
859 TELEPHONY_LOGE("simFileManager is null!");
860 return TELEPHONY_ERR_LOCAL_PTR_NULL;
861 }
862 voiceMailCount = simFileManager_[slotId]->GetVoiceMailCount();
863 return TELEPHONY_ERR_SUCCESS;
864 }
865
SetVoiceMailCount(int32_t slotId,int32_t voiceMailCount)866 int32_t SimManager::SetVoiceMailCount(int32_t slotId, int32_t voiceMailCount)
867 {
868 if (!HasSimCardInner(slotId)) {
869 TELEPHONY_LOGE("SetVoiceMailCount has no sim card!");
870 return TELEPHONY_ERR_NO_SIM_CARD;
871 }
872 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
873 TELEPHONY_LOGE("simFileManager is null!");
874 return TELEPHONY_ERR_LOCAL_PTR_NULL;
875 }
876 if (simFileManager_[slotId]->SetVoiceMailCount(voiceMailCount)) {
877 return TELEPHONY_ERR_SUCCESS;
878 }
879 return CORE_ERR_SIM_CARD_UPDATE_FAILED;
880 }
881
SetVoiceCallForwarding(int32_t slotId,bool enable,const std::string & number)882 int32_t SimManager::SetVoiceCallForwarding(int32_t slotId, bool enable, const std::string &number)
883 {
884 if (!HasSimCardInner(slotId)) {
885 TELEPHONY_LOGE("SetVoiceCallForwarding has no sim card!");
886 return TELEPHONY_ERR_NO_SIM_CARD;
887 }
888 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
889 TELEPHONY_LOGE("simFileManager is null!");
890 return TELEPHONY_ERR_LOCAL_PTR_NULL;
891 }
892 if (simFileManager_[slotId]->SetVoiceCallForwarding(enable, number)) {
893 return TELEPHONY_ERR_SUCCESS;
894 }
895 return CORE_ERR_SIM_CARD_UPDATE_FAILED;
896 }
897
ObtainSpnCondition(int32_t slotId,bool roaming,std::string operatorNum)898 int32_t SimManager::ObtainSpnCondition(int32_t slotId, bool roaming, std::string operatorNum)
899 {
900 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
901 TELEPHONY_LOGE("simFileManager is null");
902 return TELEPHONY_ERROR;
903 }
904 return simFileManager_[slotId]->ObtainSpnCondition(roaming, operatorNum);
905 }
906
SetVoiceMailInfo(int32_t slotId,const std::u16string & mailName,const std::u16string & mailNumber)907 int32_t SimManager::SetVoiceMailInfo(int32_t slotId, const std::u16string &mailName, const std::u16string &mailNumber)
908 {
909 if (!HasSimCardInner(slotId)) {
910 TELEPHONY_LOGE("SetVoiceMailInfo has no sim card!");
911 return TELEPHONY_ERR_NO_SIM_CARD;
912 }
913 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
914 TELEPHONY_LOGE("simFileManager is null");
915 return TELEPHONY_ERR_LOCAL_PTR_NULL;
916 }
917 if (!simFileManager_[slotId]->SetVoiceMailInfo(mailName, mailNumber)) {
918 return CORE_ERR_SIM_CARD_UPDATE_FAILED;
919 }
920 return TELEPHONY_ERR_SUCCESS;
921 }
922
IsCTSimCard(int32_t slotId,bool & isCTSimCard)923 int32_t SimManager::IsCTSimCard(int32_t slotId, bool &isCTSimCard)
924 {
925 if (!HasSimCardInner(slotId)) {
926 TELEPHONY_LOGE("IsCTSimCard has no sim card!");
927 return TELEPHONY_ERR_NO_SIM_CARD;
928 }
929 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
930 TELEPHONY_LOGE("simFileManager is null!");
931 return TELEPHONY_ERR_LOCAL_PTR_NULL;
932 }
933 isCTSimCard = simFileManager_[slotId]->IsCTSimCard();
934 return TELEPHONY_ERR_SUCCESS;
935 }
936
AddSmsToIcc(int32_t slotId,int status,std::string & pdu,std::string & smsc)937 int32_t SimManager::AddSmsToIcc(int32_t slotId, int status, std::string &pdu, std::string &smsc)
938 {
939 if ((!IsValidSlotId(slotId)) || (simSmsManager_[slotId] == nullptr)) {
940 TELEPHONY_LOGE("simSmsManager_ is null!");
941 return TELEPHONY_ERR_SLOTID_INVALID;
942 }
943 return simSmsManager_[slotId]->AddSmsToIcc(status, pdu, smsc);
944 }
945
UpdateSmsIcc(int32_t slotId,int index,int status,std::string & pduData,std::string & smsc)946 int32_t SimManager::UpdateSmsIcc(int32_t slotId, int index, int status, std::string &pduData, std::string &smsc)
947 {
948 if ((!IsValidSlotId(slotId)) || (simSmsManager_[slotId] == nullptr)) {
949 TELEPHONY_LOGE("simSmsManager_ is null!");
950 return TELEPHONY_ERR_SLOTID_INVALID;
951 }
952 return simSmsManager_[slotId]->UpdateSmsIcc(index, status, pduData, smsc);
953 }
954
DelSmsIcc(int32_t slotId,int index)955 int32_t SimManager::DelSmsIcc(int32_t slotId, int index)
956 {
957 if ((!IsValidSlotId(slotId)) || (simSmsManager_[slotId] == nullptr)) {
958 TELEPHONY_LOGE("simSmsManager_ is null!");
959 return TELEPHONY_ERR_SLOTID_INVALID;
960 }
961 return simSmsManager_[slotId]->DelSmsIcc(index);
962 }
963
ObtainAllSmsOfIcc(int32_t slotId)964 std::vector<std::string> SimManager::ObtainAllSmsOfIcc(int32_t slotId)
965 {
966 if ((!IsValidSlotId(slotId)) || (simSmsManager_[slotId] == nullptr)) {
967 TELEPHONY_LOGE("simSmsManager_ is null!");
968 std::vector<std::string> result;
969 return result;
970 }
971 return simSmsManager_[slotId]->ObtainAllSmsOfIcc();
972 }
973
QueryIccDiallingNumbers(int slotId,int type,std::vector<std::shared_ptr<DiallingNumbersInfo>> & result)974 int32_t SimManager::QueryIccDiallingNumbers(
975 int slotId, int type, std::vector<std::shared_ptr<DiallingNumbersInfo>> &result)
976 {
977 if ((!IsValidSlotId(slotId)) || (iccDiallingNumbersManager_[slotId] == nullptr)) {
978 TELEPHONY_LOGE("iccDiallingNumbersManager is null!");
979 return TELEPHONY_ERR_LOCAL_PTR_NULL;
980 }
981 return iccDiallingNumbersManager_[slotId]->QueryIccDiallingNumbers(type, result);
982 }
983
AddIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)984 int32_t SimManager::AddIccDiallingNumbers(
985 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
986 {
987 if ((!IsValidSlotId(slotId)) || (iccDiallingNumbersManager_[slotId] == nullptr)) {
988 TELEPHONY_LOGE("iccDiallingNumbersManager is null!");
989 return TELEPHONY_ERR_LOCAL_PTR_NULL;
990 }
991 return iccDiallingNumbersManager_[slotId]->AddIccDiallingNumbers(type, diallingNumber);
992 }
993
DelIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)994 int32_t SimManager::DelIccDiallingNumbers(
995 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
996 {
997 if ((!IsValidSlotId(slotId)) || (iccDiallingNumbersManager_[slotId] == nullptr)) {
998 TELEPHONY_LOGE("iccDiallingNumbersManager is null!");
999 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1000 }
1001 return iccDiallingNumbersManager_[slotId]->DelIccDiallingNumbers(type, diallingNumber);
1002 }
1003
UpdateIccDiallingNumbers(int slotId,int type,const std::shared_ptr<DiallingNumbersInfo> & diallingNumber)1004 int32_t SimManager::UpdateIccDiallingNumbers(
1005 int slotId, int type, const std::shared_ptr<DiallingNumbersInfo> &diallingNumber)
1006 {
1007 if ((!IsValidSlotId(slotId)) || (iccDiallingNumbersManager_[slotId] == nullptr)) {
1008 TELEPHONY_LOGE("iccDiallingNumbersManager is null!");
1009 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1010 }
1011 return iccDiallingNumbersManager_[slotId]->UpdateIccDiallingNumbers(type, diallingNumber);
1012 }
1013
RegisterCoreNotify(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & handler,int what)1014 void SimManager::RegisterCoreNotify(int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &handler, int what)
1015 {
1016 if ((what >= RadioEvent::RADIO_IMSI_LOADED_READY) && (what <= RadioEvent::RADIO_SIM_RECORDS_LOADED)) {
1017 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
1018 TELEPHONY_LOGE("slotId is invalid or simFileManager_ is nullptr");
1019 return;
1020 }
1021 simFileManager_[slotId]->RegisterCoreNotify(handler, what);
1022 } else if ((what >= RadioEvent::RADIO_SIM_STATE_CHANGE) && (what <= RadioEvent::RADIO_SIM_STATE_SIMLOCK)) {
1023 if ((!IsValidSlotId(slotId)) || (simStateManager_[slotId] == nullptr)) {
1024 TELEPHONY_LOGE("slotId is invalid or simStateManager_ is nullptr");
1025 return;
1026 }
1027 simStateManager_[slotId]->RegisterCoreNotify(handler, what);
1028 } else if (what == RadioEvent::RADIO_SIM_ACCOUNT_LOADED) {
1029 if ((!IsValidSlotId(slotId)) || (multiSimMonitor_ == nullptr)) {
1030 TELEPHONY_LOGE("slotId is invalid or multiSimMonitor_ is nullptr");
1031 return;
1032 }
1033 multiSimMonitor_->RegisterCoreNotify(slotId, handler, what);
1034 } else {
1035 TELEPHONY_LOGE("SimManager::RegisterCoreNotify faild");
1036 }
1037 }
1038
UnRegisterCoreNotify(int32_t slotId,const std::shared_ptr<AppExecFwk::EventHandler> & observerCallBack,int what)1039 void SimManager::UnRegisterCoreNotify(
1040 int32_t slotId, const std::shared_ptr<AppExecFwk::EventHandler> &observerCallBack, int what)
1041 {
1042 if (what >= RadioEvent::RADIO_IMSI_LOADED_READY && what <= RadioEvent::RADIO_SIM_RECORDS_LOADED) {
1043 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
1044 TELEPHONY_LOGE("simFileManager is null");
1045 return;
1046 }
1047 simFileManager_[slotId]->UnRegisterCoreNotify(observerCallBack, what);
1048 } else if (what >= RadioEvent::RADIO_SIM_STATE_CHANGE && what <= RadioEvent::RADIO_SIM_STATE_SIMLOCK) {
1049 if ((!IsValidSlotId(slotId)) || (simStateManager_[slotId] == nullptr)) {
1050 TELEPHONY_LOGE("simStateManager_ is null");
1051 return;
1052 }
1053 simStateManager_[slotId]->UnRegisterCoreNotify(observerCallBack, what);
1054 } else {
1055 TELEPHONY_LOGE("SimManager::UnRegisterCoreNotify faild");
1056 }
1057 }
1058
IsValidSlotId(int32_t slotId)1059 bool SimManager::IsValidSlotId(int32_t slotId)
1060 {
1061 if ((slotId < SLOT_ID_ZERO) || (slotId >= slotCount_)) {
1062 TELEPHONY_LOGE("slotId is invalid, slotId = %{public}d", slotId);
1063 return false;
1064 }
1065 TELEPHONY_LOGD("slotId is valid, slotId = %{public}d", slotId);
1066 return true;
1067 }
1068
IsValidAuthType(AuthType authType)1069 bool SimManager::IsValidAuthType(AuthType authType)
1070 {
1071 return (authType == AuthType::SIM_AUTH_EAP_SIM_TYPE || authType == AuthType::SIM_AUTH_EAP_AKA_TYPE);
1072 }
1073
IsValidSlotIdForDefault(int32_t slotId)1074 bool SimManager::IsValidSlotIdForDefault(int32_t slotId)
1075 {
1076 if ((slotId < DEFAULT_SIM_SLOT_ID_REMOVE) || (slotId >= slotCount_)) {
1077 TELEPHONY_LOGE("slotId is invalid, slotId = %{public}d", slotId);
1078 return false;
1079 }
1080 TELEPHONY_LOGD("slotId is valid, slotId = %{public}d", slotId);
1081 return true;
1082 }
1083
GetSimIst(int32_t slotId)1084 std::u16string SimManager::GetSimIst(int32_t slotId)
1085 {
1086 if ((!IsValidSlotId(slotId)) || (simFileManager_[slotId] == nullptr)) {
1087 TELEPHONY_LOGE("simFileManager is null!");
1088 return u"";
1089 }
1090 return simFileManager_[slotId]->GetSimIst();
1091 }
1092
SaveImsSwitch(int32_t slotId,int32_t imsSwitchValue)1093 int32_t SimManager::SaveImsSwitch(int32_t slotId, int32_t imsSwitchValue)
1094 {
1095 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
1096 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
1097 return TELEPHONY_ERR_ARGUMENT_INVALID;
1098 }
1099 return multiSimController_->SaveImsSwitch(slotId, imsSwitchValue);
1100 }
1101
QueryImsSwitch(int32_t slotId,int32_t & imsSwitchValue)1102 int32_t SimManager::QueryImsSwitch(int32_t slotId, int32_t &imsSwitchValue)
1103 {
1104 if ((!IsValidSlotId(slotId)) || (multiSimController_ == nullptr)) {
1105 TELEPHONY_LOGE("slotId is invalid or multiSimController_ is nullptr");
1106 return TELEPHONY_ERR_ARGUMENT_INVALID;
1107 }
1108 return multiSimController_->QueryImsSwitch(slotId, imsSwitchValue);
1109 }
1110
RegisterSimAccountCallback(const std::string & bundleName,const sptr<SimAccountCallback> & callback)1111 int32_t SimManager::RegisterSimAccountCallback(const std::string &bundleName, const sptr<SimAccountCallback> &callback)
1112 {
1113 if (multiSimMonitor_ == nullptr) {
1114 TELEPHONY_LOGE("multiSimMonitor is null");
1115 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1116 }
1117 return multiSimMonitor_->RegisterSimAccountCallback(bundleName, callback);
1118 }
1119
UnregisterSimAccountCallback(const std::string & bundleName)1120 int32_t SimManager::UnregisterSimAccountCallback(const std::string &bundleName)
1121 {
1122 if (multiSimMonitor_ == nullptr) {
1123 TELEPHONY_LOGE("multiSimMonitor is null");
1124 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1125 }
1126 return multiSimMonitor_->UnregisterSimAccountCallback(bundleName);
1127 }
1128 } // namespace Telephony
1129 } // namespace OHOS
1130