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