1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sim_rdb_helper.h"
17
18 #include "sim_data.h"
19 #include "telephony_errors.h"
20 #include "telephony_ext_wrapper.h"
21 #include "telephony_types.h"
22
23 namespace OHOS {
24 namespace Telephony {
SimRdbHelper()25 SimRdbHelper::SimRdbHelper() {}
26
~SimRdbHelper()27 SimRdbHelper::~SimRdbHelper() {}
28
CreateDataHelper()29 std::shared_ptr<DataShare::DataShareHelper> SimRdbHelper::CreateDataHelper()
30 {
31 TELEPHONY_LOGD("start");
32 if (mTelephonyDatahelper == nullptr) {
33 TELEPHONY_LOGE("get CreateDataHelper Failed");
34 return nullptr;
35 }
36 return mTelephonyDatahelper->CreateSimHelper();
37 }
38
CreateDataHelper(const int waitTime)39 std::shared_ptr<DataShare::DataShareHelper> SimRdbHelper::CreateDataHelper(const int waitTime)
40 {
41 TELEPHONY_LOGD("start");
42 if (mTelephonyDatahelper == nullptr) {
43 TELEPHONY_LOGE("get CreateDataHelper Failed");
44 return nullptr;
45 }
46 return mTelephonyDatahelper->CreateSimHelper(waitTime);
47 }
48
CreateOpKeyHelper(int waitTime)49 std::shared_ptr<DataShare::DataShareHelper> SimRdbHelper::CreateOpKeyHelper(int waitTime)
50 {
51 TELEPHONY_LOGI("SimRdbHelper::CreateOpKeyHelper");
52 if (mTelephonyDatahelper == nullptr) {
53 TELEPHONY_LOGE("get CreateOpKeyHelper Failed");
54 return nullptr;
55 }
56 return mTelephonyDatahelper->CreateOpKeyHelper(waitTime);
57 }
58
UpdateOpKeyInfo()59 int SimRdbHelper::UpdateOpKeyInfo()
60 {
61 TELEPHONY_LOGI("InitOpKeyData start");
62 std::shared_ptr<DataShare::DataShareHelper> helper =
63 CreateOpKeyHelper(TelephonyDataHelper::DB_CONNECT_MAX_WAIT_TIME);
64 if (helper == nullptr) {
65 TELEPHONY_LOGE("OpKey helper is nullptr");
66 return TELEPHONY_ERROR;
67 }
68 Uri uri(SimRdbInfo::OPKEY_INIT_URI);
69 std::vector<DataShare::DataShareValuesBucket> values;
70 int result = helper->BatchInsert(uri, values);
71 helper->Release();
72 helper = nullptr;
73 if (result <= 0) {
74 TELEPHONY_LOGI("InitOpKeyInfo opkey not change");
75 return result;
76 }
77 helper = CreateDataHelper();
78 if (helper == nullptr) {
79 TELEPHONY_LOGE("Sim helper is nullptr");
80 return TELEPHONY_ERROR;
81 }
82 TELEPHONY_LOGI("InitOpKeyInfo Opkey changed. clear opkey cache");
83 DataShare::DataShareValuesBucket valuesBucket;
84 DataShare::DataShareValueObject valueObj("");
85 valuesBucket.Put(SimData::OPKEY, valueObj);
86 DataShare::DataSharePredicates predicates;
87 result = Update(helper, valuesBucket, predicates);
88 helper->Release();
89 helper = nullptr;
90 TELEPHONY_LOGI("InitOpKeyInfo end");
91 return TELEPHONY_SUCCESS;
92 }
93
Insert(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const DataShare::DataShareValuesBucket & values)94 int SimRdbHelper::Insert(
95 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const DataShare::DataShareValuesBucket &values)
96 {
97 if (dataShareHelper == nullptr) {
98 TELEPHONY_LOGE("failed by nullptr");
99 return INVALID_VALUE;
100 }
101 Uri simUri(SimRdbInfo::SIM_RDB_SELECTION);
102 TELEPHONY_LOGD("SimRdbHelper::Insert");
103 return dataShareHelper->Insert(simUri, values);
104 }
105
Query(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,std::vector<std::string> & columns,const DataShare::DataSharePredicates & predicates)106 std::shared_ptr<DataShare::DataShareResultSet> SimRdbHelper::Query(
107 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, std::vector<std::string> &columns,
108 const DataShare::DataSharePredicates &predicates)
109 {
110 if (dataShareHelper == nullptr) {
111 TELEPHONY_LOGE("failed by nullptr");
112 return nullptr;
113 }
114 Uri simUri(SimRdbInfo::SIM_RDB_SELECTION);
115 return dataShareHelper->Query(simUri, predicates, columns);
116 }
117
Update(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const DataShare::DataShareValuesBucket & value,const DataShare::DataSharePredicates & predicates)118 int SimRdbHelper::Update(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
119 const DataShare::DataShareValuesBucket &value, const DataShare::DataSharePredicates &predicates)
120 {
121 if (dataShareHelper == nullptr) {
122 TELEPHONY_LOGE("failed by nullptr");
123 return INVALID_VALUE;
124 }
125 Uri simUri(SimRdbInfo::SIM_RDB_SELECTION);
126 TELEPHONY_LOGD("SimRdbHelper::Update");
127 return dataShareHelper->Update(simUri, predicates, value);
128 }
129
Delete(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const DataShare::DataSharePredicates & predicates)130 int SimRdbHelper::Delete(
131 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper, const DataShare::DataSharePredicates &predicates)
132 {
133 if (dataShareHelper == nullptr) {
134 TELEPHONY_LOGE("failed by nullptr");
135 return INVALID_VALUE;
136 }
137 Uri simUri(SimRdbInfo::SIM_RDB_SELECTION);
138 TELEPHONY_LOGD("SimRdbHelper::Delete");
139 return dataShareHelper->Delete(simUri, predicates);
140 }
141
GetDefaultMainCardSlotId()142 int32_t SimRdbHelper::GetDefaultMainCardSlotId()
143 {
144 TELEPHONY_LOGD("start");
145 int32_t mainCardSlotId = 0;
146 std::vector<std::string> colume;
147 DataShare::DataSharePredicates predicates;
148 predicates.EqualTo(SimData::IS_MAIN_CARD, std::to_string(static_cast<int32_t>(MAIN_CARD)));
149 predicates.EqualTo(SimData::IS_ACTIVE, std::to_string(static_cast<int32_t>(ACTIVE)));
150 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
151 if (dataShareHelper == nullptr) {
152 TELEPHONY_LOGE("SimRdbHelper::GetDefaultMainCardSlotId failed by nullptr");
153 return mainCardSlotId;
154 }
155 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
156 if (result == nullptr) {
157 TELEPHONY_LOGE("nothing");
158 dataShareHelper->Release();
159 return mainCardSlotId;
160 }
161 int resultSetNum = result->GoToFirstRow();
162 if (resultSetNum != 0) {
163 TELEPHONY_LOGD("not found main card");
164 result->Close();
165 dataShareHelper->Release();
166 return mainCardSlotId;
167 }
168 int index = 0;
169 result->GetColumnIndex(SimData::SLOT_INDEX, index);
170 result->GetInt(index, mainCardSlotId);
171 result->Close();
172 dataShareHelper->Release();
173 return mainCardSlotId;
174 }
175
GetDefaultMessageCardSlotId()176 int32_t SimRdbHelper::GetDefaultMessageCardSlotId()
177 {
178 TELEPHONY_LOGD("start");
179 int32_t messageCardSlotId = INVALID_VALUE;
180 std::vector<std::string> colume;
181 DataShare::DataSharePredicates predicates;
182 predicates.EqualTo(SimData::IS_MESSAGE_CARD, std::to_string(static_cast<int32_t>(MAIN_CARD)));
183 predicates.EqualTo(SimData::IS_ACTIVE, std::to_string(static_cast<int32_t>(ACTIVE)));
184 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
185 if (dataShareHelper == nullptr) {
186 TELEPHONY_LOGE("SimRdbHelper::GetDefaultMessageCardSlotId failed by nullptr");
187 return messageCardSlotId;
188 }
189 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
190 if (result == nullptr) {
191 TELEPHONY_LOGE("SimRdbHelper::get nothing");
192 dataShareHelper->Release();
193 return messageCardSlotId;
194 }
195 int resultSetNum = result->GoToFirstRow();
196 if (resultSetNum != 0) {
197 TELEPHONY_LOGD("not found default sms card");
198 result->Close();
199 dataShareHelper->Release();
200 return messageCardSlotId;
201 }
202 int index = 0;
203 result->GetColumnIndex(SimData::SLOT_INDEX, index);
204 result->GetInt(index, messageCardSlotId);
205 result->Close();
206 dataShareHelper->Release();
207 return messageCardSlotId;
208 }
209
GetDefaultCellularDataCardSlotId()210 int32_t SimRdbHelper::GetDefaultCellularDataCardSlotId()
211 {
212 TELEPHONY_LOGD("start");
213 int32_t cellularDataCardSlotId = INVALID_VALUE;
214 std::vector<std::string> colume;
215 DataShare::DataSharePredicates predicates;
216 predicates.EqualTo(SimData::IS_CELLULAR_DATA_CARD, std::to_string(static_cast<int32_t>(MAIN_CARD)));
217 predicates.EqualTo(SimData::IS_ACTIVE, std::to_string(static_cast<int32_t>(ACTIVE)));
218 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
219 if (dataShareHelper == nullptr) {
220 TELEPHONY_LOGE("SimRdbHelper::GetDefaultCellularDataCardSlotId failed by nullptr");
221 return cellularDataCardSlotId;
222 }
223 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
224 if (result == nullptr) {
225 TELEPHONY_LOGE("SimRdbHelper::get nothing");
226 dataShareHelper->Release();
227 return cellularDataCardSlotId;
228 }
229 int resultSetNum = result->GoToFirstRow();
230 if (resultSetNum != 0) {
231 TELEPHONY_LOGD("not found default data card");
232 result->Close();
233 dataShareHelper->Release();
234 return cellularDataCardSlotId;
235 }
236 int index = 0;
237 result->GetColumnIndex(SimData::SLOT_INDEX, index);
238 result->GetInt(index, cellularDataCardSlotId);
239 result->Close();
240 dataShareHelper->Release();
241 return cellularDataCardSlotId;
242 }
243
GetDefaultVoiceCardSlotId()244 int32_t SimRdbHelper::GetDefaultVoiceCardSlotId()
245 {
246 int32_t voiceCardSlotId = INVALID_VALUE;
247 std::vector<std::string> colume;
248 DataShare::DataSharePredicates predicates;
249 predicates.EqualTo(SimData::IS_VOICE_CARD, std::to_string(static_cast<int32_t>(MAIN_CARD)));
250 predicates.EqualTo(SimData::IS_ACTIVE, std::to_string(static_cast<int32_t>(ACTIVE)));
251 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
252 if (dataShareHelper == nullptr) {
253 TELEPHONY_LOGE("SimRdbHelper::GetDefaultVoiceCardSlotId failed by nullptr");
254 return voiceCardSlotId;
255 }
256 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
257 if (result == nullptr) {
258 TELEPHONY_LOGE("get nothing");
259 dataShareHelper->Release();
260 return voiceCardSlotId;
261 }
262 int resultSetNum = result->GoToFirstRow();
263 if (resultSetNum != 0) {
264 TELEPHONY_LOGD("not found default voice card");
265 result->Close();
266 dataShareHelper->Release();
267 return voiceCardSlotId;
268 }
269 int index = 0;
270 result->GetColumnIndex(SimData::SLOT_INDEX, index);
271 result->GetInt(index, voiceCardSlotId);
272 result->Close();
273 dataShareHelper->Release();
274 TELEPHONY_LOGD("voiceCardSlotId = %{public}d", voiceCardSlotId);
275 return voiceCardSlotId;
276 }
277
SetDefaultMainCard(int32_t simId)278 int32_t SimRdbHelper::SetDefaultMainCard(int32_t simId)
279 {
280 TELEPHONY_LOGI("simId = %{public}d", simId);
281 DataShare::DataSharePredicates predicates;
282 DataShare::DataShareValuesBucket value;
283 DataShare::DataShareValueObject slotObj(simId);
284 DataShare::DataShareValueObject valueObj(static_cast<int>(DefaultCardType::MAIN));
285 value.Put(SimData::SIM_ID, slotObj);
286 value.Put(SimData::CARD_TYPE, valueObj);
287 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
288 if (dataShareHelper == nullptr) {
289 TELEPHONY_LOGE("failed by nullptr");
290 return INVALID_VALUE;
291 }
292 Uri defaultUri(SimRdbInfo::SIM_RDB_DEFAULT_SET_URI);
293 int result = dataShareHelper->Update(defaultUri, predicates, value);
294 dataShareHelper->Release();
295 return result;
296 }
297
SetDefaultVoiceCard(int32_t simId)298 int32_t SimRdbHelper::SetDefaultVoiceCard(int32_t simId)
299 {
300 TELEPHONY_LOGI("simId = %{public}d", simId);
301 DataShare::DataSharePredicates predicates;
302 DataShare::DataShareValuesBucket value;
303 DataShare::DataShareValueObject slotObj(simId);
304 DataShare::DataShareValueObject valueObj(static_cast<int>(DefaultCardType::VOICE));
305 value.Put(SimData::SIM_ID, slotObj);
306 value.Put(SimData::CARD_TYPE, valueObj);
307 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
308 if (dataShareHelper == nullptr) {
309 TELEPHONY_LOGE("failed by nullptr");
310 return INVALID_VALUE;
311 }
312 Uri defaultUri(SimRdbInfo::SIM_RDB_DEFAULT_SET_URI);
313 int result = dataShareHelper->Update(defaultUri, predicates, value);
314 dataShareHelper->Release();
315 return result;
316 }
317
SetDefaultMessageCard(int32_t simId)318 int32_t SimRdbHelper::SetDefaultMessageCard(int32_t simId)
319 {
320 TELEPHONY_LOGI("simId = %{public}d", simId);
321 DataShare::DataSharePredicates predicates;
322 DataShare::DataShareValuesBucket value;
323 DataShare::DataShareValueObject slotObj(simId);
324 DataShare::DataShareValueObject valueObj(static_cast<int>(DefaultCardType::SMS));
325 value.Put(SimData::SIM_ID, slotObj);
326 value.Put(SimData::CARD_TYPE, valueObj);
327 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
328 if (dataShareHelper == nullptr) {
329 TELEPHONY_LOGE("failed by nullptr");
330 return INVALID_VALUE;
331 }
332 Uri defaultUri(SimRdbInfo::SIM_RDB_DEFAULT_SET_URI);
333 int result = dataShareHelper->Update(defaultUri, predicates, value);
334 dataShareHelper->Release();
335 return result;
336 }
337
SetDefaultCellularData(int32_t simId)338 int32_t SimRdbHelper::SetDefaultCellularData(int32_t simId)
339 {
340 TELEPHONY_LOGI("simId = %{public}d", simId);
341 DataShare::DataSharePredicates predicates;
342 DataShare::DataShareValuesBucket value;
343 DataShare::DataShareValueObject slotObj(simId);
344 DataShare::DataShareValueObject valueObj(static_cast<int>(DefaultCardType::DATA));
345 value.Put(SimData::SIM_ID, slotObj);
346 value.Put(SimData::CARD_TYPE, valueObj);
347 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
348 if (dataShareHelper == nullptr) {
349 TELEPHONY_LOGE("failed by nullptr");
350 return INVALID_VALUE;
351 }
352 Uri defaultUri(SimRdbInfo::SIM_RDB_DEFAULT_SET_URI);
353 int result = dataShareHelper->Update(defaultUri, predicates, value);
354 dataShareHelper->Release();
355 return result;
356 }
357
InsertData(int64_t & id,const DataShare::DataShareValuesBucket & values)358 int32_t SimRdbHelper::InsertData(int64_t &id, const DataShare::DataShareValuesBucket &values)
359 {
360 TELEPHONY_LOGD("start");
361 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
362 CreateDataHelper(TelephonyDataHelper::DB_CONNECT_MAX_WAIT_TIME);
363 if (dataShareHelper == nullptr) {
364 TELEPHONY_LOGE("need to retry CreateDataHelper");
365 dataShareHelper = CreateDataHelper();
366 }
367 if (dataShareHelper == nullptr) {
368 TELEPHONY_LOGE("SimRdbHelper::InsertData failed by nullptr");
369 return INVALID_VALUE;
370 }
371 int result = Insert(dataShareHelper, values);
372 dataShareHelper->Release();
373 return result;
374 }
375
SaveDataToBean(std::shared_ptr<DataShare::DataShareResultSet> result,SimRdbInfo & simBean)376 void SimRdbHelper::SaveDataToBean(std::shared_ptr<DataShare::DataShareResultSet> result, SimRdbInfo &simBean)
377 {
378 TELEPHONY_LOGD("start");
379 int index = 0;
380 result->GetColumnIndex(SimData::SIM_ID, index);
381 result->GetInt(index, simBean.simId);
382 result->GetColumnIndex(SimData::ICC_ID, index);
383 result->GetString(index, simBean.iccId);
384 result->GetColumnIndex(SimData::CARD_ID, index);
385 result->GetString(index, simBean.cardId);
386 result->GetColumnIndex(SimData::IMS_SWITCH, index);
387 result->GetInt(index, simBean.imsSwitch);
388 result->GetColumnIndex(SimData::SLOT_INDEX, index);
389 result->GetInt(index, simBean.slotIndex);
390 result->GetColumnIndex(SimData::CARD_TYPE, index);
391 result->GetInt(index, simBean.cardType);
392 result->GetColumnIndex(SimData::SHOW_NAME, index);
393 result->GetString(index, simBean.showName);
394 result->GetColumnIndex(SimData::PHONE_NUMBER, index);
395 result->GetString(index, simBean.phoneNumber);
396 result->GetColumnIndex(SimData::COUNTRY_CODE, index);
397 result->GetString(index, simBean.countryCode);
398 result->GetColumnIndex(SimData::LANGUAGE, index);
399 result->GetString(index, simBean.language);
400 result->GetColumnIndex(SimData::IMSI, index);
401 result->GetString(index, simBean.imsi);
402 result->GetColumnIndex(SimData::IS_MAIN_CARD, index);
403 result->GetInt(index, simBean.isMainCard);
404 result->GetColumnIndex(SimData::IS_VOICE_CARD, index);
405 result->GetInt(index, simBean.isVoiceCard);
406 result->GetColumnIndex(SimData::IS_MESSAGE_CARD, index);
407 result->GetInt(index, simBean.isMessageCard);
408 result->GetColumnIndex(SimData::IS_CELLULAR_DATA_CARD, index);
409 result->GetInt(index, simBean.isCellularDataCard);
410 result->GetColumnIndex(SimData::IS_ACTIVE, index);
411 result->GetInt(index, simBean.isActive);
412 result->GetColumnIndex(SimData::IS_ESIM, index);
413 result->GetInt(index, simBean.isEsim);
414 result->GetColumnIndex(SimData::SIM_LABEL_INDEX, index);
415 result->GetInt(index, simBean.simLabelIndex);
416 result->GetColumnIndex(SimData::OPERATOR_NAME, index);
417 result->GetString(index, simBean.operatorName);
418 }
419
QueryDataByIccId(std::string iccId,SimRdbInfo & simBean)420 int32_t SimRdbHelper::QueryDataByIccId(std::string iccId, SimRdbInfo &simBean)
421 {
422 TELEPHONY_LOGD("start");
423 std::vector<std::string> colume;
424 DataShare::DataSharePredicates predicates;
425 predicates.EqualTo(SimData::ICC_ID, iccId);
426 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
427 CreateDataHelper(TelephonyDataHelper::DB_CONNECT_MAX_WAIT_TIME);
428 if (dataShareHelper == nullptr) {
429 TELEPHONY_LOGE("failed by nullptr");
430 return INVALID_VALUE;
431 }
432 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
433 if (result == nullptr) {
434 TELEPHONY_LOGE("get nothing");
435 dataShareHelper->Release();
436 return TELEPHONY_SUCCESS;
437 }
438 int rowCount = 0;
439 result->GetRowCount(rowCount);
440 if (rowCount <= 0) {
441 TELEPHONY_LOGE("dont query the iccid record in db");
442 result->Close();
443 dataShareHelper->Release();
444 return TELEPHONY_SUCCESS;
445 }
446 int resultSetNum = result->GoToFirstRow();
447 while (resultSetNum == 0) {
448 SaveDataToBean(result, simBean);
449 resultSetNum = result->GoToNextRow();
450 }
451 result->Close();
452 dataShareHelper->Release();
453 return TELEPHONY_SUCCESS;
454 }
455
QueryAllData(std::vector<SimRdbInfo> & vec)456 int32_t SimRdbHelper::QueryAllData(std::vector<SimRdbInfo> &vec)
457 {
458 TELEPHONY_LOGD("start");
459 std::vector<std::string> colume;
460 DataShare::DataSharePredicates predicates;
461 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
462 if (dataShareHelper == nullptr) {
463 TELEPHONY_LOGE("failed by nullptr");
464 return INVALID_VALUE;
465 }
466 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
467 if (result == nullptr) {
468 TELEPHONY_LOGE("get nothing");
469 dataShareHelper->Release();
470 return INVALID_VALUE;
471 }
472 int resultSetNum = result->GoToFirstRow();
473 while (resultSetNum == 0) {
474 SimRdbInfo simBean;
475 SaveDataToBean(result, simBean);
476 vec.push_back(simBean);
477 resultSetNum = result->GoToNextRow();
478 }
479 result->Close();
480 dataShareHelper->Release();
481 return TELEPHONY_SUCCESS;
482 }
483
QueryAllValidData(std::vector<SimRdbInfo> & vec)484 int32_t SimRdbHelper::QueryAllValidData(std::vector<SimRdbInfo> &vec)
485 {
486 TELEPHONY_LOGD("start");
487 std::vector<std::string> colume;
488 std::string id = std::to_string(INVALID_VALUE);
489 DataShare::DataSharePredicates predicates;
490 predicates.GreaterThan(SimData::SLOT_INDEX, id);
491 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
492 CreateDataHelper(TelephonyDataHelper::DB_CONNECT_MAX_WAIT_TIME);
493 if (dataShareHelper == nullptr) {
494 TELEPHONY_LOGI("retry CreateDataHelper");
495 dataShareHelper = CreateDataHelper();
496 }
497 if (dataShareHelper == nullptr) {
498 TELEPHONY_LOGE("failed by nullptr");
499 return INVALID_VALUE;
500 }
501 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
502 if (result == nullptr) {
503 TELEPHONY_LOGE("get nothing");
504 dataShareHelper->Release();
505 return INVALID_VALUE;
506 }
507 int resultSetNum = result->GoToFirstRow();
508 while (resultSetNum == 0) {
509 SimRdbInfo simBean;
510 SaveDataToBean(result, simBean);
511 vec.push_back(simBean);
512 resultSetNum = result->GoToNextRow();
513 }
514 result->Close();
515 dataShareHelper->Release();
516 return TELEPHONY_SUCCESS;
517 }
518
UpdateDataBySimId(int32_t simId,const DataShare::DataShareValuesBucket & values)519 int32_t SimRdbHelper::UpdateDataBySimId(int32_t simId, const DataShare::DataShareValuesBucket &values)
520 {
521 TELEPHONY_LOGD("simId = %{public}d", simId);
522 std::string sim = std::to_string(simId);
523 DataShare::DataSharePredicates predicates;
524 predicates.EqualTo(SimData::SIM_ID, sim);
525 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
526 if (dataShareHelper == nullptr) {
527 TELEPHONY_LOGE("failed by nullptr");
528 return INVALID_VALUE;
529 }
530 int result = Update(dataShareHelper, values, predicates);
531 dataShareHelper->Release();
532 return result;
533 }
534
UpdateDataByIccId(std::string iccId,const DataShare::DataShareValuesBucket & values)535 int32_t SimRdbHelper::UpdateDataByIccId(std::string iccId, const DataShare::DataShareValuesBucket &values)
536 {
537 TELEPHONY_LOGI("start");
538 DataShare::DataSharePredicates predicates;
539 predicates.EqualTo(SimData::ICC_ID, iccId);
540 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
541 CreateDataHelper(TelephonyDataHelper::DB_CONNECT_MAX_WAIT_TIME);
542 if (dataShareHelper == nullptr) {
543 TELEPHONY_LOGE("failed by nullptr");
544 return INVALID_VALUE;
545 }
546 int result = Update(dataShareHelper, values, predicates);
547 dataShareHelper->Release();
548 return result;
549 }
550
ForgetAllData()551 int32_t SimRdbHelper::ForgetAllData()
552 {
553 TELEPHONY_LOGD("start");
554 DataShare::DataSharePredicates predicates1;
555 DataShare::DataShareValuesBucket value;
556 DataShare::DataShareValueObject valueObj(INVALID_VALUE);
557 value.Put(SimData::SLOT_INDEX, valueObj);
558 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
559 CreateDataHelper(TelephonyDataHelper::DB_CONNECT_MAX_WAIT_TIME);
560 if (dataShareHelper == nullptr) {
561 TELEPHONY_LOGE("failed by nullptr");
562 return INVALID_VALUE;
563 }
564 int result = Update(dataShareHelper, value, predicates1);
565 if (result != TELEPHONY_ERR_SUCCESS) {
566 TELEPHONY_LOGE("ForgetAllData update slotId fail");
567 }
568 DataShare::DataSharePredicates predicates2;
569 predicates2.EqualTo(SimData::IS_ESIM, std::to_string(0));
570 DataShare::DataShareValuesBucket simLabelValue;
571 simLabelValue.Put(SimData::SIM_LABEL_INDEX, valueObj);
572 result = Update(dataShareHelper, simLabelValue, predicates2);
573 dataShareHelper->Release();
574 TELEPHONY_LOGD("result = %{public}d", result);
575 return result;
576 }
577
ForgetAllData(int32_t slotId,bool isUpdateSimLabel)578 int32_t SimRdbHelper::ForgetAllData(int32_t slotId, bool isUpdateSimLabel)
579 {
580 TELEPHONY_LOGD("slotId = %{public}d", slotId);
581 DataShare::DataSharePredicates predicates;
582 predicates.EqualTo(SimData::SLOT_INDEX, std::to_string(slotId));
583 DataShare::DataShareValuesBucket value;
584 if (TELEPHONY_EXT_WRAPPER.isVSimEnabled_ && TELEPHONY_EXT_WRAPPER.isVSimEnabled_() &&
585 slotId != static_cast<int32_t>(SimSlotType::VSIM_SLOT_ID)) {
586 TELEPHONY_LOGI("vsim enabled, not change slotId: %{public}d IS_ACTIVE state", slotId);
587 } else {
588 DataShare::DataShareValueObject valueObj(ACTIVE);
589 value.Put(SimData::IS_ACTIVE, valueObj);
590 }
591 DataShare::DataShareValueObject valueIndex(INVALID_VALUE);
592 value.Put(SimData::SLOT_INDEX, valueIndex);
593 if (isUpdateSimLabel) {
594 value.Put(SimData::SIM_LABEL_INDEX, valueIndex);
595 }
596 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
597 if (dataShareHelper == nullptr) {
598 TELEPHONY_LOGE("failed by nullptr");
599 return INVALID_VALUE;
600 }
601 int result = Update(dataShareHelper, value, predicates);
602 dataShareHelper->Release();
603 TELEPHONY_LOGD("result = %{public}d", result);
604 return result;
605 }
606
ClearData()607 int32_t SimRdbHelper::ClearData()
608 {
609 std::string id = std::to_string(INVALID_VALUE);
610 DataShare::DataSharePredicates predicates;
611 predicates.GreaterThan(SimData::SIM_ID, id);
612 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
613 if (dataShareHelper == nullptr) {
614 TELEPHONY_LOGE("failed by nullptr");
615 return INVALID_VALUE;
616 }
617 int result = Delete(dataShareHelper, predicates);
618 dataShareHelper->Release();
619 return result;
620 }
621
IsDataShareError()622 bool SimRdbHelper::IsDataShareError()
623 {
624 return mTelephonyDatahelper != nullptr && mTelephonyDatahelper->IsDataShareError();
625 }
626
ResetDataShareError()627 void SimRdbHelper::ResetDataShareError()
628 {
629 if (mTelephonyDatahelper != nullptr) {
630 mTelephonyDatahelper->ResetDataShareError();
631 }
632 }
633 } // namespace Telephony
634 } // namespace OHOS
635