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