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 "multi_sim_controller.h"
17 
18 #include <openssl/sha.h>
19 
20 #include "common_event_manager.h"
21 #include "common_event_support.h"
22 #include "core_manager_inner.h"
23 #include "core_service_errors.h"
24 #include "core_service_hisysevent.h"
25 #include "ims_core_service_client.h"
26 #include "tel_aes_crypto_util.h"
27 #include "parameters.h"
28 #include "sim_data.h"
29 #include "sim_utils.h"
30 #include "string_ex.h"
31 #include "telephony_ext_wrapper.h"
32 
33 namespace OHOS {
34 namespace Telephony {
35 static const int32_t EVENT_CODE = 1;
36 static const int32_t IMS_SWITCH_VALUE_UNKNOWN = -1;
37 const int32_t SYSTEM_PARAMETER_LENGTH = 128;
38 static const std::string PARAM_SIMID = "simId";
39 static const std::string PARAM_SET_PRIMARY_STATUS = "setDone";
40 static const std::string DEFAULT_VOICE_SIMID_CHANGED = "defaultVoiceSimIdChanged";
41 static const std::string DEFAULT_SMS_SIMID_CHANGED = "defaultSmsSimIdChanged";
42 static const std::string DEFAULT_CELLULAR_DATA_SIMID_CHANGED = "defaultCellularDataSimIdChanged";
43 static const std::string DEFAULT_MAIN_SIMID_CHANGED = "defaultMainSimIdChanged";
44 static const std::string MAIN_CARD_ICCID_KEY = "persist.telephony.MainCard.Iccid";
45 static const std::string PRIMARY_SLOTID_KEY = "persist.telephony.MainSlotId";
46 static const std::string MAIN_CELLULAR_DATA_SLOTID_KEY = "persist.telephony.MainCellularDataSlotId";
47 static const std::string PRIMARY_SLOTID = "0";
48 
MultiSimController(std::shared_ptr<Telephony::ITelRilManager> telRilManager,std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager,std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager)49 MultiSimController::MultiSimController(std::shared_ptr<Telephony::ITelRilManager> telRilManager,
50     std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager,
51     std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager)
52     : simStateManager_(simStateManager), simFileManager_(simFileManager)
53 {
54     TELEPHONY_LOGI("MultiSimController::MultiSimController");
55     radioProtocolController_ = std::make_shared<RadioProtocolController>(std::weak_ptr<ITelRilManager>(telRilManager));
56     InitMainCardSlotId();
57 }
58 
~MultiSimController()59 MultiSimController::~MultiSimController()
60 {
61     if (radioProtocolController_ != nullptr) {
62         radioProtocolController_->UnRegisterEvents();
63     }
64 }
65 
66 // set all data to invalid wait for InitData to rebuild
Init()67 void MultiSimController::Init()
68 {
69     if (simDbHelper_ == nullptr) {
70         simDbHelper_ = std::make_unique<SimRdbHelper>();
71     }
72     if (radioProtocolController_ != nullptr) {
73         radioProtocolController_->Init();
74     }
75     maxCount_ = SIM_SLOT_COUNT;
76     isSetActiveSimInProgress_.resize(maxCount_, 0);
77     TELEPHONY_LOGI("Create SimRdbHelper count = %{public}d", maxCount_);
78 }
79 
ForgetAllData()80 bool MultiSimController::ForgetAllData()
81 {
82     if (simDbHelper_ == nullptr) {
83         TELEPHONY_LOGE("simDbHelper_ is nullptr failed");
84         return false;
85     }
86     return (simDbHelper_->ForgetAllData() != INVALID_VALUE);
87 }
88 
ForgetAllData(int32_t slotId)89 bool MultiSimController::ForgetAllData(int32_t slotId)
90 {
91     if (simDbHelper_ == nullptr) {
92         TELEPHONY_LOGE("simDbHelper_ is nullptr");
93         return false;
94     }
95     return simDbHelper_->ForgetAllData(slotId) != INVALID_VALUE;
96 }
97 
AddExtraManagers(std::shared_ptr<Telephony::SimStateManager> simStateManager,std::shared_ptr<Telephony::SimFileManager> simFileManager)98 void MultiSimController::AddExtraManagers(std::shared_ptr<Telephony::SimStateManager> simStateManager,
99     std::shared_ptr<Telephony::SimFileManager> simFileManager)
100 {
101     if (static_cast<int>(simStateManager_.size()) == SIM_SLOT_COUNT) {
102         simStateManager_.push_back(simStateManager);
103         simFileManager_.push_back(simFileManager);
104         isSetActiveSimInProgress_.push_back(0);
105         maxCount_ = MAX_SLOT_COUNT;
106         size_t count = localCacheInfo_.size();
107         TELEPHONY_LOGI("localCacheInfo_.size() = %{public}lu, maxCount_ = %{public}d",
108             static_cast<unsigned long>(count), maxCount_);
109     }
110 }
111 
InitData(int32_t slotId)112 bool MultiSimController::InitData(int32_t slotId)
113 {
114     TELEPHONY_LOGI("start to initData slotId is %{public}d", slotId);
115     if (!IsValidData(slotId)) {
116         TELEPHONY_LOGE("has no sim card, abandon");
117         return false;
118     }
119     if (!InitIccId(slotId)) { // check if we insert or reactive a data
120         TELEPHONY_LOGE("can not init IccId");
121         return false;
122     }
123     if (!GetListFromDataBase()) { // init data base to local cache
124         TELEPHONY_LOGE("can not get dataBase");
125         return false;
126     }
127     if (localCacheInfo_.size() <= 0) {
128         TELEPHONY_LOGE("MultiSimController::we get nothing from init");
129         return false;
130     }
131     if (!InitActive(slotId)) {
132         TELEPHONY_LOGE("InitActive failed");
133         return false;
134     }
135     if (!InitShowNumber(slotId)) {
136         TELEPHONY_LOGE("InitShowNumber failed");
137     }
138     if (InitPrimary()) {
139         TELEPHONY_LOGI("InitPrimary start");
140         CheckIfNeedSwitchMainSlotId();
141     }
142     TELEPHONY_LOGI("sim account loaded, slotId is %{public}d, simId is %{public}d", slotId,
143         localCacheInfo_[slotId].simId);
144     return true;
145 }
146 
InitActive(int slotId)147 bool MultiSimController::InitActive(int slotId)
148 {
149     bool result = true;
150     if (!simStateManager_[slotId]->HasSimCard()) {
151         TELEPHONY_LOGI("has no sim and not need to active");
152         return result;
153     }
154     if (!IsSimActive(slotId)) {
155         result = (SetActiveSim(slotId, DEACTIVE, true) == TELEPHONY_ERR_SUCCESS);
156     }
157     if (IsSimActive(slotId)) {
158         result = (SetActiveSim(slotId, ACTIVE, true) == TELEPHONY_ERR_SUCCESS);
159     }
160     return result;
161 }
162 
InitPrimary()163 bool MultiSimController::InitPrimary()
164 {
165     if (maxCount_ <= 1) {
166         TELEPHONY_LOGI("no need to init");
167         return false;
168     }
169     if (!IsAllModemInitDone()) {
170         TELEPHONY_LOGI("wait for the other modem init");
171         return false;
172     }
173     unInitModemSlotId_ = INVALID_VALUE;
174     if (IsAllCardsReady() && !IsAllCardsLoaded()) {
175         TELEPHONY_LOGI("wait for the other card ready");
176         return false;
177     }
178     return true;
179 }
180 
ReCheckPrimary()181 void MultiSimController::ReCheckPrimary()
182 {
183     if (InitPrimary()) {
184         TELEPHONY_LOGI("ReCheckPrimary start");
185         CheckIfNeedSwitchMainSlotId();
186     }
187 }
188 
IsAllCardsReady()189 bool MultiSimController::IsAllCardsReady()
190 {
191     for (int32_t i = 0; i < SIM_SLOT_COUNT; i++) {
192         if (simStateManager_[i] != nullptr && (simStateManager_[i]->GetSimState() != SimState::SIM_STATE_READY
193             && simStateManager_[i]->GetSimState() != SimState::SIM_STATE_LOCKED)) {
194             TELEPHONY_LOGI("slot:%{public}d not ready", i);
195             return false;
196         }
197     }
198     return true;
199 }
200 
IsAllModemInitDone()201 bool MultiSimController::IsAllModemInitDone()
202 {
203     for (int32_t i = 0; i < SIM_SLOT_COUNT; i++) {
204         if (simStateManager_[i] != nullptr && !(simStateManager_[i]->IfModemInitDone())) {
205             TELEPHONY_LOGI("slot:%{public}d modem init not done", i);
206             unInitModemSlotId_ = i;
207             return false;
208         }
209     }
210     return true;
211 }
212 
IsDataShareError()213 bool MultiSimController::IsDataShareError()
214 {
215     return simDbHelper_ != nullptr && simDbHelper_->IsDataShareError();
216 }
217 
ResetDataShareError()218 void MultiSimController::ResetDataShareError()
219 {
220     if (simDbHelper_ != nullptr) {
221         simDbHelper_->ResetDataShareError();
222     }
223 }
224 
UpdateOpKeyInfo()225 int32_t MultiSimController::UpdateOpKeyInfo()
226 {
227     if (simDbHelper_ == nullptr) {
228         TELEPHONY_LOGE("simDbHelper is nullptr");
229         return TELEPHONY_ERROR;
230     }
231     return simDbHelper_->UpdateOpKeyInfo();
232 }
233 
IsAllCardsLoaded()234 bool MultiSimController::IsAllCardsLoaded()
235 {
236     if (localCacheInfo_.empty()) {
237         TELEPHONY_LOGI("there is no card loaded");
238         return false;
239     }
240     for (int32_t i = 0; i < SIM_SLOT_COUNT; i++) {
241         if (localCacheInfo_[i].iccId.empty()) {
242             TELEPHONY_LOGI("slot:%{public}d not loaded", i);
243             return false;
244         }
245     }
246     return true;
247 }
248 
InitIccId(int slotId)249 bool MultiSimController::InitIccId(int slotId)
250 {
251     if (simFileManager_[slotId] == nullptr) {
252         TELEPHONY_LOGE("can not get simFileManager");
253         return false;
254     }
255     std::string newIccId = Str16ToStr8(simFileManager_[slotId]->GetSimIccId());
256     if (newIccId.empty()) {
257         TELEPHONY_LOGI("iccid is empty.");
258         newIccId = "emptyiccid" + std::to_string(slotId);
259     }
260     if (simDbHelper_ == nullptr) {
261         TELEPHONY_LOGE("failed by nullptr");
262         return false;
263     }
264     int32_t result;
265     SimRdbInfo simRdbInfo;
266     if (simDbHelper_->QueryDataByIccId(newIccId, simRdbInfo) == INVALID_VALUE) {
267         TELEPHONY_LOGE("query fail");
268         return false;
269     }
270     if (!simRdbInfo.iccId.empty()) { // already have this card, reactive it
271         TELEPHONY_LOGI("old sim insert");
272         result = UpdateDataByIccId(slotId, newIccId);
273     } else { // insert a new data for new IccId
274         TELEPHONY_LOGI("new sim insert");
275         result = InsertData(slotId, newIccId);
276     }
277     if (result == INVALID_VALUE) {
278         TELEPHONY_LOGE("failed to init data");
279         return false;
280     }
281     TELEPHONY_LOGI("result is %{public}d", result);
282     return true;
283 }
284 
UpdateDataByIccId(int slotId,const std::string & newIccId)285 int32_t MultiSimController::UpdateDataByIccId(int slotId, const std::string &newIccId)
286 {
287     if (simDbHelper_ == nullptr) {
288         TELEPHONY_LOGE("failed by nullptr");
289         return INVALID_VALUE;
290     }
291     DataShare::DataShareValuesBucket values;
292     DataShare::DataShareValueObject slotObj(slotId);
293     values.Put(SimData::SLOT_INDEX, slotObj);
294     const int32_t slotSingle = 1;
295     if (SIM_SLOT_COUNT == slotSingle) {
296         DataShare::DataShareValueObject mainCardObj(MAIN_CARD);
297         values.Put(SimData::IS_MAIN_CARD, mainCardObj);
298         values.Put(SimData::IS_VOICE_CARD, mainCardObj);
299         values.Put(SimData::IS_MESSAGE_CARD, mainCardObj);
300         values.Put(SimData::IS_CELLULAR_DATA_CARD, mainCardObj);
301     }
302     if (simFileManager_[slotId] != nullptr) {
303         std::string operKey = Str16ToStr8(simFileManager_[slotId]->GetOpKey());
304         std::string mcc = Str16ToStr8(simFileManager_[slotId]->GetMCC());
305         std::string mnc = Str16ToStr8(simFileManager_[slotId]->GetMNC());
306         std::string imsi = Str16ToStr8(simFileManager_[slotId]->GetIMSI());
307         DataShare::DataShareValuesBucket valuesExt;
308         DataShare::DataShareValueObject opkeyObj(operKey);
309         DataShare::DataShareValueObject mccObj(mcc);
310         DataShare::DataShareValueObject mncObj(mnc);
311         DataShare::DataShareValueObject imsiObj(imsi);
312         valuesExt.Put(SimData::OPKEY, opkeyObj);
313         valuesExt.Put(SimData::MCC, mccObj);
314         valuesExt.Put(SimData::MNC, mncObj);
315         valuesExt.Put(SimData::IMSI, imsiObj);
316         DataShare::DataSharePredicates predicates;
317         predicates.EqualTo(SimData::ICC_ID, newIccId);
318         int result = simDbHelper_->UpdateDataByIccId(newIccId, valuesExt);
319         TELEPHONY_LOGI("Update Opkey result is %{public}d", result);
320     }
321     return simDbHelper_->UpdateDataByIccId(newIccId, values);
322 }
323 
InsertData(int slotId,const std::string & newIccId)324 int32_t MultiSimController::InsertData(int slotId, const std::string &newIccId)
325 {
326     if (simDbHelper_ == nullptr) {
327         TELEPHONY_LOGE("failed by nullptr");
328         return INVALID_VALUE;
329     }
330     DataShare::DataShareValuesBucket values;
331     DataShare::DataShareValueObject slotObj(slotId);
332     DataShare::DataShareValueObject iccidObj(newIccId);
333     DataShare::DataShareValueObject valueObj(ACTIVE);
334     values.Put(SimData::SLOT_INDEX, slotObj);
335     values.Put(SimData::ICC_ID, iccidObj);
336     values.Put(SimData::CARD_ID, iccidObj); // iccId == cardId by now
337     values.Put(SimData::IS_ACTIVE, valueObj);
338     const int32_t slotSingle = 1;
339     DataShare::DataShareValuesBucket valuesExt;
340     if (simFileManager_[slotId] != nullptr) {
341         std::string operKey = Str16ToStr8(simFileManager_[slotId]->GetOpKey());
342         std::string mcc = Str16ToStr8(simFileManager_[slotId]->GetMCC());
343         std::string mnc = Str16ToStr8(simFileManager_[slotId]->GetMNC());
344         std::string imsi = Str16ToStr8(simFileManager_[slotId]->GetIMSI());
345         DataShare::DataShareValueObject opkeyObj(operKey);
346         DataShare::DataShareValueObject mccObj(mcc);
347         DataShare::DataShareValueObject mncObj(mnc);
348         DataShare::DataShareValueObject imsiObj(imsi);
349         valuesExt.Put(SimData::OPKEY, opkeyObj);
350         valuesExt.Put(SimData::MCC, mccObj);
351         valuesExt.Put(SimData::MNC, mncObj);
352         values.Put(SimData::IMSI, imsiObj);
353     }
354     if (SIM_SLOT_COUNT == slotSingle) {
355         DataShare::DataShareValueObject mainCardObj(MAIN_CARD);
356         values.Put(SimData::IS_MAIN_CARD, mainCardObj);
357         values.Put(SimData::IS_VOICE_CARD, mainCardObj);
358         values.Put(SimData::IS_MESSAGE_CARD, mainCardObj);
359         values.Put(SimData::IS_CELLULAR_DATA_CARD, mainCardObj);
360     } else {
361         DataShare::DataShareValueObject notMainCardObj(NOT_MAIN);
362         values.Put(SimData::IS_MAIN_CARD, notMainCardObj);
363         values.Put(SimData::IS_VOICE_CARD, notMainCardObj);
364         values.Put(SimData::IS_MESSAGE_CARD, notMainCardObj);
365         values.Put(SimData::IS_CELLULAR_DATA_CARD, notMainCardObj);
366     }
367     int64_t id;
368     int result = simDbHelper_->InsertData(id, values);
369     DataShare::DataSharePredicates predicates;
370     predicates.EqualTo(SimData::ICC_ID, newIccId);
371     simDbHelper_->UpdateDataByIccId(newIccId, valuesExt);
372     return result;
373 }
374 
InitShowNumber(int slotId)375 bool MultiSimController::InitShowNumber(int slotId)
376 {
377     std::u16string showNumber;
378     if (!IsValidData(slotId)) {
379         TELEPHONY_LOGE("InValidData");
380         return false;
381     }
382     if (simFileManager_[slotId] == nullptr) {
383         TELEPHONY_LOGE("can not get simFileManager");
384         return false;
385     }
386     showNumber = simFileManager_[slotId]->GetSimTelephoneNumber();
387     int32_t result = TELEPHONY_ERROR;
388     result = SetShowNumberToDB(slotId, showNumber);
389     return result == TELEPHONY_ERR_SUCCESS;
390 }
391 
GetListFromDataBase()392 bool MultiSimController::GetListFromDataBase()
393 {
394     TELEPHONY_LOGD("start");
395     std::vector<SimRdbInfo> newCache;
396     if (simDbHelper_ == nullptr) {
397         TELEPHONY_LOGE("failed by nullptr");
398         return false;
399     }
400     int32_t result = simDbHelper_->QueryAllValidData(newCache);
401     TELEPHONY_LOGI("QueryAllValidData result is %{public}d", result);
402     std::unique_lock<std::mutex> lock(mutex_);
403     if (localCacheInfo_.size() > 0) {
404         localCacheInfo_.clear();
405     }
406     localCacheInfo_ = newCache;
407     SortCache();
408     return (result != INVALID_VALUE) ? true : false;
409 }
410 
SortCache()411 void MultiSimController::SortCache()
412 {
413     size_t count = localCacheInfo_.size();
414     TELEPHONY_LOGI("count = %{public}lu", static_cast<unsigned long>(count));
415     if (count <= 0) {
416         TELEPHONY_LOGE("empty");
417         return;
418     }
419     std::vector<SimRdbInfo> sortCache;
420     SimRdbInfo emptyUnit;
421     emptyUnit.isActive = DEACTIVE;
422     emptyUnit.iccId = "";
423     for (int i = 0; i < maxCount_; i++) {
424         emptyUnit.slotIndex = i;
425         sortCache.emplace_back(emptyUnit);
426     }
427     for (size_t j = 0; j < count; j++) {
428         TELEPHONY_LOGD(
429             "index = %{public}d j = %{public}lu", localCacheInfo_[j].slotIndex, static_cast<unsigned long>(j));
430         sortCache[localCacheInfo_[j].slotIndex] = localCacheInfo_[j];
431     }
432     localCacheInfo_ = sortCache;
433     count = localCacheInfo_.size();
434     TELEPHONY_LOGI("localCacheInfo_.size() = %{public}lu, maxCount_ = %{public}d",
435         static_cast<unsigned long>(count), maxCount_);
436 }
437 
438 /*
439  * check the data is valid, if we don't have SimCard the data is not valid
440  */
IsValidData(int32_t slotId)441 bool MultiSimController::IsValidData(int32_t slotId)
442 {
443     if ((slotId < DEFAULT_SIM_SLOT_ID) || (static_cast<uint32_t>(slotId) >= simStateManager_.size())) {
444         TELEPHONY_LOGE("can not get simStateManager");
445         return false;
446     }
447     if (simStateManager_.empty() || static_cast<uint32_t>(slotId) >= simStateManager_.size() ||
448         simStateManager_[slotId] == nullptr) {
449         TELEPHONY_LOGE("can not get simStateManager");
450         return false;
451     }
452     return simStateManager_[slotId]->HasSimCard();
453 }
454 
RefreshActiveIccAccountInfoList()455 bool MultiSimController::RefreshActiveIccAccountInfoList()
456 {
457     std::unique_lock<std::mutex> lock(mutex_);
458     if (localCacheInfo_.empty()) {
459         TELEPHONY_LOGE("failed by invalid data");
460         return false;
461     }
462     std::vector<SimRdbInfo>::iterator it = localCacheInfo_.begin();
463     if (iccAccountInfoList_.size() > 0) {
464         iccAccountInfoList_.clear();
465     }
466     while (it != localCacheInfo_.end()) { // loop data list
467         if (it->isActive == ACTIVE) { // pick Active item
468             iccAccountInfo_.Init(it->simId, it->slotIndex);
469             iccAccountInfo_.showName = Str8ToStr16(it->showName);
470             iccAccountInfo_.showNumber = Str8ToStr16(it->phoneNumber);
471             iccAccountInfo_.iccId = Str8ToStr16(it->iccId);
472             iccAccountInfo_.isActive = it->isActive;
473             iccAccountInfoList_.emplace_back(iccAccountInfo_);
474         }
475         ++it;
476     }
477     return true;
478 }
479 
GetSlotId(int32_t simId)480 int32_t MultiSimController::GetSlotId(int32_t simId)
481 {
482     std::unique_lock<std::mutex> lock(mutex_);
483     if (localCacheInfo_.empty()) {
484         TELEPHONY_LOGE("failed by nullptr");
485         return INVALID_VALUE;
486     }
487     std::vector<SimRdbInfo>::iterator it = localCacheInfo_.begin();
488 
489     while (it != localCacheInfo_.end()) { // loop data list
490         if (it->isActive == ACTIVE && it->simId == simId) { // pick Active item
491             return it->slotIndex;
492         }
493         ++it;
494     }
495     return INVALID_VALUE;
496 }
497 
GetSimId(int32_t slotId)498 int32_t MultiSimController::GetSimId(int32_t slotId)
499 {
500     IccAccountInfo iccAccountInfo;
501     if (GetSimAccountInfo(slotId, true, iccAccountInfo) == TELEPHONY_ERR_SUCCESS) {
502         return iccAccountInfo.simId;
503     }
504     return INVALID_VALUE;
505 }
506 
IsSimActive(int32_t slotId)507 bool MultiSimController::IsSimActive(int32_t slotId)
508 {
509     if (!IsValidData(slotId)) {
510         return false;
511     }
512     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
513         TELEPHONY_LOGD("failed by out of range");
514         return false;
515     }
516     return localCacheInfo_[slotId].isActive == ACTIVE ? true : false;
517 }
518 
SetActiveSim(int32_t slotId,int32_t enable,bool force)519 int32_t MultiSimController::SetActiveSim(int32_t slotId, int32_t enable, bool force)
520 {
521     TELEPHONY_LOGI("enable = %{public}d slotId = %{public}d", enable, slotId);
522     if (!IsValidData(slotId)) {
523         TELEPHONY_LOGE("invalid slotid or sim card absent.");
524         return TELEPHONY_ERR_NO_SIM_CARD;
525     }
526     int curSimId = 0;
527     if (GetTargetSimId(slotId, curSimId) != TELEPHONY_ERR_SUCCESS) {
528         TELEPHONY_LOGE("failed by out of range");
529         return TELEPHONY_ERR_ARGUMENT_INVALID;
530     }
531     isSetActiveSimInProgress_[slotId] = 1;
532     if (!SetActiveSimToRil(slotId, ENTITY_CARD, enable)) {
533         CoreServiceHiSysEvent::WriteSetActiveSimFaultEvent(
534             slotId, SimCardErrorCode::SET_ACTIVESIM_ERROR, "SetActiveSimToRil failure");
535         TELEPHONY_LOGE("SetActiveSimToRil failed");
536         isSetActiveSimInProgress_[slotId] = 0;
537         return TELEPHONY_ERR_RIL_CMD_FAIL;
538     }
539     if (force) {
540         TELEPHONY_LOGD("no need to update cache");
541         isSetActiveSimInProgress_[slotId] = 0;
542         return TELEPHONY_ERR_SUCCESS;
543     }
544     if (simDbHelper_ == nullptr) {
545         TELEPHONY_LOGE("failed by nullptr");
546         isSetActiveSimInProgress_[slotId] = 0;
547         return TELEPHONY_ERR_LOCAL_PTR_NULL;
548     }
549     DataShare::DataShareValuesBucket values;
550     DataShare::DataShareValueObject valueObj(enable);
551     values.Put(SimData::IS_ACTIVE, valueObj);
552     int32_t result = simDbHelper_->UpdateDataBySimId(curSimId, values);
553     if (result == INVALID_VALUE) {
554         TELEPHONY_LOGE("failed by database");
555         isSetActiveSimInProgress_[slotId] = 0;
556         return TELEPHONY_ERR_DATABASE_WRITE_FAIL;
557     }
558     std::unique_lock<std::mutex> lock(mutex_);
559     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
560         TELEPHONY_LOGE("failed by out of range");
561         isSetActiveSimInProgress_[slotId] = 0;
562         return TELEPHONY_ERR_ARGUMENT_INVALID;
563     }
564     localCacheInfo_[slotId].isActive = enable;
565     lock.unlock();
566     CheckIfNeedSwitchMainSlotId();
567     isSetActiveSimInProgress_[slotId] = 0;
568     return TELEPHONY_ERR_SUCCESS;
569 }
570 
CheckIfNeedSwitchMainSlotId()571 void MultiSimController::CheckIfNeedSwitchMainSlotId()
572 {
573     TELEPHONY_LOGD("start");
574     bool satelliteStatusOn = CoreManagerInner::GetInstance().IsSatelliteEnabled();
575     if (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED) && satelliteStatusOn) {
576         TELEPHONY_LOGI("CheckIfNeedSwitchMainSlotId satelliteStatusOn");
577         return;
578     }
579     int32_t defaultSlotId = getDefaultMainSlotByIccId();
580     if (IsSimActive(defaultSlotId)) {
581         if (IsAllCardsReady() && defaultSlotId != lastPrimarySlotId_) {
582             TELEPHONY_LOGI("defaultSlotId changed, need to set slot%{public}d primary", defaultSlotId);
583             std::thread initDataTask([&, defaultSlotId = defaultSlotId]() {
584                 pthread_setname_np(pthread_self(), "SetPrimarySlotId");
585                 CoreManagerInner::GetInstance().SetPrimarySlotId(defaultSlotId);
586             });
587             initDataTask.detach();
588         } else {
589             TELEPHONY_LOGI("no need set main slot, defaultslot same main slot");
590             SavePrimarySlotIdInfo(defaultSlotId);
591         }
592     } else {
593         int32_t firstActivedSlotId = GetFirstActivedSlotId();
594         if (!IsValidSlotId(firstActivedSlotId)) {
595             TELEPHONY_LOGE("active slotId is invalid");
596             return;
597         }
598         TELEPHONY_LOGI("single card active, need to set slot%{public}d primary", firstActivedSlotId);
599         std::thread initDataTask([&, firstActivedSlotId = firstActivedSlotId]() {
600             pthread_setname_np(pthread_self(), "SetPrimarySlotId");
601             CoreManagerInner::GetInstance().SetPrimarySlotId(firstActivedSlotId);
602         });
603         initDataTask.detach();
604     }
605 }
606 
getDefaultMainSlotByIccId()607 int32_t MultiSimController::getDefaultMainSlotByIccId()
608 {
609     if (SIM_SLOT_COUNT == std::atoi(DEFAULT_SLOT_COUNT)) {
610         TELEPHONY_LOGI("default slotId is 0 for single card version");
611         return DEFAULT_SIM_SLOT_ID;
612     }
613     int mainSlot = lastPrimarySlotId_;
614     if (simFileManager_[SIM_SLOT_0] == nullptr || simFileManager_[SIM_SLOT_1] == nullptr) {
615         TELEPHONY_LOGE("simFileManager_ is null");
616         return mainSlot;
617     }
618     std::string iccIdSub1 = Str16ToStr8(simFileManager_[SIM_SLOT_0]->GetSimIccId());
619     std::string iccIdSub2 = Str16ToStr8(simFileManager_[SIM_SLOT_1]->GetSimIccId());
620     if (iccIdSub1.empty() || iccIdSub2.empty()) {
621         TELEPHONY_LOGD("iccid is null");
622         return mainSlot;
623     }
624     std::string encryptIccIdSub1 = EncryptIccId(iccIdSub1);
625     std::string encryptIccIdSub2 = EncryptIccId(iccIdSub2);
626     char lastMainCardIccId[SYSTEM_PARAMETER_LENGTH] = { 0 };
627     GetParameter(MAIN_CARD_ICCID_KEY.c_str(), "", lastMainCardIccId, SYSTEM_PARAMETER_LENGTH);
628     if (lastMainCardIccId == encryptIccIdSub1) {
629         mainSlot = SIM_SLOT_0;
630     } else if (lastMainCardIccId == encryptIccIdSub2) {
631         mainSlot = SIM_SLOT_1;
632     }
633     TELEPHONY_LOGI("getDefaultMainSlotByIccId is %{public}d", mainSlot);
634     return mainSlot;
635 }
636 
IsValidSlotId(int32_t slotId)637 bool MultiSimController::IsValidSlotId(int32_t slotId)
638 {
639     return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
640 }
641 
SetActiveSimToRil(int32_t slotId,int32_t type,int32_t enable)642 bool MultiSimController::SetActiveSimToRil(int32_t slotId, int32_t type, int32_t enable)
643 {
644     if (radioProtocolController_ == nullptr) {
645         TELEPHONY_LOGE("radioProtocolController_ is nullptr");
646         return false;
647     }
648     std::unique_lock<std::mutex> lck(radioProtocolController_->ctx_);
649     radioProtocolController_->RadioProtocolControllerWait();
650     if (!radioProtocolController_->SetActiveSimToRil(slotId, type, enable)) {
651         TELEPHONY_LOGE("MultiSimController::SetActiveSimToRil failed");
652         return false;
653     }
654     while (!radioProtocolController_->RadioProtocolControllerPoll()) {
655         TELEPHONY_LOGI("MultiSimController SetActiveSimToRil wait");
656         radioProtocolController_->cv_.wait(lck);
657     }
658     return radioProtocolController_->GetActiveSimToRilResult() == static_cast<int32_t>(ErrType::NONE);
659 }
660 
GetSimAccountInfo(int32_t slotId,bool denied,IccAccountInfo & info)661 int32_t MultiSimController::GetSimAccountInfo(int32_t slotId, bool denied, IccAccountInfo &info)
662 {
663     if (!IsValidData(slotId)) {
664         TELEPHONY_LOGE("MultiSimController::GetSimAccountInfo InValidData");
665         return TELEPHONY_ERR_NO_SIM_CARD;
666     }
667     std::unique_lock<std::mutex> lock(mutex_);
668     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
669         TELEPHONY_LOGE("MultiSimController::GetSimAccountInfo failed by out of range");
670         return TELEPHONY_ERR_SLOTID_INVALID;
671     }
672     if (localCacheInfo_[slotId].iccId.empty()) {
673         TELEPHONY_LOGE("MultiSimController::GetSimAccountInfo failed by no data");
674         return CORE_ERR_SIM_CARD_LOAD_FAILED;
675     }
676     info.slotIndex = localCacheInfo_[slotId].slotIndex;
677     info.simId = localCacheInfo_[slotId].simId;
678     info.isActive = localCacheInfo_[slotId].isActive;
679     info.showName = Str8ToStr16(localCacheInfo_[slotId].showName);
680     info.isEsim = false;
681     if (!denied) {
682         info.showNumber = Str8ToStr16(localCacheInfo_[slotId].phoneNumber);
683         info.iccId = Str8ToStr16(localCacheInfo_[slotId].iccId);
684     }
685     return TELEPHONY_ERR_SUCCESS;
686 }
687 
GetDefaultVoiceSlotId()688 int32_t MultiSimController::GetDefaultVoiceSlotId()
689 {
690     std::unique_lock<std::mutex> lock(mutex_);
691     if (localCacheInfo_.size() <= 0) {
692         TELEPHONY_LOGE("failed by nullptr");
693         return INVALID_VALUE;
694     }
695     int32_t i = DEFAULT_SIM_SLOT_ID;
696     for (; i < static_cast<int32_t>(localCacheInfo_.size()); i++) {
697         if (localCacheInfo_[i].isVoiceCard == MAIN_CARD && localCacheInfo_[i].isActive == ACTIVE) {
698             return i;
699         }
700     }
701     return INVALID_VALUE;
702 }
703 
GetLocalCacheSize()704 size_t MultiSimController::GetLocalCacheSize()
705 {
706     std::unique_lock<std::mutex> lock(mutex_);
707     return localCacheInfo_.size();
708 }
709 
GetTargetSimId(int32_t slotId,int & simId)710 int32_t MultiSimController::GetTargetSimId(int32_t slotId, int &simId)
711 {
712     std::unique_lock<std::mutex> lock(mutex_);
713     simId = 0;
714     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
715         return TELEPHONY_ERR_ARGUMENT_INVALID;
716     }
717     simId = localCacheInfo_[slotId].simId;
718     return TELEPHONY_ERR_SUCCESS;
719 }
720 
GetFirstActivedSlotId()721 int32_t MultiSimController::GetFirstActivedSlotId()
722 {
723     int32_t i = DEFAULT_SIM_SLOT_ID;
724     for (; i < maxCount_; i++) {
725         if (localCacheInfo_[i].isActive == ACTIVE) {
726             return localCacheInfo_[i].slotIndex;
727         }
728     }
729     return INVALID_VALUE;
730 }
731 
SetDefaultVoiceSlotId(int32_t slotId)732 int32_t MultiSimController::SetDefaultVoiceSlotId(int32_t slotId)
733 {
734     TELEPHONY_LOGD("slotId = %{public}d", slotId);
735     int curSimId = 0;
736     int32_t ret = GetTargetDefaultSimId(slotId, curSimId);
737     if (ret != TELEPHONY_ERR_SUCCESS) {
738         TELEPHONY_LOGE("ret is %{public}d", ret);
739         return ret;
740     }
741     if (simDbHelper_ == nullptr) {
742         TELEPHONY_LOGE("failed by nullptr");
743         return TELEPHONY_ERR_LOCAL_PTR_NULL;
744     }
745     int32_t result = simDbHelper_->SetDefaultVoiceCard(curSimId);
746     if (result == INVALID_VALUE) {
747         TELEPHONY_LOGE("get Data Base failed");
748         return TELEPHONY_ERR_DATABASE_WRITE_FAIL;
749     }
750     int32_t i = DEFAULT_SIM_SLOT_ID;
751     std::unique_lock<std::mutex> lock(mutex_);
752     if (localCacheInfo_.size() <= 0) {
753         TELEPHONY_LOGE("failed by nullptr");
754         return TELEPHONY_ERR_NO_SIM_CARD;
755     }
756     for (; i < static_cast<int32_t>(localCacheInfo_.size()); i++) { // save to cache
757         if (slotId == i) {
758             localCacheInfo_[i].isVoiceCard = MAIN_CARD;
759             curSimId = localCacheInfo_[i].simId;
760             continue;
761         }
762         localCacheInfo_[i].isVoiceCard = NOT_MAIN;
763     }
764     lock.unlock();
765     if (curSimId == defaultVoiceSimId_) {
766         TELEPHONY_LOGE("no need to AnnounceDefaultVoiceSimIdChanged");
767         return TELEPHONY_ERR_SUCCESS;
768     }
769     defaultVoiceSimId_ = curSimId;
770     if (!AnnounceDefaultVoiceSimIdChanged(defaultVoiceSimId_)) {
771         return TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL;
772     }
773     return TELEPHONY_ERR_SUCCESS;
774 }
775 
GetDefaultSmsSlotId()776 int32_t MultiSimController::GetDefaultSmsSlotId()
777 {
778     std::unique_lock<std::mutex> lock(mutex_);
779     if (localCacheInfo_.size() <= 0) {
780         TELEPHONY_LOGE("failed by nullptr");
781         return INVALID_VALUE;
782     }
783     int32_t i = DEFAULT_SIM_SLOT_ID;
784     for (; i < static_cast<int32_t>(localCacheInfo_.size()); i++) {
785         if (localCacheInfo_[i].isMessageCard == MAIN_CARD && localCacheInfo_[i].isActive == ACTIVE) {
786             return i;
787         }
788     }
789     return GetFirstActivedSlotId();
790 }
791 
SetDefaultSmsSlotId(int32_t slotId)792 int32_t MultiSimController::SetDefaultSmsSlotId(int32_t slotId)
793 {
794     TELEPHONY_LOGD("slotId = %{public}d", slotId);
795     int curSimId = 0;
796     int32_t ret = GetTargetDefaultSimId(slotId, curSimId);
797     if (ret != TELEPHONY_ERR_SUCCESS) {
798         TELEPHONY_LOGE("ret is %{public}d", ret);
799         return ret;
800     }
801     if (simDbHelper_ == nullptr) {
802         TELEPHONY_LOGE("failed by nullptr");
803         return TELEPHONY_ERR_LOCAL_PTR_NULL;
804     }
805     int32_t result = simDbHelper_->SetDefaultMessageCard(curSimId);
806     if (result == INVALID_VALUE) {
807         TELEPHONY_LOGE("get Data Base failed");
808         return TELEPHONY_ERR_DATABASE_WRITE_FAIL;
809     }
810     int32_t i = DEFAULT_SIM_SLOT_ID;
811     std::unique_lock<std::mutex> lock(mutex_);
812     if (localCacheInfo_.size() <= 0) {
813         TELEPHONY_LOGE("failed by nullptr");
814         return TELEPHONY_ERR_NO_SIM_CARD;
815     }
816     for (; i < static_cast<int32_t>(localCacheInfo_.size()); i++) { // save to cache
817         if (slotId == i) {
818             localCacheInfo_[i].isMessageCard = MAIN_CARD;
819             curSimId = localCacheInfo_[slotId].simId;
820             continue;
821         }
822         localCacheInfo_[i].isMessageCard = NOT_MAIN;
823     }
824     lock.unlock();
825     if (curSimId == defaultSmsSimId_) {
826         TELEPHONY_LOGE("no need to AnnounceDefaultSmsSimIdChanged");
827         return TELEPHONY_ERR_SUCCESS;
828     }
829     defaultSmsSimId_ = curSimId;
830     if (!AnnounceDefaultSmsSimIdChanged(defaultSmsSimId_)) {
831         return TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL;
832     }
833     return TELEPHONY_ERR_SUCCESS;
834 }
835 
GetTargetDefaultSimId(int32_t slotId,int & simId)836 int32_t MultiSimController::GetTargetDefaultSimId(int32_t slotId, int &simId)
837 {
838     std::unique_lock<std::mutex> lock(mutex_);
839     simId = 0;
840     if ((slotId == DEFAULT_SIM_SLOT_ID_REMOVE && localCacheInfo_.empty()) ||
841         (slotId != DEFAULT_SIM_SLOT_ID_REMOVE && !IsValidData(slotId))) {
842         TELEPHONY_LOGE("no sim card");
843         return TELEPHONY_ERR_NO_SIM_CARD;
844     }
845     if (slotId != DEFAULT_SIM_SLOT_ID_REMOVE && !IsSimActive(slotId)) {
846         TELEPHONY_LOGE("slotId is not active!");
847         return CORE_SERVICE_SIM_CARD_IS_NOT_ACTIVE;
848     }
849     if (slotId != DEFAULT_SIM_SLOT_ID_REMOVE) {
850         simId = localCacheInfo_[slotId].simId;
851     }
852     return TELEPHONY_ERR_SUCCESS;
853 }
854 
GetDefaultCellularDataSlotId()855 int32_t MultiSimController::GetDefaultCellularDataSlotId()
856 {
857     TELEPHONY_LOGD("start lastCellularDataSlotId_ is %{public}d", lastCellularDataSlotId_);
858     return lastCellularDataSlotId_;
859 }
860 
SetDefaultCellularDataSlotId(int32_t slotId)861 int32_t MultiSimController::SetDefaultCellularDataSlotId(int32_t slotId)
862 {
863     SaveDefaultCellularDataSlotIdInfo(slotId);
864     CoreServiceHiSysEvent::WriteDefaultDataSlotIdBehaviorEvent(slotId);
865     return TELEPHONY_ERR_SUCCESS;
866 }
867 
GetPrimarySlotId()868 int32_t MultiSimController::GetPrimarySlotId()
869 {
870     TELEPHONY_LOGD("start lastPrimarySlotId_ is %{public}d", lastPrimarySlotId_);
871     return lastPrimarySlotId_;
872 }
873 
SetPrimarySlotId(int32_t slotId)874 int32_t MultiSimController::SetPrimarySlotId(int32_t slotId)
875 {
876     TELEPHONY_LOGD("slotId = %{public}d", slotId);
877     if (TELEPHONY_EXT_WRAPPER.isHandleVSim_ && TELEPHONY_EXT_WRAPPER.isHandleVSim_()) {
878         TELEPHONY_LOGE("in vsim handle, not allowed switch card");
879         return TELEPHONY_ERR_FAIL;
880     }
881 
882     if (!IsValidData(slotId)) {
883         TELEPHONY_LOGE("no sim card");
884         return TELEPHONY_ERR_NO_SIM_CARD;
885     }
886     if (lastPrimarySlotId_ == slotId) {
887         TELEPHONY_LOGI("The current slot is the main slot, no need to set primary slot");
888         SavePrimarySlotIdInfo(slotId);
889         return TELEPHONY_ERR_SUCCESS;
890     }
891     // change protocol for default cellulardata slotId
892     isSetPrimarySlotIdInProgress_ = true;
893     PublishSetPrimaryEvent(false);
894     if (radioProtocolController_ == nullptr || !radioProtocolController_->SetRadioProtocol(slotId)) {
895         TELEPHONY_LOGE("SetRadioProtocol failed");
896         isSetPrimarySlotIdInProgress_ = false;
897         PublishSetPrimaryEvent(true);
898         return TELEPHONY_ERR_LOCAL_PTR_NULL;
899     }
900     SavePrimarySlotIdInfo(slotId);
901     isSetPrimarySlotIdInProgress_ = false;
902     PublishSetPrimaryEvent(true);
903     return TELEPHONY_ERR_SUCCESS;
904 }
905 
PublishSetPrimaryEvent(bool setDone)906 void MultiSimController::PublishSetPrimaryEvent(bool setDone)
907 {
908     AAFwk::Want want;
909     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SET_PRIMARY_SLOT_STATUS);
910     want.SetParam(PARAM_SET_PRIMARY_STATUS, setDone);
911     EventFwk::CommonEventData data;
912     data.SetWant(want);
913 
914     EventFwk::CommonEventPublishInfo publishInfo;
915     publishInfo.SetSticky(true);
916     bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
917     TELEPHONY_LOGI("result : %{public}d", publishResult);
918 }
919 
SendMainCardBroadCast(int32_t slotId)920 void MultiSimController::SendMainCardBroadCast(int32_t slotId)
921 {
922     std::unique_lock<std::mutex> lock(mutex_);
923     if (localCacheInfo_.empty() || static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
924         TELEPHONY_LOGE("no need to update cache");
925         return;
926     }
927     if (localCacheInfo_[slotId].simId == primarySimId_) {
928         TELEPHONY_LOGE("no need to AnnouncePrimarySimIdChanged");
929         return;
930     }
931     primarySimId_ = localCacheInfo_[slotId].simId;
932     lock.unlock();
933     TELEPHONY_LOGI("Announce main simId %{public}d", primarySimId_);
934     AnnouncePrimarySimIdChanged(primarySimId_);
935 }
936 
SendDefaultCellularDataBroadCast(int32_t slotId)937 void MultiSimController::SendDefaultCellularDataBroadCast(int32_t slotId)
938 {
939     if (localCacheInfo_.empty() || static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
940         TELEPHONY_LOGE("no need to update cache");
941         return;
942     }
943     if (localCacheInfo_[slotId].simId == defaultCellularSimId_) {
944         TELEPHONY_LOGE("no need to AnnouncePrimarySimIdChanged");
945         return;
946     }
947     defaultCellularSimId_ = localCacheInfo_[slotId].simId;
948     TELEPHONY_LOGI("Announce default cellular data simId %{public}d", defaultCellularSimId_);
949     AnnounceDefaultCellularDataSimIdChanged(defaultCellularSimId_);
950 }
951 
EncryptIccId(const std::string iccid)952 std::string MultiSimController::EncryptIccId(const std::string iccid)
953 {
954     unsigned char hash[SHA256_DIGEST_LENGTH];
955     SHA256_CTX sha256;
956     SHA256_Init(&sha256);
957     SHA256_Update(&sha256, iccid.c_str(), iccid.size());
958     SHA256_Final(hash, &sha256);
959     std::string encryptIccId = SIMUtils::BytesConvertToHexString(hash, SHA256_DIGEST_LENGTH);
960     return encryptIccId;
961 }
962 
SavePrimarySlotIdInfo(int32_t slotId)963 void MultiSimController::SavePrimarySlotIdInfo(int32_t slotId)
964 {
965     lastPrimarySlotId_ = slotId;
966     SetParameter(PRIMARY_SLOTID_KEY.c_str(), std::to_string(slotId).c_str());
967     if (simFileManager_[slotId] == nullptr) {
968         TELEPHONY_LOGE("simFileManager_ is null slotId is %{public}d", slotId);
969         return;
970     }
971     std::string iccId = Str16ToStr8(simFileManager_[slotId]->GetSimIccId());
972     TELEPHONY_LOGI("save data is empty %{public}d", iccId.empty());
973     if (!iccId.empty()) {
974         std::string encryptIccId = EncryptIccId(iccId);
975         SetParameter(MAIN_CARD_ICCID_KEY.c_str(), encryptIccId.c_str());
976     }
977     SendMainCardBroadCast(slotId);
978     SetDefaultCellularDataSlotId(slotId);
979 }
980 
SaveDefaultCellularDataSlotIdInfo(int32_t slotId)981 void MultiSimController::SaveDefaultCellularDataSlotIdInfo(int32_t slotId)
982 {
983     SetParameter(MAIN_CELLULAR_DATA_SLOTID_KEY.c_str(), std::to_string(slotId).c_str());
984     lastCellularDataSlotId_ = slotId;
985     SendDefaultCellularDataBroadCast(slotId);
986 }
987 
InitMainCardSlotId()988 void MultiSimController::InitMainCardSlotId()
989 {
990     char lastPrimarySlotId[SYSTEM_PARAMETER_LENGTH] = { 0 };
991     GetParameter(PRIMARY_SLOTID_KEY.c_str(), PRIMARY_SLOTID.c_str(), lastPrimarySlotId, SYSTEM_PARAMETER_LENGTH);
992     lastPrimarySlotId_ = std::atoi(lastPrimarySlotId);
993 
994     char lastCellularDataSlotId[SYSTEM_PARAMETER_LENGTH] = { 0 };
995     GetParameter(
996         MAIN_CELLULAR_DATA_SLOTID_KEY.c_str(), PRIMARY_SLOTID.c_str(), lastCellularDataSlotId, SYSTEM_PARAMETER_LENGTH);
997     lastCellularDataSlotId_ = std::atoi(lastCellularDataSlotId);
998 }
999 
GetShowNumber(int32_t slotId,std::u16string & showNumber)1000 int32_t MultiSimController::GetShowNumber(int32_t slotId, std::u16string &showNumber)
1001 {
1002     if (!IsValidData(slotId)) {
1003         TELEPHONY_LOGE("InValidData");
1004         return TELEPHONY_ERR_NO_SIM_CARD;
1005     }
1006     if (simFileManager_[slotId] == nullptr) {
1007         TELEPHONY_LOGE("can not get simFileManager");
1008         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1009     }
1010     showNumber = simFileManager_[slotId]->GetSimTelephoneNumber();
1011     if (!showNumber.empty()) {
1012         TELEPHONY_LOGI("get phone number from sim");
1013         return TELEPHONY_ERR_SUCCESS;
1014     }
1015     int curSimId;
1016     if (GetTargetSimId(slotId, curSimId) != TELEPHONY_ERR_SUCCESS) {
1017         TELEPHONY_LOGE("failed by out of range");
1018         return TELEPHONY_ERR_ARGUMENT_INVALID;
1019     }
1020     showNumber = Str8ToStr16(localCacheInfo_[slotId].phoneNumber);
1021     if (!showNumber.empty()) {
1022         return TELEPHONY_ERR_SUCCESS;
1023     }
1024     return GetSimTelephoneNumber(slotId, showNumber);
1025 }
1026 
SetShowNumber(int32_t slotId,std::u16string number,bool force)1027 int32_t MultiSimController::SetShowNumber(int32_t slotId, std::u16string number, bool force)
1028 {
1029     TELEPHONY_LOGI("MultiSimController::SetShowNumber slotId = %{public}d", slotId);
1030     if (!force && !IsValidData(slotId)) {
1031         TELEPHONY_LOGE("MultiSimController::SetShowNumber InValidData");
1032         return TELEPHONY_ERR_NO_SIM_CARD;
1033     }
1034     if (simFileManager_[slotId] == nullptr) {
1035         TELEPHONY_LOGE("can not get simFileManager");
1036         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1037     }
1038     std::u16string alphaTag = simFileManager_[slotId]->GetSimTeleNumberIdentifier();
1039     if (!simFileManager_[slotId]->SetSimTelephoneNumber(alphaTag, number)) {
1040         return TELEPHONY_ERR_FAIL;
1041     }
1042     return SetShowNumberToDB(slotId, number);
1043 }
1044 
SetShowNumberToDB(int32_t slotId,std::u16string number)1045 int32_t MultiSimController::SetShowNumberToDB(int32_t slotId, std::u16string number)
1046 {
1047     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
1048         TELEPHONY_LOGE("failed by nullptr");
1049         return false;
1050     }
1051     int curSimId;
1052     if (GetTargetSimId(slotId, curSimId) != TELEPHONY_ERR_SUCCESS) {
1053         TELEPHONY_LOGE("MultiSimController::SetShowNumber failed by out of range");
1054         return TELEPHONY_ERR_ARGUMENT_INVALID;
1055     }
1056     if (simDbHelper_ == nullptr) {
1057         TELEPHONY_LOGE("MultiSimController::SetShowNumber failed by nullptr");
1058         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1059     }
1060     DataShare::DataShareValuesBucket values;
1061     DataShare::DataShareValueObject valueObj(Str16ToStr8(number));
1062     values.Put(SimData::PHONE_NUMBER, valueObj);
1063     int32_t result = simDbHelper_->UpdateDataBySimId(curSimId, values);
1064     if (result == INVALID_VALUE) {
1065         TELEPHONY_LOGE("MultiSimController::SetShowNumber set Data Base failed");
1066         return TELEPHONY_ERR_DATABASE_WRITE_FAIL;
1067     }
1068     std::unique_lock<std::mutex> lock(mutex_);
1069     if ((static_cast<uint32_t>(slotId) >= localCacheInfo_.size())) {
1070         TELEPHONY_LOGE("localCacheInfo_ is empty");
1071         return TELEPHONY_ERR_NO_SIM_CARD;
1072     }
1073     localCacheInfo_[slotId].phoneNumber = Str16ToStr8(number); // save to cache
1074     return TELEPHONY_ERR_SUCCESS;
1075 }
1076 
GetShowName(int32_t slotId,std::u16string & showName)1077 int32_t MultiSimController::GetShowName(int32_t slotId, std::u16string &showName)
1078 {
1079     if (!IsValidData(slotId)) {
1080         TELEPHONY_LOGE("InValidData");
1081         return TELEPHONY_ERR_NO_SIM_CARD;
1082     }
1083     std::unique_lock<std::mutex> lock(mutex_);
1084     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
1085         TELEPHONY_LOGE("failed by nullptr");
1086         return TELEPHONY_ERR_ARGUMENT_INVALID;
1087     }
1088     showName = Str8ToStr16(localCacheInfo_[slotId].showName);
1089     lock.unlock();
1090     TELEPHONY_LOGD("Get the SIM name set by the user");
1091     return TELEPHONY_ERR_SUCCESS;
1092 }
1093 
SetShowName(int32_t slotId,std::u16string name,bool force)1094 int32_t MultiSimController::SetShowName(int32_t slotId, std::u16string name, bool force)
1095 {
1096     if (!force && !IsValidData(slotId)) {
1097         TELEPHONY_LOGE("MultiSimController::SetShowNumber InValidData");
1098         return TELEPHONY_ERR_NO_SIM_CARD;
1099     }
1100     int curSimId;
1101     if (GetTargetSimId(slotId, curSimId) != TELEPHONY_ERR_SUCCESS) {
1102         TELEPHONY_LOGE("MultiSimController::SetShowName failed by out of range");
1103         return TELEPHONY_ERR_ARGUMENT_INVALID;
1104     }
1105     if (simDbHelper_ == nullptr) {
1106         TELEPHONY_LOGE("MultiSimController::SetShowName get Data Base failed");
1107         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1108     }
1109     DataShare::DataShareValuesBucket values;
1110     DataShare::DataShareValueObject valueObj(Str16ToStr8(name));
1111     values.Put(SimData::SHOW_NAME, valueObj);
1112     int32_t result = simDbHelper_->UpdateDataBySimId(curSimId, values);
1113     if (result == INVALID_VALUE) {
1114         TELEPHONY_LOGE("MultiSimController::SetShowName set Data Base failed");
1115         return TELEPHONY_ERR_DATABASE_WRITE_FAIL;
1116     }
1117     std::unique_lock<std::mutex> lock(mutex_);
1118     if ((static_cast<uint32_t>(slotId) >= localCacheInfo_.size())) {
1119         TELEPHONY_LOGE("failed by out of range");
1120         return TELEPHONY_ERR_ARGUMENT_INVALID;
1121     }
1122     localCacheInfo_[slotId].showName = Str16ToStr8(name); // save to cache
1123     return TELEPHONY_ERR_SUCCESS;
1124 }
1125 
GetSimTelephoneNumber(int32_t slotId,std::u16string & telephoneNumber)1126 int32_t MultiSimController::GetSimTelephoneNumber(int32_t slotId, std::u16string &telephoneNumber)
1127 {
1128     if (!IsValidData(slotId)) {
1129         TELEPHONY_LOGE("InValidData");
1130         return TELEPHONY_ERR_NO_SIM_CARD;
1131     }
1132     std::shared_ptr<ImsCoreServiceClient> imsCoreServiceClient = DelayedSingleton<ImsCoreServiceClient>::GetInstance();
1133     if (imsCoreServiceClient == nullptr) {
1134         TELEPHONY_LOGE("can not get imsCoreServiceClient");
1135         return TELEPHONY_ERR_LOCAL_PTR_NULL;
1136     }
1137     std::string result = "";
1138     imsCoreServiceClient->GetPhoneNumberFromIMPU(slotId, result);
1139     telephoneNumber = Str8ToStr16(result);
1140     TELEPHONY_LOGI("impu result is empty:%{public}s, slotId:%{public}d", (telephoneNumber.empty() ? "true" : "false"),
1141         slotId);
1142     return TELEPHONY_ERR_SUCCESS;
1143 }
1144 
GetTargetIccId(int32_t slotId,std::string & iccId)1145 int32_t MultiSimController::GetTargetIccId(int32_t slotId, std::string &iccId)
1146 {
1147     std::unique_lock<std::mutex> lock(mutex_);
1148     iccId = "";
1149     if (static_cast<uint32_t>(slotId) >= localCacheInfo_.size()) {
1150         TELEPHONY_LOGE("failed by out of range");
1151         return TELEPHONY_ERROR;
1152     }
1153     iccId = localCacheInfo_[slotId].iccId;
1154     return TELEPHONY_ERR_SUCCESS;
1155 }
1156 
AnnounceDefaultVoiceSimIdChanged(int32_t simId)1157 bool MultiSimController::AnnounceDefaultVoiceSimIdChanged(int32_t simId)
1158 {
1159     AAFwk::Want want;
1160     want.SetParam(PARAM_SIMID, simId);
1161     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_VOICE_SUBSCRIPTION_CHANGED);
1162     int32_t eventCode = EVENT_CODE;
1163     std::string eventData(DEFAULT_VOICE_SIMID_CHANGED);
1164     return PublishSimFileEvent(want, eventCode, eventData);
1165 }
1166 
AnnounceDefaultSmsSimIdChanged(int32_t simId)1167 bool MultiSimController::AnnounceDefaultSmsSimIdChanged(int32_t simId)
1168 {
1169     AAFwk::Want want;
1170     want.SetParam(PARAM_SIMID, simId);
1171     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_SMS_SUBSCRIPTION_CHANGED);
1172     int32_t eventCode = EVENT_CODE;
1173     std::string eventData(DEFAULT_SMS_SIMID_CHANGED);
1174     return PublishSimFileEvent(want, eventCode, eventData);
1175 }
1176 
AnnounceDefaultCellularDataSimIdChanged(int32_t simId)1177 bool MultiSimController::AnnounceDefaultCellularDataSimIdChanged(int32_t simId)
1178 {
1179     AAFwk::Want want;
1180     want.SetParam(PARAM_SIMID, simId);
1181     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED);
1182     int32_t eventCode = EVENT_CODE;
1183     std::string eventData(DEFAULT_CELLULAR_DATA_SIMID_CHANGED);
1184     return PublishSimFileEvent(want, eventCode, eventData);
1185 }
1186 
AnnouncePrimarySimIdChanged(int32_t simId)1187 bool MultiSimController::AnnouncePrimarySimIdChanged(int32_t simId)
1188 {
1189     AAFwk::Want want;
1190     want.SetParam(PARAM_SIMID, simId);
1191     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_MAIN_SUBSCRIPTION_CHANGED);
1192     int32_t eventCode = EVENT_CODE;
1193     std::string eventData(DEFAULT_MAIN_SIMID_CHANGED);
1194     return PublishSimFileEvent(want, eventCode, eventData);
1195 }
1196 
PublishSimFileEvent(const AAFwk::Want & want,int eventCode,const std::string & eventData)1197 bool MultiSimController::PublishSimFileEvent(const AAFwk::Want &want, int eventCode, const std::string &eventData)
1198 {
1199     EventFwk::CommonEventData data;
1200     data.SetWant(want);
1201     data.SetCode(eventCode);
1202     data.SetData(eventData);
1203     EventFwk::CommonEventPublishInfo publishInfo;
1204     publishInfo.SetOrdered(false);
1205     bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
1206     TELEPHONY_LOGD("MultiSimController::PublishSimFileEvent end###publishResult = %{public}d", publishResult);
1207     return publishResult;
1208 }
1209 
SaveImsSwitch(int32_t slotId,int32_t imsSwitchValue)1210 int32_t MultiSimController::SaveImsSwitch(int32_t slotId, int32_t imsSwitchValue)
1211 {
1212     std::string curIccid = "";
1213     if (GetTargetIccId(slotId, curIccid) != TELEPHONY_SUCCESS || simDbHelper_ == nullptr) {
1214         TELEPHONY_LOGE("failed by out of range or simDbHelper is nullptr");
1215         imsSwitchValue = IMS_SWITCH_VALUE_UNKNOWN;
1216         return TELEPHONY_ERROR;
1217     }
1218     DataShare::DataShareValuesBucket values;
1219     DataShare::DataShareValueObject valueObj(imsSwitchValue);
1220     values.Put(SimData::IMS_SWITCH, valueObj);
1221     return simDbHelper_->UpdateDataByIccId(curIccid, values);
1222 }
1223 
QueryImsSwitch(int32_t slotId,int32_t & imsSwitchValue)1224 int32_t MultiSimController::QueryImsSwitch(int32_t slotId, int32_t &imsSwitchValue)
1225 {
1226     std::string curIccid = "";
1227     if (GetTargetIccId(slotId, curIccid) != TELEPHONY_SUCCESS || simDbHelper_ == nullptr) {
1228         TELEPHONY_LOGE("failed by out of range or simDbHelper is nullptr");
1229         imsSwitchValue = IMS_SWITCH_VALUE_UNKNOWN;
1230         return TELEPHONY_ERROR;
1231     }
1232     SimRdbInfo simRdbInfo;
1233     simRdbInfo.imsSwitch = IMS_SWITCH_STATUS_UNKNOWN;
1234     simDbHelper_->QueryDataByIccId(curIccid, simRdbInfo);
1235     imsSwitchValue = simRdbInfo.imsSwitch;
1236     return TELEPHONY_SUCCESS;
1237 }
1238 
GetActiveSimAccountInfoList(bool denied,std::vector<IccAccountInfo> & iccAccountInfoList)1239 int32_t MultiSimController::GetActiveSimAccountInfoList(bool denied, std::vector<IccAccountInfo> &iccAccountInfoList)
1240 {
1241     if (!RefreshActiveIccAccountInfoList()) {
1242         TELEPHONY_LOGE("refresh failed");
1243         return TELEPHONY_ERR_NO_SIM_CARD;
1244     }
1245     iccAccountInfoList.clear();
1246     std::unique_lock<std::mutex> lock(mutex_);
1247     std::vector<IccAccountInfo>::iterator it = iccAccountInfoList_.begin();
1248     while (it != iccAccountInfoList_.end()) {
1249         TELEPHONY_LOGI("slotIndex=%{public}d", it->slotIndex);
1250         if (denied) {
1251             it->iccId = u"";
1252             it->showNumber = u"";
1253         }
1254         iccAccountInfoList.emplace_back(*it);
1255         ++it;
1256     }
1257     return iccAccountInfoList.size() > 0 ? TELEPHONY_ERR_SUCCESS : TELEPHONY_ERR_NO_SIM_CARD;
1258 }
1259 
GetRadioProtocolTech(int32_t slotId)1260 int32_t MultiSimController::GetRadioProtocolTech(int32_t slotId)
1261 {
1262     if (radioProtocolController_ == nullptr) {
1263         TELEPHONY_LOGE("radioProtocolController_ is nullptr");
1264         return static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN);
1265     }
1266     return radioProtocolController_->GetRadioProtocolTech(slotId);
1267 }
1268 
GetRadioProtocol(int32_t slotId)1269 void MultiSimController::GetRadioProtocol(int32_t slotId)
1270 {
1271     if (radioProtocolController_ == nullptr) {
1272         TELEPHONY_LOGE("radioProtocolController_ is nullptr");
1273         return;
1274     }
1275     radioProtocolController_->GetRadioProtocol(slotId);
1276 }
IsSatelliteSupported()1277 int32_t MultiSimController::IsSatelliteSupported()
1278 {
1279     char satelliteSupported[SYSPARA_SIZE] = { 0 };
1280     GetParameter(TEL_SATELLITE_SUPPORTED, SATELLITE_DEFAULT_VALUE, satelliteSupported, SYSPARA_SIZE);
1281     TELEPHONY_LOGI("satelliteSupported is %{public}s", satelliteSupported);
1282     return std::atoi(satelliteSupported);
1283 }
1284 
IsSetActiveSimInProgress(int32_t slotId)1285 bool MultiSimController::IsSetActiveSimInProgress(int32_t slotId)
1286 {
1287     if (static_cast<uint32_t>(slotId) >= isSetActiveSimInProgress_.size()) {
1288         TELEPHONY_LOGE("IsSetActiveSimInProgress invalid slotId: %{public}d", slotId);
1289         return false;
1290     }
1291     TELEPHONY_LOGD("isSetActiveSimInProgress_ %{public}d, is %{public}d", slotId, isSetActiveSimInProgress_[slotId]);
1292     return static_cast<bool>(isSetActiveSimInProgress_[slotId]);
1293 }
1294 
IsSetPrimarySlotIdInProgress()1295 bool MultiSimController::IsSetPrimarySlotIdInProgress()
1296 {
1297     TELEPHONY_LOGD("isSetPrimarySlotIdInProgress_ is %{public}d", isSetPrimarySlotIdInProgress_);
1298     return isSetPrimarySlotIdInProgress_;
1299 }
1300 
1301 } // namespace Telephony
1302 } // namespace OHOS
1303