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 {
25 const int WAIT_TIME = 10;
SimRdbHelper()26 SimRdbHelper::SimRdbHelper() {}
27
~SimRdbHelper()28 SimRdbHelper::~SimRdbHelper() {}
29
CreateDataHelper()30 std::shared_ptr<DataShare::DataShareHelper> SimRdbHelper::CreateDataHelper()
31 {
32 TELEPHONY_LOGD("start");
33 if (mTelephonyDatahelper == nullptr) {
34 TELEPHONY_LOGE("get CreateDataHelper Failed");
35 return nullptr;
36 }
37 return mTelephonyDatahelper->CreateSimHelper();
38 }
39
CreateDataHelper(const int waitTime)40 std::shared_ptr<DataShare::DataShareHelper> SimRdbHelper::CreateDataHelper(const int waitTime)
41 {
42 TELEPHONY_LOGD("start");
43 if (mTelephonyDatahelper == nullptr) {
44 TELEPHONY_LOGE("get CreateDataHelper Failed");
45 return nullptr;
46 }
47 return mTelephonyDatahelper->CreateSimHelper(waitTime);
48 }
49
CreateOpKeyHelper()50 std::shared_ptr<DataShare::DataShareHelper> SimRdbHelper::CreateOpKeyHelper()
51 {
52 TELEPHONY_LOGI("SimRdbHelper::CreateOpKeyHelper");
53 if (mTelephonyDatahelper == nullptr) {
54 TELEPHONY_LOGE("get CreateOpKeyHelper Failed");
55 return nullptr;
56 }
57 return mTelephonyDatahelper->CreateOpKeyHelper();
58 }
59
UpdateOpKeyInfo()60 int SimRdbHelper::UpdateOpKeyInfo()
61 {
62 TELEPHONY_LOGI("InitOpKeyData start");
63 std::shared_ptr<DataShare::DataShareHelper> helper = CreateOpKeyHelper();
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 = CreateDataHelper(WAIT_TIME);
362 if (dataShareHelper == nullptr) {
363 TELEPHONY_LOGE("need to retry CreateDataHelper");
364 dataShareHelper = CreateDataHelper();
365 }
366 if (dataShareHelper == nullptr) {
367 TELEPHONY_LOGE("SimRdbHelper::InsertData failed by nullptr");
368 return INVALID_VALUE;
369 }
370 int result = Insert(dataShareHelper, values);
371 dataShareHelper->Release();
372 return result;
373 }
374
SaveDataToBean(std::shared_ptr<DataShare::DataShareResultSet> result,SimRdbInfo & simBean)375 void SimRdbHelper::SaveDataToBean(std::shared_ptr<DataShare::DataShareResultSet> result, SimRdbInfo &simBean)
376 {
377 TELEPHONY_LOGD("start");
378 int index = 0;
379 result->GetColumnIndex(SimData::SIM_ID, index);
380 result->GetInt(index, simBean.simId);
381 result->GetColumnIndex(SimData::ICC_ID, index);
382 result->GetString(index, simBean.iccId);
383 result->GetColumnIndex(SimData::CARD_ID, index);
384 result->GetString(index, simBean.cardId);
385 result->GetColumnIndex(SimData::IMS_SWITCH, index);
386 result->GetInt(index, simBean.imsSwitch);
387 result->GetColumnIndex(SimData::SLOT_INDEX, index);
388 result->GetInt(index, simBean.slotIndex);
389 result->GetColumnIndex(SimData::CARD_TYPE, index);
390 result->GetInt(index, simBean.cardType);
391 result->GetColumnIndex(SimData::SHOW_NAME, index);
392 result->GetString(index, simBean.showName);
393 result->GetColumnIndex(SimData::PHONE_NUMBER, index);
394 result->GetString(index, simBean.phoneNumber);
395 result->GetColumnIndex(SimData::COUNTRY_CODE, index);
396 result->GetString(index, simBean.countryCode);
397 result->GetColumnIndex(SimData::LANGUAGE, index);
398 result->GetString(index, simBean.language);
399 result->GetColumnIndex(SimData::IMSI, index);
400 result->GetString(index, simBean.imsi);
401 result->GetColumnIndex(SimData::IS_MAIN_CARD, index);
402 result->GetInt(index, simBean.isMainCard);
403 result->GetColumnIndex(SimData::IS_VOICE_CARD, index);
404 result->GetInt(index, simBean.isVoiceCard);
405 result->GetColumnIndex(SimData::IS_MESSAGE_CARD, index);
406 result->GetInt(index, simBean.isMessageCard);
407 result->GetColumnIndex(SimData::IS_CELLULAR_DATA_CARD, index);
408 result->GetInt(index, simBean.isCellularDataCard);
409 result->GetColumnIndex(SimData::IS_ACTIVE, index);
410 result->GetInt(index, simBean.isActive);
411 }
412
QueryDataByIccId(std::string iccId,SimRdbInfo & simBean)413 int32_t SimRdbHelper::QueryDataByIccId(std::string iccId, SimRdbInfo &simBean)
414 {
415 TELEPHONY_LOGD("start");
416 std::vector<std::string> colume;
417 DataShare::DataSharePredicates predicates;
418 predicates.EqualTo(SimData::ICC_ID, iccId);
419 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper(WAIT_TIME);
420 if (dataShareHelper == nullptr) {
421 TELEPHONY_LOGE("failed by nullptr");
422 return INVALID_VALUE;
423 }
424 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
425 if (result == nullptr) {
426 TELEPHONY_LOGE("get nothing");
427 dataShareHelper->Release();
428 return TELEPHONY_SUCCESS;
429 }
430 int rowCount = 0;
431 result->GetRowCount(rowCount);
432 if (rowCount <= 0) {
433 TELEPHONY_LOGE("dont query the iccid record in db");
434 result->Close();
435 dataShareHelper->Release();
436 return TELEPHONY_SUCCESS;
437 }
438 int resultSetNum = result->GoToFirstRow();
439 while (resultSetNum == 0) {
440 SaveDataToBean(result, simBean);
441 resultSetNum = result->GoToNextRow();
442 }
443 result->Close();
444 dataShareHelper->Release();
445 return TELEPHONY_SUCCESS;
446 }
447
QueryAllData(std::vector<SimRdbInfo> & vec)448 int32_t SimRdbHelper::QueryAllData(std::vector<SimRdbInfo> &vec)
449 {
450 TELEPHONY_LOGD("start");
451 std::vector<std::string> colume;
452 DataShare::DataSharePredicates predicates;
453 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
454 if (dataShareHelper == nullptr) {
455 TELEPHONY_LOGE("failed by nullptr");
456 return INVALID_VALUE;
457 }
458 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
459 if (result == nullptr) {
460 TELEPHONY_LOGE("get nothing");
461 dataShareHelper->Release();
462 return INVALID_VALUE;
463 }
464 int resultSetNum = result->GoToFirstRow();
465 while (resultSetNum == 0) {
466 SimRdbInfo simBean;
467 SaveDataToBean(result, simBean);
468 vec.push_back(simBean);
469 resultSetNum = result->GoToNextRow();
470 }
471 result->Close();
472 dataShareHelper->Release();
473 return TELEPHONY_SUCCESS;
474 }
475
QueryAllValidData(std::vector<SimRdbInfo> & vec)476 int32_t SimRdbHelper::QueryAllValidData(std::vector<SimRdbInfo> &vec)
477 {
478 TELEPHONY_LOGD("start");
479 std::vector<std::string> colume;
480 std::string id = std::to_string(INVALID_VALUE);
481 DataShare::DataSharePredicates predicates;
482 predicates.GreaterThan(SimData::SLOT_INDEX, id);
483 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper(WAIT_TIME);
484 if (dataShareHelper == nullptr) {
485 TELEPHONY_LOGI("retry CreateDataHelper");
486 dataShareHelper = CreateDataHelper();
487 }
488 if (dataShareHelper == nullptr) {
489 TELEPHONY_LOGE("failed by nullptr");
490 return INVALID_VALUE;
491 }
492 std::shared_ptr<DataShare::DataShareResultSet> result = Query(dataShareHelper, colume, predicates);
493 if (result == nullptr) {
494 TELEPHONY_LOGE("get nothing");
495 dataShareHelper->Release();
496 return INVALID_VALUE;
497 }
498 int resultSetNum = result->GoToFirstRow();
499 while (resultSetNum == 0) {
500 SimRdbInfo simBean;
501 SaveDataToBean(result, simBean);
502 vec.push_back(simBean);
503 resultSetNum = result->GoToNextRow();
504 }
505 result->Close();
506 dataShareHelper->Release();
507 return TELEPHONY_SUCCESS;
508 }
509
UpdateDataBySimId(int32_t simId,const DataShare::DataShareValuesBucket & values)510 int32_t SimRdbHelper::UpdateDataBySimId(int32_t simId, const DataShare::DataShareValuesBucket &values)
511 {
512 TELEPHONY_LOGD("simId = %{public}d", simId);
513 std::string sim = std::to_string(simId);
514 DataShare::DataSharePredicates predicates;
515 predicates.EqualTo(SimData::SIM_ID, sim);
516 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
517 if (dataShareHelper == nullptr) {
518 TELEPHONY_LOGE("failed by nullptr");
519 return INVALID_VALUE;
520 }
521 int result = Update(dataShareHelper, values, predicates);
522 dataShareHelper->Release();
523 return result;
524 }
525
UpdateDataByIccId(std::string iccId,const DataShare::DataShareValuesBucket & values)526 int32_t SimRdbHelper::UpdateDataByIccId(std::string iccId, const DataShare::DataShareValuesBucket &values)
527 {
528 TELEPHONY_LOGI("start");
529 DataShare::DataSharePredicates predicates;
530 predicates.EqualTo(SimData::ICC_ID, iccId);
531 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper(WAIT_TIME);
532 if (dataShareHelper == nullptr) {
533 TELEPHONY_LOGE("failed by nullptr");
534 return INVALID_VALUE;
535 }
536 int result = Update(dataShareHelper, values, predicates);
537 dataShareHelper->Release();
538 return result;
539 }
540
ForgetAllData()541 int32_t SimRdbHelper::ForgetAllData()
542 {
543 TELEPHONY_LOGD("start");
544 DataShare::DataSharePredicates predicates;
545 DataShare::DataShareValuesBucket value;
546 DataShare::DataShareValueObject valueObj(INVALID_VALUE);
547 value.Put(SimData::SLOT_INDEX, valueObj);
548 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper(WAIT_TIME);
549 if (dataShareHelper == nullptr) {
550 TELEPHONY_LOGE("failed by nullptr");
551 return INVALID_VALUE;
552 }
553 int result = Update(dataShareHelper, value, predicates);
554 dataShareHelper->Release();
555 TELEPHONY_LOGD("result = %{public}d", result);
556 return result;
557 }
558
ForgetAllData(int32_t slotId)559 int32_t SimRdbHelper::ForgetAllData(int32_t slotId)
560 {
561 TELEPHONY_LOGD("slotId = %{public}d", slotId);
562 DataShare::DataSharePredicates predicates;
563 predicates.EqualTo(SimData::SLOT_INDEX, std::to_string(slotId));
564 DataShare::DataShareValuesBucket value;
565 if (TELEPHONY_EXT_WRAPPER.isVSimEnabled_ && TELEPHONY_EXT_WRAPPER.isVSimEnabled_() &&
566 slotId != static_cast<int32_t>(SimSlotType::VSIM_SLOT_ID)) {
567 TELEPHONY_LOGI("vsim enabled, not change slotId: %{public}d IS_ACTIVE state", slotId);
568 } else {
569 DataShare::DataShareValueObject valueObj(ACTIVE);
570 value.Put(SimData::IS_ACTIVE, valueObj);
571 }
572 DataShare::DataShareValueObject valueIndex(INVALID_VALUE);
573 value.Put(SimData::SLOT_INDEX, valueIndex);
574 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
575 if (dataShareHelper == nullptr) {
576 TELEPHONY_LOGE("failed by nullptr");
577 return INVALID_VALUE;
578 }
579 int result = Update(dataShareHelper, value, predicates);
580 dataShareHelper->Release();
581 TELEPHONY_LOGD("result = %{public}d", result);
582 return result;
583 }
584
ClearData()585 int32_t SimRdbHelper::ClearData()
586 {
587 std::string id = std::to_string(INVALID_VALUE);
588 DataShare::DataSharePredicates predicates;
589 predicates.GreaterThan(SimData::SIM_ID, id);
590 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataHelper();
591 if (dataShareHelper == nullptr) {
592 TELEPHONY_LOGE("failed by nullptr");
593 return INVALID_VALUE;
594 }
595 int result = Delete(dataShareHelper, predicates);
596 dataShareHelper->Release();
597 return result;
598 }
599
IsDataShareError()600 bool SimRdbHelper::IsDataShareError()
601 {
602 return mTelephonyDatahelper != nullptr && mTelephonyDatahelper->IsDataShareError();
603 }
604
ResetDataShareError()605 void SimRdbHelper::ResetDataShareError()
606 {
607 if (mTelephonyDatahelper != nullptr) {
608 mTelephonyDatahelper->ResetDataShareError();
609 }
610 }
611 } // namespace Telephony
612 } // namespace OHOS
613