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