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
Init(int slotId)36 void SimFileManager::Init(int slotId)
37 {
38 TELEPHONY_LOGI("SimFileManager::Init() started slot %{public}d", slotId);
39 slotId_ = slotId;
40 if (stateRecord_ == HandleRunningState::STATE_RUNNING) {
41 TELEPHONY_LOGI("SimFileManager::Init stateRecord_ started.");
42 return;
43 }
44 if (stateHandler_ == HandleRunningState::STATE_RUNNING) {
45 TELEPHONY_LOGI("SimFileManager::Init stateHandler_ started.");
46 return;
47 }
48 if (telRilManager_ == nullptr) {
49 TELEPHONY_LOGE("SimFileManager get NULL ITelRilManager.");
50 return;
51 }
52 CardType cardType = simStateManager_->GetCardType();
53 TELEPHONY_LOGI("SimFileManager current card type is %{public}d", cardType);
54 if ((cardType == static_cast<CardType>(0)) || (cardType == CardType::UNKNOWN_CARD)) {
55 cardType = CardType::SINGLE_MODE_USIM_CARD; // default card
56 }
57 iccType_ = GetIccTypeByCardType(cardType);
58 TELEPHONY_LOGI("SimFileManager current icc type is %{public}d", iccType_);
59 if (!InitIccFileController(iccType_)) {
60 TELEPHONY_LOGE("SimFileManager::InitIccFileController fail");
61 return;
62 }
63 if (!InitDiallingNumberHandler()) {
64 TELEPHONY_LOGE("SimFileManager::InitDiallingNumberHandler fail");
65 return;
66 }
67 if (!InitSimFile(iccType_)) {
68 TELEPHONY_LOGE("SimFileManager::InitSimFile fail");
69 return;
70 }
71 stateRecord_ = HandleRunningState::STATE_RUNNING;
72 stateHandler_ = HandleRunningState::STATE_RUNNING;
73
74 simStateManager_->RegisterCoreNotify(shared_from_this(), RadioEvent::RADIO_CARD_TYPE_CHANGE);
75 telRilManager_->RegisterCoreNotify(
76 slotId, shared_from_this(), RadioEvent::RADIO_VOICE_TECH_CHANGED, nullptr);
77 TELEPHONY_LOGI("SimFileManager::Init() end");
78 }
79
InitSimFile(SimFileManager::IccType type)80 bool SimFileManager::InitSimFile(SimFileManager::IccType type)
81 {
82 if (fileController_ == nullptr || diallingNumberHandler_ == nullptr) {
83 TELEPHONY_LOGE("InitSimFile need more helper");
84 return false;
85 }
86 if (eventLoopRecord_ == nullptr) {
87 eventLoopRecord_ = AppExecFwk::EventRunner::Create("IccFile");
88 if (eventLoopRecord_.get() == nullptr) {
89 TELEPHONY_LOGE("IccFile failed to create EventRunner");
90 return false;
91 }
92 } else {
93 eventLoopRecord_->Stop();
94 }
95 auto iccFileIt = iccFileCache_.find(type);
96 if (iccFileIt == iccFileCache_.end()) {
97 if (type == SimFileManager::IccType::ICC_TYPE_CDMA) {
98 simFile_ = std::make_shared<RuimFile>(eventLoopRecord_, simStateManager_);
99 } else if (type == SimFileManager::IccType::ICC_TYPE_IMS) {
100 simFile_ = std::make_shared<IsimFile>(eventLoopRecord_, simStateManager_);
101 } else {
102 simFile_ = std::make_shared<SimFile>(eventLoopRecord_, simStateManager_);
103 }
104 iccFileCache_.insert(std::make_pair(type, simFile_));
105 } else {
106 simFile_ = iccFileIt->second;
107 }
108
109 if (simFile_ == nullptr) {
110 TELEPHONY_LOGE("SimFileManager::Init simFile create nullptr.");
111 return false;
112 }
113 simFile_->SetRilAndFileController(telRilManager_, fileController_, diallingNumberHandler_);
114 eventLoopRecord_->Run();
115 simFile_->SetId(slotId_);
116 simFile_->Init();
117 return true;
118 }
119
InitIccFileController(SimFileManager::IccType type)120 bool SimFileManager::InitIccFileController(SimFileManager::IccType type)
121 {
122 if (eventLoopFileController_ == nullptr) {
123 eventLoopFileController_ = AppExecFwk::EventRunner::Create("SIMController");
124 if (eventLoopFileController_.get() == nullptr) {
125 TELEPHONY_LOGE("SIMHandler failed to create EventRunner");
126 return false;
127 }
128 } else {
129 eventLoopFileController_->Stop();
130 }
131 auto iccFileConIt = iccFileControllerCache_.find(type);
132 if (iccFileConIt == iccFileControllerCache_.end()) {
133 if (type == SimFileManager::IccType::ICC_TYPE_CDMA) { // ruim 30 usim 20 isim 60
134 fileController_ = std::make_shared<RuimFileController>(eventLoopFileController_, slotId_);
135 } else if (type == SimFileManager::IccType::ICC_TYPE_IMS) {
136 fileController_ = std::make_shared<IsimFileController>(eventLoopFileController_, slotId_);
137 } else if (type == SimFileManager::IccType::ICC_TYPE_GSM) {
138 fileController_ = std::make_shared<SimFileController>(eventLoopFileController_, slotId_);
139 } else {
140 fileController_ = std::make_shared<UsimFileController>(eventLoopFileController_, slotId_);
141 }
142 iccFileControllerCache_.insert(std::make_pair(type, fileController_));
143 } else {
144 fileController_ = iccFileConIt->second;
145 }
146 if (fileController_ == nullptr) {
147 TELEPHONY_LOGE("SimFileManager::Init fileController create nullptr.");
148 return false;
149 }
150 fileController_->SetRilManager(telRilManager_);
151 eventLoopFileController_->Run();
152 return true;
153 }
154
GetSimOperatorNumeric()155 std::u16string SimFileManager::GetSimOperatorNumeric()
156 {
157 if (simFile_ == nullptr) {
158 TELEPHONY_LOGE("SimFileManager::GetSimOperatorNumeric simFile nullptr");
159 return Str8ToStr16("");
160 }
161
162 std::string result = simFile_->ObtainSimOperator();
163 TELEPHONY_LOGI("SimFileManager::GetOperator result:%{public}s ", (result.empty() ? "false" : "true"));
164 return Str8ToStr16(result);
165 }
166
GetISOCountryCodeForSim()167 std::u16string SimFileManager::GetISOCountryCodeForSim()
168 {
169 if (simFile_ == nullptr) {
170 TELEPHONY_LOGE("SimFileManager::GetISOCountryCodeForSim simFile nullptr");
171 return Str8ToStr16("");
172 }
173
174 std::string result = simFile_->ObtainIsoCountryCode();
175 TELEPHONY_LOGI("SimFileManager::ObtainIsoCountryCode result:%{public}s ", (result.empty() ? "false" : "true"));
176 return Str8ToStr16(result);
177 }
178
GetSimSpn()179 std::u16string SimFileManager::GetSimSpn()
180 {
181 if (simFile_ == nullptr) {
182 TELEPHONY_LOGE("SimFileManager::GetSimSpn simFile nullptr");
183 return Str8ToStr16("");
184 }
185
186 std::string result = simFile_->ObtainSPN();
187 TELEPHONY_LOGI("SimFileManager::GetSimSpn result:%{public}s ", (result.empty() ? "false" : "true"));
188 return Str8ToStr16(result);
189 }
190
GetSimIccId()191 std::u16string SimFileManager::GetSimIccId()
192 {
193 if (simFile_ == nullptr) {
194 TELEPHONY_LOGE("SimFileManager::GetSimIccId simFile nullptr");
195 return Str8ToStr16("");
196 }
197
198 std::string result = simFile_->ObtainIccId();
199 TELEPHONY_LOGI("SimFileManager::GetSimIccId result:%{public}s ", (result.empty() ? "false" : "true"));
200 return Str8ToStr16(result);
201 }
202
GetIMSI()203 std::u16string SimFileManager::GetIMSI()
204 {
205 if (simFile_ == nullptr) {
206 TELEPHONY_LOGE("SimFileManager::GetIMSI simFile nullptr");
207 return Str8ToStr16("");
208 }
209
210 std::string result = simFile_->ObtainIMSI();
211 TELEPHONY_LOGI("SimFileManager::ObtainIMSI result:%{public}s ", (result.empty() ? "false" : "true"));
212 return Str8ToStr16(result);
213 }
214
GetLocaleFromDefaultSim()215 std::u16string SimFileManager::GetLocaleFromDefaultSim()
216 {
217 if (simFile_ == nullptr) {
218 TELEPHONY_LOGE("SimFileManager::GetLocaleFromDefaultSim simFile nullptr");
219 return Str8ToStr16("");
220 }
221
222 std::string result = simFile_->ObtainIccLanguage();
223 TELEPHONY_LOGI(
224 "SimFileManager::GetLocaleFromDefaultSim result:%{public}s ", (result.empty() ? "false" : "true"));
225 return Str8ToStr16(result);
226 }
227
GetSimGid1()228 std::u16string SimFileManager::GetSimGid1()
229 {
230 if (simFile_ == nullptr) {
231 TELEPHONY_LOGE("SimFileManager::GetSimGid1 simFile nullptr");
232 return Str8ToStr16("");
233 }
234
235 std::string result = simFile_->ObtainGid1();
236 TELEPHONY_LOGI("SimFileManager::GetSimGid1 result:%{public}s ", (result.empty() ? "false" : "true"));
237 return Str8ToStr16(result);
238 }
239
GetSimTelephoneNumber()240 std::u16string SimFileManager::GetSimTelephoneNumber()
241 {
242 if (simFile_ == nullptr) {
243 TELEPHONY_LOGE("SimFileManager::GetSimTelephoneNumber simFile nullptr");
244 return Str8ToStr16("");
245 }
246
247 std::string result = simFile_->ObtainMsisdnNumber();
248 TELEPHONY_LOGI("SimFileManager::GetSimTelephoneNumber result:%{public}s ", (result.empty() ? "false" : "true"));
249 return Str8ToStr16(result);
250 }
251
GetSimTeleNumberIdentifier()252 std::u16string SimFileManager::GetSimTeleNumberIdentifier()
253 {
254 if (simFile_ == nullptr) {
255 TELEPHONY_LOGE("SimFileManager::GetSimTeleNumberIdentifier simFile nullptr");
256 return Str8ToStr16("");
257 }
258
259 std::string result = simFile_->ObtainMsisdnAlphaStatus();
260 TELEPHONY_LOGI(
261 "SimFileManager::GetSimTeleNumberIdentifier result:%{public}s ", (result.empty() ? "false" : "true"));
262 return Str8ToStr16(result);
263 }
264
GetVoiceMailIdentifier()265 std::u16string SimFileManager::GetVoiceMailIdentifier()
266 {
267 if (simFile_ == nullptr) {
268 TELEPHONY_LOGE("SimFileManager::GetVoiceMailIdentifier simFile nullptr");
269 return Str8ToStr16("");
270 }
271
272 std::string result = simFile_->ObtainVoiceMailInfo();
273 TELEPHONY_LOGI(
274 "SimFileManager::GetVoiceMailIdentifier result:%{public}s ", (result.empty() ? "false" : "true"));
275 return Str8ToStr16(result);
276 }
277
GetVoiceMailNumber()278 std::u16string SimFileManager::GetVoiceMailNumber()
279 {
280 if (simFile_ == nullptr) {
281 TELEPHONY_LOGE("SimFileManager::GetVoiceMailNumber simFile nullptr");
282 return Str8ToStr16("");
283 }
284
285 std::string result = simFile_->ObtainVoiceMailNumber();
286 TELEPHONY_LOGI("SimFileManager::GetVoiceMailNumber result:%{public}s ", (result.empty() ? "false" : "true"));
287 return Str8ToStr16(result);
288 }
289
ObtainSpnCondition(bool roaming,std::string operatorNum)290 int SimFileManager::ObtainSpnCondition(bool roaming, std::string operatorNum)
291 {
292 if (simFile_ == nullptr) {
293 TELEPHONY_LOGE("SimFileManager::ObtainSpnCondition simFile nullptr");
294 return 0;
295 }
296
297 int result = simFile_->ObtainSpnCondition(roaming, operatorNum);
298 TELEPHONY_LOGI("SimFileManager::ObtainSpnCondition:%{public}d", result);
299 return result;
300 }
301
GetIccFile()302 std::shared_ptr<IccFile> SimFileManager::GetIccFile()
303 {
304 return simFile_;
305 }
306
GetIccFileController()307 std::shared_ptr<IccFileController> SimFileManager::GetIccFileController()
308 {
309 return fileController_;
310 }
311
RegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> & handler,int what)312 void SimFileManager::RegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> &handler, int what)
313 {
314 if (simFile_ == nullptr) {
315 TELEPHONY_LOGE("SimFileManager::RegisterCoreNotify simFile nullptr");
316 return;
317 }
318 simFile_->RegisterCoreNotify(handler, what);
319 }
320
UnRegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> & handler,int what)321 void SimFileManager::UnRegisterCoreNotify(const std::shared_ptr<AppExecFwk::EventHandler> &handler, int what)
322 {
323 if (simFile_ == nullptr) {
324 TELEPHONY_LOGE("SimFileManager::UnRegisterCoreNotify simFile nullptr");
325 return;
326 }
327 simFile_->UnRegisterCoreNotify(handler, what);
328 }
329
SetImsi(std::string imsi)330 void SimFileManager::SetImsi(std::string imsi)
331 {
332 if (simFile_ == nullptr) {
333 TELEPHONY_LOGE("SimFileManager::SetImsi simFile nullptr");
334 return;
335 }
336 simFile_->UpdateImsi(imsi);
337 }
338
SetVoiceMailInfo(const std::u16string & mailName,const std::u16string & mailNumber)339 bool SimFileManager::SetVoiceMailInfo(const std::u16string &mailName, const std::u16string &mailNumber)
340 {
341 if (simFile_ == nullptr || !simStateManager_->HasSimCard()) {
342 TELEPHONY_LOGE("SimFileManager::SetVoiceMail simFile nullptr");
343 return false;
344 }
345 std::string name = Str16ToStr8(mailName);
346 std::string number = Str16ToStr8(mailNumber);
347 bool result = simFile_->UpdateVoiceMail(name, number);
348 TELEPHONY_LOGI("SimFileManager::SetVoiceMail result:%{public}s ", (!result ? "false" : "true"));
349 return result;
350 }
351
InitDiallingNumberHandler()352 bool SimFileManager::InitDiallingNumberHandler()
353 {
354 if (fileController_ == nullptr) {
355 TELEPHONY_LOGI("InitDiallingNumberHandler null fileController");
356 return false;
357 }
358 if (diallingNumberHandler_ != nullptr) {
359 TELEPHONY_LOGI("InitDiallingNumberHandler update fileController");
360 diallingNumberHandler_->UpdateFileController(fileController_);
361 return true;
362 }
363 std::shared_ptr<AppExecFwk::EventRunner> loaderLoop = AppExecFwk::EventRunner::Create("msisdnLoader");
364 if (loaderLoop.get() == nullptr) {
365 TELEPHONY_LOGE("SimFileManager failed to create diallingNumberloader loop");
366 return false;
367 }
368 diallingNumberHandler_ = std::make_shared<IccDiallingNumbersHandler>(loaderLoop, fileController_);
369 if (diallingNumberHandler_ == nullptr) {
370 TELEPHONY_LOGE("SimFileManager failed to create IccDiallingNumbersHandler.");
371 return false;
372 }
373 loaderLoop->Run();
374 return true;
375 }
376
ObtainDiallingNumberHandler()377 std::shared_ptr<IccDiallingNumbersHandler> SimFileManager::ObtainDiallingNumberHandler()
378 {
379 return diallingNumberHandler_;
380 }
381
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)382 void SimFileManager::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
383 {
384 int id = event->GetInnerEventId();
385 TELEPHONY_LOGI("SimFileManager::ProcessEvent id %{public}d", id);
386 switch (id) {
387 case RadioEvent::RADIO_VOICE_TECH_CHANGED: {
388 TELEPHONY_LOGI("SimFileManager receive RADIO_VOICE_TECH_CHANGED");
389 std::shared_ptr<VoiceRadioTechnology> tech = event->GetSharedObject<VoiceRadioTechnology>();
390 SimFileManager::IccType iccType = GetIccTypeByTech(tech);
391 ChangeSimFileByCardType(iccType);
392 break;
393 }
394 case RadioEvent::RADIO_CARD_TYPE_CHANGE: {
395 CardType cardType = simStateManager_->GetCardType();
396 TELEPHONY_LOGI("SimFileManager GetCardType is %{public}d", cardType);
397 SimFileManager::IccType iccType = GetIccTypeByCardType(cardType);
398 ChangeSimFileByCardType(iccType);
399 break;
400 }
401 default:
402 break;
403 }
404 }
405
CreateInstance(const std::shared_ptr<ITelRilManager> & ril,const std::shared_ptr<SimStateManager> & simState)406 std::shared_ptr<SimFileManager> SimFileManager::CreateInstance(
407 const std::shared_ptr<ITelRilManager> &ril, const std::shared_ptr<SimStateManager> &simState)
408 {
409 std::shared_ptr<AppExecFwk::EventRunner> eventLoop = AppExecFwk::EventRunner::Create("simFileMgrLoop");
410 if (eventLoop.get() == nullptr) {
411 TELEPHONY_LOGE("SimFileManager failed to create EventRunner");
412 return nullptr;
413 }
414 if (ril == nullptr) {
415 TELEPHONY_LOGE("SimFileManager::Init rilmanager null pointer");
416 return nullptr;
417 }
418 std::shared_ptr<SimFileManager> manager = std::make_shared<SimFileManager>(eventLoop, ril, simState);
419 if (manager == nullptr) {
420 TELEPHONY_LOGE("SimFileManager::Init manager create nullptr.");
421 return nullptr;
422 }
423 eventLoop->Run();
424 return manager;
425 }
426
ChangeSimFileByCardType(SimFileManager::IccType type)427 void SimFileManager::ChangeSimFileByCardType(SimFileManager::IccType type)
428 {
429 TELEPHONY_LOGI("SimFileManager new icc type:%{public}d, old icc type: %{public}d", type, iccType_);
430 if (!IsValidType(type)) {
431 TELEPHONY_LOGI("SimFileManager handle new icc invalid type received %{public}d", type);
432 return;
433 }
434 if (type == iccType_) {
435 TELEPHONY_LOGI("SimFileManager same type as ready");
436 return;
437 }
438 if (type != iccType_) {
439 TELEPHONY_LOGI("SimFileManager handle new icc type received %{public}d", type);
440 iccType_ = type;
441 if (simFile_ != nullptr) {
442 simFile_->UnInit();
443 }
444 InitIccFileController(type);
445 InitDiallingNumberHandler();
446 InitSimFile(type);
447 }
448 }
449
GetIccTypeByCardType(CardType type)450 SimFileManager::IccType SimFileManager::GetIccTypeByCardType(CardType type)
451 {
452 switch (type) {
453 case CardType::SINGLE_MODE_RUIM_CARD:
454 return SimFileManager::IccType::ICC_TYPE_CDMA;
455 case CardType::SINGLE_MODE_ISIM_CARD:
456 return SimFileManager::IccType::ICC_TYPE_IMS;
457 case CardType::SINGLE_MODE_SIM_CARD:
458 case CardType::DUAL_MODE_CG_CARD:
459 case CardType::CT_NATIONAL_ROAMING_CARD:
460 case CardType::CU_DUAL_MODE_CARD:
461 case CardType::DUAL_MODE_TELECOM_LTE_CARD:
462 case CardType::DUAL_MODE_UG_CARD:
463 return SimFileManager::IccType::ICC_TYPE_GSM;
464 default:
465 break;
466 }
467 return SimFileManager::IccType::ICC_TYPE_USIM;
468 }
469
GetIccTypeByTech(const std::shared_ptr<VoiceRadioTechnology> & tech)470 SimFileManager::IccType SimFileManager::GetIccTypeByTech(const std::shared_ptr<VoiceRadioTechnology> &tech)
471 {
472 if (tech == nullptr) {
473 TELEPHONY_LOGI("GetCardTypeByTech param tech is nullptr then ICC_TYPE_UNKNOW");
474 return SimFileManager::IccType::ICC_TYPE_GSM;
475 }
476 switch (tech->actType) {
477 case int32_t(RadioTech::RADIO_TECHNOLOGY_EHRPD):
478 case int32_t(RadioTech::RADIO_TECHNOLOGY_1XRTT):
479 return SimFileManager::IccType::ICC_TYPE_CDMA;
480 case int32_t(RadioTech::RADIO_TECHNOLOGY_LTE_CA):
481 case int32_t(RadioTech::RADIO_TECHNOLOGY_LTE):
482 case int32_t(RadioTech::RADIO_TECHNOLOGY_GSM):
483 case int32_t(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA):
484 case int32_t(RadioTech::RADIO_TECHNOLOGY_HSPA):
485 case int32_t(RadioTech::RADIO_TECHNOLOGY_HSPAP):
486 default:
487 break;
488 }
489 return SimFileManager::IccType::ICC_TYPE_GSM;
490 }
491
IsValidType(SimFileManager::IccType type)492 bool SimFileManager::IsValidType(SimFileManager::IccType type)
493 {
494 switch (type) {
495 case SimFileManager::IccType::ICC_TYPE_CDMA:
496 case SimFileManager::IccType::ICC_TYPE_GSM:
497 case SimFileManager::IccType::ICC_TYPE_IMS:
498 case SimFileManager::IccType::ICC_TYPE_USIM:
499 return true;
500 default:
501 break;
502 }
503 return false;
504 }
505 } // namespace Telephony
506 } // namespace OHOS
507