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