1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sim_file_manager.h"
17
18 #include "network_state.h"
19 #include "radio_event.h"
20
21 namespace OHOS {
22 namespace Telephony {
SimFileManager(const std::shared_ptr<AppExecFwk::EventRunner> & runner,std::shared_ptr<ITelRilManager> telRilManager,std::shared_ptr<Telephony::SimStateManager> state)23 SimFileManager::SimFileManager(const std::shared_ptr<AppExecFwk::EventRunner> &runner,
24 std::shared_ptr<ITelRilManager> telRilManager, std::shared_ptr<Telephony::SimStateManager> state)
25 : AppExecFwk::EventHandler(runner), telRilManager_(telRilManager), simStateManager_(state)
26 {
27 if (simStateManager_ == nullptr) {
28 TELEPHONY_LOGE("SimFileManager set NULL simStateManager.");
29 return;
30 }
31 TELEPHONY_LOGI("SIM manager SimFileManager::SimFileManager started ");
32 }
33
~SimFileManager()34 SimFileManager::~SimFileManager()
35 {
36 if (simFile_ != nullptr) {
37 simFile_->UnInit();
38 }
39 }
40
Init(int slotId)41 void SimFileManager::Init(int slotId)
42 {
43 TELEPHONY_LOGI("SimFileManager::Init() started slot %{public}d", slotId);
44 slotId_ = slotId;
45 if (stateRecord_ == HandleRunningState::STATE_RUNNING) {
46 TELEPHONY_LOGI("SimFileManager::Init stateRecord_ started.");
47 return;
48 }
49 if (stateHandler_ == HandleRunningState::STATE_RUNNING) {
50 TELEPHONY_LOGI("SimFileManager::Init stateHandler_ started.");
51 return;
52 }
53 if (telRilManager_ == nullptr) {
54 TELEPHONY_LOGE("SimFileManager get NULL ITelRilManager.");
55 return;
56 }
57 CardType cardType = simStateManager_->GetCardType();
58 TELEPHONY_LOGI("SimFileManager current card type is %{public}d", cardType);
59 if ((cardType == static_cast<CardType>(0)) || (cardType == CardType::UNKNOWN_CARD)) {
60 cardType = CardType::SINGLE_MODE_USIM_CARD; // default card
61 }
62 iccType_ = GetIccTypeByCardType(cardType);
63 TELEPHONY_LOGI("SimFileManager current icc type is %{public}d", iccType_);
64 if (!InitIccFileController(iccType_)) {
65 TELEPHONY_LOGE("SimFileManager::InitIccFileController fail");
66 return;
67 }
68 if (!InitDiallingNumberHandler()) {
69 TELEPHONY_LOGE("SimFileManager::InitDiallingNumberHandler fail");
70 return;
71 }
72 if (!InitSimFile(iccType_)) {
73 TELEPHONY_LOGE("SimFileManager::InitSimFile fail");
74 return;
75 }
76 stateRecord_ = HandleRunningState::STATE_RUNNING;
77 stateHandler_ = HandleRunningState::STATE_RUNNING;
78
79 simStateManager_->RegisterCoreNotify(shared_from_this(), RadioEvent::RADIO_CARD_TYPE_CHANGE);
80 telRilManager_->RegisterCoreNotify(
81 slotId, shared_from_this(), RadioEvent::RADIO_VOICE_TECH_CHANGED, nullptr);
82 TELEPHONY_LOGI("SimFileManager::Init() end");
83 }
84
InitSimFile(SimFileManager::IccType type)85 bool SimFileManager::InitSimFile(SimFileManager::IccType type)
86 {
87 if (fileController_ == nullptr || diallingNumberHandler_ == nullptr) {
88 TELEPHONY_LOGE("InitSimFile need more helper");
89 return false;
90 }
91 if (eventLoopRecord_ == nullptr) {
92 eventLoopRecord_ = AppExecFwk::EventRunner::Create("IccFile");
93 if (eventLoopRecord_.get() == nullptr) {
94 TELEPHONY_LOGE("IccFile failed to create EventRunner");
95 return false;
96 }
97 } else {
98 eventLoopRecord_->Stop();
99 }
100 auto iccFileIt = iccFileCache_.find(type);
101 if (iccFileIt == iccFileCache_.end()) {
102 if (type == SimFileManager::IccType::ICC_TYPE_CDMA) {
103 simFile_ = std::make_shared<RuimFile>(eventLoopRecord_, simStateManager_);
104 } else if (type == SimFileManager::IccType::ICC_TYPE_IMS) {
105 simFile_ = std::make_shared<IsimFile>(eventLoopRecord_, simStateManager_);
106 } else {
107 simFile_ = std::make_shared<SimFile>(eventLoopRecord_, simStateManager_);
108 }
109 iccFileCache_.insert(std::make_pair(type, simFile_));
110 } else {
111 simFile_ = iccFileIt->second;
112 }
113
114 if (simFile_ == nullptr) {
115 TELEPHONY_LOGE("SimFileManager::Init simFile create nullptr.");
116 return false;
117 }
118 simFile_->SetRilAndFileController(telRilManager_, fileController_, diallingNumberHandler_);
119 eventLoopRecord_->Run();
120 simFile_->SetId(slotId_);
121 simFile_->Init();
122 return true;
123 }
124
InitIccFileController(SimFileManager::IccType type)125 bool SimFileManager::InitIccFileController(SimFileManager::IccType type)
126 {
127 if (eventLoopFileController_ == nullptr) {
128 eventLoopFileController_ = AppExecFwk::EventRunner::Create("SIMController");
129 if (eventLoopFileController_.get() == nullptr) {
130 TELEPHONY_LOGE("SIMHandler failed to create EventRunner");
131 return false;
132 }
133 } else {
134 eventLoopFileController_->Stop();
135 }
136 auto iccFileConIt = iccFileControllerCache_.find(type);
137 if (iccFileConIt == iccFileControllerCache_.end()) {
138 if (type == SimFileManager::IccType::ICC_TYPE_CDMA) { // ruim 30 usim 20 isim 60
139 fileController_ = std::make_shared<RuimFileController>(eventLoopFileController_, slotId_);
140 } else if (type == SimFileManager::IccType::ICC_TYPE_IMS) {
141 fileController_ = std::make_shared<IsimFileController>(eventLoopFileController_, slotId_);
142 } else if (type == SimFileManager::IccType::ICC_TYPE_GSM) {
143 fileController_ = std::make_shared<SimFileController>(eventLoopFileController_, slotId_);
144 } else {
145 fileController_ = std::make_shared<UsimFileController>(eventLoopFileController_, slotId_);
146 }
147 iccFileControllerCache_.insert(std::make_pair(type, fileController_));
148 } else {
149 fileController_ = iccFileConIt->second;
150 }
151 if (fileController_ == nullptr) {
152 TELEPHONY_LOGE("SimFileManager::Init fileController create nullptr.");
153 return false;
154 }
155 fileController_->SetRilManager(telRilManager_);
156 eventLoopFileController_->Run();
157 return true;
158 }
159
GetSimOperatorNumeric()160 std::u16string SimFileManager::GetSimOperatorNumeric()
161 {
162 if (simFile_ == nullptr) {
163 TELEPHONY_LOGE("SimFileManager::GetSimOperatorNumeric simFile nullptr");
164 return Str8ToStr16("");
165 }
166
167 std::string result = simFile_->ObtainSimOperator();
168 TELEPHONY_LOGI("SimFileManager::GetOperator result:%{public}s ", (result.empty() ? "false" : "true"));
169 return Str8ToStr16(result);
170 }
171
GetISOCountryCodeForSim()172 std::u16string SimFileManager::GetISOCountryCodeForSim()
173 {
174 if (simFile_ == nullptr) {
175 TELEPHONY_LOGE("SimFileManager::GetISOCountryCodeForSim simFile nullptr");
176 return Str8ToStr16("");
177 }
178
179 std::string result = simFile_->ObtainIsoCountryCode();
180 TELEPHONY_LOGI("SimFileManager::ObtainIsoCountryCode result:%{public}s ", (result.empty() ? "false" : "true"));
181 return Str8ToStr16(result);
182 }
183
GetSimSpn()184 std::u16string SimFileManager::GetSimSpn()
185 {
186 if (simFile_ == nullptr) {
187 TELEPHONY_LOGE("SimFileManager::GetSimSpn simFile nullptr");
188 return Str8ToStr16("");
189 }
190
191 std::string result = simFile_->ObtainSPN();
192 TELEPHONY_LOGI("SimFileManager::GetSimSpn result:%{public}s ", (result.empty() ? "false" : "true"));
193 return Str8ToStr16(result);
194 }
195
GetSimEons(const std::string & plmn,int32_t lac,bool longNameRequired)196 std::u16string SimFileManager::GetSimEons(const std::string &plmn, int32_t lac, bool longNameRequired)
197 {
198 if (simFile_ == nullptr) {
199 TELEPHONY_LOGE("SimFileManager::GetEons simFile nullptr");
200 return Str8ToStr16("");
201 }
202
203 std::string result = simFile_->ObtainEons(plmn, lac, longNameRequired);
204 TELEPHONY_LOGI("SimFileManager::GetEons result:%{public}s ", (result.empty() ? "false" : "true"));
205 return Str8ToStr16(result);
206 }
207
GetSimIccId()208 std::u16string SimFileManager::GetSimIccId()
209 {
210 if (simFile_ == nullptr) {
211 TELEPHONY_LOGE("SimFileManager::GetSimIccId simFile nullptr");
212 return Str8ToStr16("");
213 }
214
215 std::string result = simFile_->ObtainIccId();
216 TELEPHONY_LOGI("SimFileManager::GetSimIccId result:%{public}s ", (result.empty() ? "false" : "true"));
217 return Str8ToStr16(result);
218 }
219
GetIMSI()220 std::u16string SimFileManager::GetIMSI()
221 {
222 if (simFile_ == nullptr) {
223 TELEPHONY_LOGE("SimFileManager::GetIMSI simFile nullptr");
224 return Str8ToStr16("");
225 }
226
227 std::string result = simFile_->ObtainIMSI();
228 TELEPHONY_LOGI("SimFileManager::ObtainIMSI result:%{public}s ", (result.empty() ? "false" : "true"));
229 return Str8ToStr16(result);
230 }
231
GetLocaleFromDefaultSim()232 std::u16string SimFileManager::GetLocaleFromDefaultSim()
233 {
234 if (simFile_ == nullptr) {
235 TELEPHONY_LOGE("SimFileManager::GetLocaleFromDefaultSim simFile nullptr");
236 return Str8ToStr16("");
237 }
238
239 std::string result = simFile_->ObtainIccLanguage();
240 TELEPHONY_LOGI(
241 "SimFileManager::GetLocaleFromDefaultSim result:%{public}s ", (result.empty() ? "false" : "true"));
242 return Str8ToStr16(result);
243 }
244
GetSimGid1()245 std::u16string SimFileManager::GetSimGid1()
246 {
247 if (simFile_ == nullptr) {
248 TELEPHONY_LOGE("SimFileManager::GetSimGid1 simFile nullptr");
249 return Str8ToStr16("");
250 }
251
252 std::string result = simFile_->ObtainGid1();
253 TELEPHONY_LOGI("SimFileManager::GetSimGid1 result:%{public}s ", (result.empty() ? "false" : "true"));
254 return Str8ToStr16(result);
255 }
256
GetSimGid2()257 std::u16string SimFileManager::GetSimGid2()
258 {
259 if (simFile_ == nullptr) {
260 TELEPHONY_LOGE("SimFileManager::GetSimGid2 simFile nullptr");
261 return Str8ToStr16("");
262 }
263
264 std::string result = simFile_->ObtainGid2();
265 TELEPHONY_LOGI("SimFileManager::GetSimGid2 result:%{public}s ", (result.empty() ? "false" : "true"));
266 return Str8ToStr16(result);
267 }
268
GetSimTelephoneNumber()269 std::u16string SimFileManager::GetSimTelephoneNumber()
270 {
271 if (simFile_ == nullptr) {
272 TELEPHONY_LOGE("SimFileManager::GetSimTelephoneNumber simFile nullptr");
273 return Str8ToStr16("");
274 }
275
276 std::string result = simFile_->ObtainMsisdnNumber();
277 TELEPHONY_LOGI("SimFileManager::GetSimTelephoneNumber result:%{public}s ", (result.empty() ? "false" : "true"));
278 return Str8ToStr16(result);
279 }
280
GetSimTeleNumberIdentifier()281 std::u16string SimFileManager::GetSimTeleNumberIdentifier()
282 {
283 if (simFile_ == nullptr) {
284 TELEPHONY_LOGE("SimFileManager::GetSimTeleNumberIdentifier simFile nullptr");
285 return Str8ToStr16("");
286 }
287
288 std::string result = simFile_->ObtainMsisdnAlphaStatus();
289 TELEPHONY_LOGI(
290 "SimFileManager::GetSimTeleNumberIdentifier result:%{public}s ", (result.empty() ? "false" : "true"));
291 return Str8ToStr16(result);
292 }
293
GetVoiceMailIdentifier()294 std::u16string SimFileManager::GetVoiceMailIdentifier()
295 {
296 if (simFile_ == nullptr) {
297 TELEPHONY_LOGE("SimFileManager::GetVoiceMailIdentifier simFile nullptr");
298 return Str8ToStr16("");
299 }
300
301 std::string result = simFile_->ObtainVoiceMailInfo();
302 TELEPHONY_LOGI(
303 "SimFileManager::GetVoiceMailIdentifier result:%{public}s ", (result.empty() ? "false" : "true"));
304 return Str8ToStr16(result);
305 }
306
GetVoiceMailNumber()307 std::u16string SimFileManager::GetVoiceMailNumber()
308 {
309 if (simFile_ == nullptr) {
310 TELEPHONY_LOGE("SimFileManager::GetVoiceMailNumber simFile nullptr");
311 return Str8ToStr16("");
312 }
313
314 std::string result = simFile_->ObtainVoiceMailNumber();
315 TELEPHONY_LOGI("SimFileManager::GetVoiceMailNumber result:%{public}s ", (result.empty() ? "false" : "true"));
316 return Str8ToStr16(result);
317 }
318
GetOpName()319 std::u16string SimFileManager::GetOpName()
320 {
321 return Str8ToStr16(opName_);
322 }
323
GetOpKey()324 std::u16string SimFileManager::GetOpKey()
325 {
326 return Str8ToStr16(opKey_);
327 }
328
GetOpKeyExt()329 std::u16string SimFileManager::GetOpKeyExt()
330 {
331 return Str8ToStr16(opKeyExt_);
332 }
333
SetOpName(const std::string & opName)334 void SimFileManager::SetOpName(const std::string &opName)
335 {
336 opName_ = opName;
337 }
338
SetOpKey(const std::string & opKey)339 void SimFileManager::SetOpKey(const std::string &opKey)
340 {
341 opKey_ = opKey;
342 }
343
SetOpKeyExt(const std::string & opKeyExt)344 void SimFileManager::SetOpKeyExt(const std::string &opKeyExt)
345 {
346 opKeyExt_ = opKeyExt;
347 }
348
ObtainSpnCondition(bool roaming,const std::string & operatorNum)349 int SimFileManager::ObtainSpnCondition(bool roaming, const std::string &operatorNum)
350 {
351 if (simFile_ == nullptr) {
352 TELEPHONY_LOGE("SimFileManager::ObtainSpnCondition simFile nullptr");
353 return 0;
354 }
355
356 int result = simFile_->ObtainSpnCondition(roaming, operatorNum);
357 TELEPHONY_LOGI("SimFileManager::ObtainSpnCondition:%{public}d", result);
358 return result;
359 }
360
GetIccFile()361 std::shared_ptr<IccFile> SimFileManager::GetIccFile()
362 {
363 return simFile_;
364 }
365
GetIccFileController()366 std::shared_ptr<IccFileController> SimFileManager::GetIccFileController()
367 {
368 return fileController_;
369 }
370
RegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> & handler,int what)371 void SimFileManager::RegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> &handler, int what)
372 {
373 if (what == RadioEvent::RADIO_SIM_STATE_CHANGE && simStateManager_ != nullptr) {
374 simStateManager_->RegisterCoreNotify(handler, what);
375 return;
376 }
377 if (simFile_ == nullptr) {
378 TELEPHONY_LOGE("SimFileManager::RegisterCoreNotify simFile nullptr");
379 return;
380 }
381 simFile_->RegisterCoreNotify(handler, what);
382 }
383
UnRegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> & handler,int what)384 void SimFileManager::UnRegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> &handler, int what)
385 {
386 if (what == RadioEvent::RADIO_SIM_STATE_CHANGE && simStateManager_ != nullptr) {
387 simStateManager_->UnRegisterCoreNotify(handler, what);
388 return;
389 }
390 if (simFile_ == nullptr) {
391 TELEPHONY_LOGE("SimFileManager::UnRegisterCoreNotify simFile nullptr");
392 return;
393 }
394 simFile_->UnRegisterCoreNotify(handler, what);
395 }
396
SetImsi(std::string imsi)397 void SimFileManager::SetImsi(std::string imsi)
398 {
399 if (simFile_ == nullptr) {
400 TELEPHONY_LOGE("SimFileManager::SetImsi simFile nullptr");
401 return;
402 }
403 simFile_->UpdateImsi(imsi);
404 }
405
SetVoiceMailInfo(const std::u16string & mailName,const std::u16string & mailNumber)406 bool SimFileManager::SetVoiceMailInfo(const std::u16string &mailName, const std::u16string &mailNumber)
407 {
408 if (simFile_ == nullptr || !HasSimCard()) {
409 TELEPHONY_LOGE("SimFileManager::SetVoiceMail simFile nullptr");
410 return false;
411 }
412 std::string name = Str16ToStr8(mailName);
413 std::string number = Str16ToStr8(mailNumber);
414 bool result = simFile_->UpdateVoiceMail(name, number);
415 TELEPHONY_LOGI("SimFileManager::SetVoiceMail result:%{public}s ", (!result ? "false" : "true"));
416 return result;
417 }
418
HasSimCard()419 bool SimFileManager::HasSimCard()
420 {
421 if (simStateManager_ == nullptr) {
422 TELEPHONY_LOGE("SimFileManager::HasSimCard simStateManager_ nullptr");
423 return false;
424 }
425 bool result = simStateManager_->HasSimCard();
426 TELEPHONY_LOGI("SimFileManager::HasSimCard result:%{public}s ", (result ? "true" : "false"));
427 return result;
428 }
429
InitDiallingNumberHandler()430 bool SimFileManager::InitDiallingNumberHandler()
431 {
432 if (fileController_ == nullptr) {
433 TELEPHONY_LOGI("InitDiallingNumberHandler null fileController");
434 return false;
435 }
436 if (diallingNumberHandler_ != nullptr) {
437 TELEPHONY_LOGI("InitDiallingNumberHandler update fileController");
438 diallingNumberHandler_->UpdateFileController(fileController_);
439 return true;
440 }
441 std::shared_ptr<AppExecFwk::EventRunner> loaderLoop = AppExecFwk::EventRunner::Create("msisdnLoader");
442 if (loaderLoop.get() == nullptr) {
443 TELEPHONY_LOGE("SimFileManager failed to create diallingNumberloader loop");
444 return false;
445 }
446 diallingNumberHandler_ = std::make_shared<IccDiallingNumbersHandler>(loaderLoop, fileController_);
447 if (diallingNumberHandler_ == nullptr) {
448 TELEPHONY_LOGE("SimFileManager failed to create IccDiallingNumbersHandler.");
449 return false;
450 }
451 loaderLoop->Run();
452 return true;
453 }
454
ObtainDiallingNumberHandler()455 std::shared_ptr<IccDiallingNumbersHandler> SimFileManager::ObtainDiallingNumberHandler()
456 {
457 return diallingNumberHandler_;
458 }
459
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)460 void SimFileManager::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
461 {
462 if (event == nullptr) {
463 TELEPHONY_LOGE("event is nullptr!");
464 return;
465 }
466 uint32_t id = event->GetInnerEventId();
467 TELEPHONY_LOGI("SimFileManager::ProcessEvent id %{public}d", id);
468 if (simStateManager_ == nullptr) {
469 TELEPHONY_LOGE("simStateManager_ is nullptr");
470 return;
471 }
472 switch (id) {
473 case RadioEvent::RADIO_VOICE_TECH_CHANGED: {
474 TELEPHONY_LOGI("SimFileManager receive RADIO_VOICE_TECH_CHANGED");
475 std::shared_ptr<VoiceRadioTechnology> tech = event->GetSharedObject<VoiceRadioTechnology>();
476 SimFileManager::IccType iccType = GetIccTypeByTech(tech);
477 if (iccType == SimFileManager::IccType::ICC_TYPE_CDMA &&
478 simStateManager_->GetCardType() == CardType::SINGLE_MODE_USIM_CARD) {
479 iccType = SimFileManager::IccType::ICC_TYPE_USIM;
480 TELEPHONY_LOGI("SimFileManager change iccType to USIM");
481 }
482 ChangeSimFileByCardType(iccType);
483 break;
484 }
485 case RadioEvent::RADIO_CARD_TYPE_CHANGE: {
486 CardType cardType = simStateManager_->GetCardType();
487 TELEPHONY_LOGI("SimFileManager GetCardType is %{public}d", cardType);
488 SimFileManager::IccType iccType = GetIccTypeByCardType(cardType);
489 ChangeSimFileByCardType(iccType);
490 break;
491 }
492 default:
493 break;
494 }
495 }
496
CreateInstance(const std::shared_ptr<ITelRilManager> & ril,const std::shared_ptr<SimStateManager> & simState)497 std::shared_ptr<SimFileManager> SimFileManager::CreateInstance(
498 const std::shared_ptr<ITelRilManager> &ril, const std::shared_ptr<SimStateManager> &simState)
499 {
500 std::shared_ptr<AppExecFwk::EventRunner> eventLoop = AppExecFwk::EventRunner::Create("simFileMgrLoop");
501 if (eventLoop.get() == nullptr) {
502 TELEPHONY_LOGE("SimFileManager failed to create EventRunner");
503 return nullptr;
504 }
505 if (ril == nullptr) {
506 TELEPHONY_LOGE("SimFileManager::Init rilmanager null pointer");
507 return nullptr;
508 }
509 std::shared_ptr<SimFileManager> manager = std::make_shared<SimFileManager>(eventLoop, ril, simState);
510 if (manager == nullptr) {
511 TELEPHONY_LOGE("SimFileManager::Init manager create nullptr.");
512 return nullptr;
513 }
514 eventLoop->Run();
515 return manager;
516 }
517
ChangeSimFileByCardType(SimFileManager::IccType type)518 void SimFileManager::ChangeSimFileByCardType(SimFileManager::IccType type)
519 {
520 TELEPHONY_LOGI("SimFileManager new icc type:%{public}d, old icc type: %{public}d", type, iccType_);
521 if (!IsValidType(type)) {
522 TELEPHONY_LOGI("SimFileManager handle new icc invalid type received %{public}d", type);
523 return;
524 }
525 if (type == iccType_) {
526 TELEPHONY_LOGI("SimFileManager same type as ready");
527 return;
528 }
529 if (type != iccType_) {
530 TELEPHONY_LOGI("SimFileManager handle new icc type received %{public}d", type);
531 iccType_ = type;
532 if (simFile_ != nullptr) {
533 simFile_->UnInit();
534 }
535 InitIccFileController(type);
536 InitDiallingNumberHandler();
537 InitSimFile(type);
538 }
539 }
540
GetIccTypeByCardType(CardType type)541 SimFileManager::IccType SimFileManager::GetIccTypeByCardType(CardType type)
542 {
543 switch (type) {
544 case CardType::SINGLE_MODE_RUIM_CARD:
545 return SimFileManager::IccType::ICC_TYPE_CDMA;
546 case CardType::SINGLE_MODE_ISIM_CARD:
547 return SimFileManager::IccType::ICC_TYPE_IMS;
548 case CardType::SINGLE_MODE_SIM_CARD:
549 case CardType::DUAL_MODE_CG_CARD:
550 case CardType::CT_NATIONAL_ROAMING_CARD:
551 case CardType::CU_DUAL_MODE_CARD:
552 case CardType::DUAL_MODE_TELECOM_LTE_CARD:
553 case CardType::DUAL_MODE_UG_CARD:
554 return SimFileManager::IccType::ICC_TYPE_GSM;
555 default:
556 break;
557 }
558 return SimFileManager::IccType::ICC_TYPE_USIM;
559 }
560
GetIccTypeByTech(const std::shared_ptr<VoiceRadioTechnology> & tech)561 SimFileManager::IccType SimFileManager::GetIccTypeByTech(const std::shared_ptr<VoiceRadioTechnology> &tech)
562 {
563 if (tech == nullptr) {
564 TELEPHONY_LOGI("GetCardTypeByTech param tech is nullptr then ICC_TYPE_UNKNOW");
565 return SimFileManager::IccType::ICC_TYPE_GSM;
566 }
567 switch (tech->actType) {
568 case int32_t(RadioTech::RADIO_TECHNOLOGY_EHRPD):
569 case int32_t(RadioTech::RADIO_TECHNOLOGY_1XRTT):
570 return SimFileManager::IccType::ICC_TYPE_CDMA;
571 case int32_t(RadioTech::RADIO_TECHNOLOGY_LTE_CA):
572 case int32_t(RadioTech::RADIO_TECHNOLOGY_LTE):
573 case int32_t(RadioTech::RADIO_TECHNOLOGY_GSM):
574 case int32_t(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA):
575 case int32_t(RadioTech::RADIO_TECHNOLOGY_HSPA):
576 case int32_t(RadioTech::RADIO_TECHNOLOGY_HSPAP):
577 default:
578 break;
579 }
580 return SimFileManager::IccType::ICC_TYPE_GSM;
581 }
582
IsValidType(SimFileManager::IccType type)583 bool SimFileManager::IsValidType(SimFileManager::IccType type)
584 {
585 switch (type) {
586 case SimFileManager::IccType::ICC_TYPE_CDMA:
587 case SimFileManager::IccType::ICC_TYPE_GSM:
588 case SimFileManager::IccType::ICC_TYPE_IMS:
589 case SimFileManager::IccType::ICC_TYPE_USIM:
590 return true;
591 default:
592 break;
593 }
594 return false;
595 }
596
GetSimIst()597 std::u16string SimFileManager::GetSimIst()
598 {
599 if (simFile_ == nullptr) {
600 TELEPHONY_LOGE("SimFileManager::GetSimIst simFile nullptr");
601 return Str8ToStr16("");
602 }
603 std::string result = static_cast<IsimFile *>(simFile_.get())->ObtainIsimIst();
604 TELEPHONY_LOGI("SimFileManager::GetSimIst result:%{public}s ", (result.empty() ? "false" : "true"));
605 return Str8ToStr16(result);
606 }
607
ClearData()608 void SimFileManager::ClearData()
609 {
610 if (simFile_ == nullptr) {
611 TELEPHONY_LOGE("SimFileManager::ClearData simFile nullptr");
612 return;
613 }
614 simFile_->ClearData();
615 }
616 } // namespace Telephony
617 } // namespace OHOS