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 "cellular_data_rdb_helper.h"
17 #include "cellular_data_hisysevent.h"
18 #include "cellular_data_constant.h"
19 #include "core_manager_inner.h"
20 #include "core_service_client.h"
21 #include "telephony_log_wrapper.h"
22
23 static constexpr const char *SIM_ID = "simId";
24 namespace OHOS {
25 namespace Telephony {
CellularDataRdbHelper()26 CellularDataRdbHelper::CellularDataRdbHelper() : cellularDataUri_(CELLULAR_DATA_RDB_SELECTION) {}
27
28 CellularDataRdbHelper::~CellularDataRdbHelper() = default;
29
CreateDataAbilityHelper()30 std::shared_ptr<DataShare::DataShareHelper> CellularDataRdbHelper::CreateDataAbilityHelper()
31 {
32 TELEPHONY_LOGI("Create data ability helper");
33 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
34 if (saManager == nullptr) {
35 TELEPHONY_LOGE("GetSystemAbilityManager failed.");
36 return nullptr;
37 }
38 sptr<IRemoteObject> remoteObj = saManager->GetSystemAbility(TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID);
39 if (remoteObj == nullptr) {
40 TELEPHONY_LOGE("GetSystemAbility Service Failed.");
41 return nullptr;
42 }
43 return DataShare::DataShareHelper::Creator(remoteObj, CELLULAR_DATA_RDB_URI);
44 }
45
Update(const DataShare::DataShareValuesBucket & value,const DataShare::DataSharePredicates & predicates)46 int CellularDataRdbHelper::Update(
47 const DataShare::DataShareValuesBucket &value, const DataShare::DataSharePredicates &predicates)
48 {
49 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
50 if (dataShareHelper == nullptr) {
51 TELEPHONY_LOGE("dataShareHelper is null");
52 return NULL_POINTER_EXCEPTION;
53 }
54 TELEPHONY_LOGI("Cellular data RDB helper update");
55 int32_t result = dataShareHelper->Update(cellularDataUri_, predicates, value);
56 dataShareHelper->Release();
57 return result;
58 }
59
Insert(const DataShare::DataShareValuesBucket & values)60 int CellularDataRdbHelper::Insert(const DataShare::DataShareValuesBucket &values)
61 {
62 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
63 if (dataShareHelper == nullptr) {
64 TELEPHONY_LOGE("dataShareHelper is null");
65 return NULL_POINTER_EXCEPTION;
66 }
67 TELEPHONY_LOGI("Cellular data RDB helper insert");
68 int32_t result = dataShareHelper->Insert(cellularDataUri_, values);
69 dataShareHelper->Release();
70 return result;
71 }
72
ResetApns(int32_t slotId)73 bool CellularDataRdbHelper::ResetApns(int32_t slotId)
74 {
75 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
76 if (dataShareHelper == nullptr) {
77 TELEPHONY_LOGE("dataShareHelper is null");
78 return false;
79 }
80 TELEPHONY_LOGI("Reset apns");
81 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId);
82 Uri resetApnUri(CELLULAR_DATA_RDB_RESET);
83 DataShare::DataSharePredicates predicates;
84 DataShare::DataShareValuesBucket values;
85 values.Put(SIM_ID, simId);
86 int32_t result = dataShareHelper->Update(resetApnUri, predicates, values);
87 dataShareHelper->Release();
88 return result >= 0;
89 }
90
QueryApns(const std::string & mcc,const std::string & mnc,std::vector<PdpProfile> & apnVec,int32_t slotId)91 bool CellularDataRdbHelper::QueryApns(
92 const std::string &mcc, const std::string &mnc, std::vector<PdpProfile> &apnVec, int32_t slotId)
93 {
94 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
95 if (dataShareHelper == nullptr) {
96 TELEPHONY_LOGE("dataShareHelper is null");
97 return false;
98 }
99 std::vector<std::string> columns;
100 DataShare::DataSharePredicates predicates;
101 predicates.EqualTo(PdpProfileData::MCCMNC, mcc + mnc);
102 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId);
103 Uri cellularDataUri(std::string(CELLULAR_DATA_RDB_SELECTION) + "?simId=" + std::to_string(simId));
104 std::shared_ptr<DataShare::DataShareResultSet> result =
105 dataShareHelper->Query(cellularDataUri, predicates, columns);
106 if (result == nullptr) {
107 TELEPHONY_LOGE("query apns error");
108 dataShareHelper->Release();
109 return false;
110 }
111 ReadApnResult(result, apnVec);
112 result->Close();
113 dataShareHelper->Release();
114 return true;
115 }
116
QueryMvnoApnsByType(const std::string & mcc,const std::string & mnc,const std::string & mvnoType,const std::string & mvnoDataFromSim,std::vector<PdpProfile> & mvnoApnVec,int32_t slotId)117 bool CellularDataRdbHelper::QueryMvnoApnsByType(const std::string &mcc, const std::string &mnc,
118 const std::string &mvnoType, const std::string &mvnoDataFromSim, std::vector<PdpProfile> &mvnoApnVec,
119 int32_t slotId)
120 {
121 if (mvnoDataFromSim.empty()) {
122 TELEPHONY_LOGE("mvnoDataFromSim is empty!");
123 return true;
124 }
125 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
126 if (dataShareHelper == nullptr) {
127 TELEPHONY_LOGE("dataShareHelper is null");
128 return false;
129 }
130 std::vector<std::string> columns;
131 DataShare::DataSharePredicates predicates;
132 predicates.EqualTo(PdpProfileData::MVNO_TYPE, mvnoType)
133 ->EqualTo(PdpProfileData::MCCMNC, mcc + mnc);
134 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId);
135 Uri cellularDataUri(std::string(CELLULAR_DATA_RDB_SELECTION) + "?simId=" + std::to_string(simId));
136 std::shared_ptr<DataShare::DataShareResultSet> result =
137 dataShareHelper->Query(cellularDataUri, predicates, columns);
138 if (result == nullptr) {
139 TELEPHONY_LOGE("Query apns error");
140 dataShareHelper->Release();
141 return false;
142 }
143 ReadMvnoApnResult(result, mvnoDataFromSim, mvnoApnVec);
144 result->Close();
145 dataShareHelper->Release();
146 return true;
147 }
148
QueryPreferApn(int32_t slotId,std::vector<PdpProfile> & apnVec)149 bool CellularDataRdbHelper::QueryPreferApn(int32_t slotId, std::vector<PdpProfile> &apnVec)
150 {
151 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
152 if (dataShareHelper == nullptr) {
153 TELEPHONY_LOGE("dataShareHelper is null");
154 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId, SWITCH_ON,
155 CellularDataErrorCode::DATA_ERROR_APN_CREATE_HELPER_FAIL, "Create dataHelper fail");
156 return false;
157 }
158 std::vector<std::string> columns;
159 DataShare::DataSharePredicates predicates;
160 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId);
161 Uri preferApnUri(std::string(CELLULAR_DATA_RDB_PREFER) + "?simId=" + std::to_string(simId));
162 std::shared_ptr<DataShare::DataShareResultSet> result = dataShareHelper->Query(preferApnUri, predicates, columns);
163 if (result == nullptr) {
164 TELEPHONY_LOGE("query prefer apns error");
165 dataShareHelper->Release();
166 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId, SWITCH_ON,
167 CellularDataErrorCode::DATA_ERROR_APN_QUERY_FAIL, "Query apn fail");
168 return false;
169 }
170 ReadApnResult(result, apnVec);
171 result->Close();
172 dataShareHelper->Release();
173 if (apnVec.size() <= 0) {
174 TELEPHONY_LOGI("simid no set prefer apn");
175 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId, SWITCH_ON,
176 CellularDataErrorCode::DATA_ERROR_APN_FOUND_EMPTY, "Apn list is empty");
177 }
178 return true;
179 }
180
ReadApnResult(const std::shared_ptr<DataShare::DataShareResultSet> & result,std::vector<PdpProfile> & apnVec)181 void CellularDataRdbHelper::ReadApnResult(
182 const std::shared_ptr<DataShare::DataShareResultSet> &result, std::vector<PdpProfile> &apnVec)
183 {
184 if (result == nullptr) {
185 TELEPHONY_LOGI("result is nullptr");
186 return;
187 }
188 int rowCnt = 0;
189 result->GetRowCount(rowCnt);
190 TELEPHONY_LOGI("query apns rowCnt = %{public}d", rowCnt);
191 for (int i = 0; i < rowCnt; ++i) {
192 PdpProfile apnBean;
193 MakePdpProfile(result, i, apnBean);
194 if (apnBean.mvnoType.empty()) {
195 apnVec.push_back(apnBean);
196 }
197 }
198 }
199
ReadMvnoApnResult(const std::shared_ptr<DataShare::DataShareResultSet> & result,const std::string & mvnoDataFromSim,std::vector<PdpProfile> & apnVec)200 void CellularDataRdbHelper::ReadMvnoApnResult(const std::shared_ptr<DataShare::DataShareResultSet> &result,
201 const std::string &mvnoDataFromSim, std::vector<PdpProfile> &apnVec)
202 {
203 if (result == nullptr) {
204 TELEPHONY_LOGI("result is nullptr");
205 return;
206 }
207 int rowCnt = 0;
208 result->GetRowCount(rowCnt);
209 TELEPHONY_LOGI("query mvno apns rowCnt = %{public}d", rowCnt);
210 for (int i = 0; i < rowCnt; ++i) {
211 PdpProfile apnBean;
212 MakePdpProfile(result, i, apnBean);
213 if (IsMvnoDataMatched(mvnoDataFromSim, apnBean)) {
214 apnVec.push_back(apnBean);
215 }
216 }
217 }
218
MakePdpProfile(const std::shared_ptr<DataShare::DataShareResultSet> & result,int i,PdpProfile & apnBean)219 void CellularDataRdbHelper::MakePdpProfile(
220 const std::shared_ptr<DataShare::DataShareResultSet> &result, int i, PdpProfile &apnBean)
221 {
222 int index = 0;
223 result->GoToRow(i);
224 result->GetColumnIndex(PdpProfileData::PROFILE_ID, index);
225 result->GetInt(index, apnBean.profileId);
226 result->GetColumnIndex(PdpProfileData::PROFILE_NAME, index);
227 result->GetString(index, apnBean.profileName);
228 result->GetColumnIndex(PdpProfileData::MCC, index);
229 result->GetString(index, apnBean.mcc);
230 result->GetColumnIndex(PdpProfileData::MNC, index);
231 result->GetString(index, apnBean.mnc);
232 result->GetColumnIndex(PdpProfileData::APN, index);
233 result->GetString(index, apnBean.apn);
234 result->GetColumnIndex(PdpProfileData::AUTH_USER, index);
235 result->GetString(index, apnBean.authUser);
236 int32_t authType;
237 result->GetColumnIndex(PdpProfileData::AUTH_TYPE, index);
238 result->GetInt(index, authType);
239 if (authType == -1) {
240 apnBean.authType = (apnBean.authUser.empty()) ? SETUP_DATA_AUTH_NONE : SETUP_DATA_AUTH_PAP_CHAP;
241 } else {
242 apnBean.authType = authType;
243 }
244 result->GetColumnIndex(PdpProfileData::AUTH_PWD, index);
245 result->GetString(index, apnBean.authPwd);
246 result->GetColumnIndex(PdpProfileData::APN_TYPES, index);
247 result->GetString(index, apnBean.apnTypes);
248 result->GetColumnIndex(PdpProfileData::APN_PROTOCOL, index);
249 result->GetString(index, apnBean.pdpProtocol);
250 result->GetColumnIndex(PdpProfileData::APN_ROAM_PROTOCOL, index);
251 result->GetString(index, apnBean.roamPdpProtocol);
252 result->GetColumnIndex(PdpProfileData::MVNO_TYPE, index);
253 result->GetString(index, apnBean.mvnoType);
254 result->GetColumnIndex(PdpProfileData::MVNO_MATCH_DATA, index);
255 result->GetString(index, apnBean.mvnoMatchData);
256 result->GetColumnIndex(PdpProfileData::EDITED_STATUS, index);
257 result->GetInt(index, apnBean.edited);
258 result->GetColumnIndex(PdpProfileData::PROXY_IP_ADDRESS, index);
259 result->GetString(index, apnBean.proxyIpAddress);
260 if (apnBean.pdpProtocol.empty()) {
261 apnBean.pdpProtocol = "IP";
262 }
263 if (apnBean.roamPdpProtocol.empty()) {
264 apnBean.roamPdpProtocol = "IP";
265 }
266 }
267
IsMvnoDataMatched(const std::string & mvnoDataFromSim,const PdpProfile & apnBean)268 bool CellularDataRdbHelper::IsMvnoDataMatched(const std::string &mvnoDataFromSim, const PdpProfile &apnBean)
269 {
270 if (mvnoDataFromSim.empty()) {
271 return false;
272 }
273 if (apnBean.mvnoType.compare(MvnoType::ICCID) == 0 ||
274 apnBean.mvnoType.compare(MvnoType::SPN) == 0 ||
275 apnBean.mvnoType.compare(MvnoType::IMSI) == 0) {
276 try {
277 return std::regex_match(mvnoDataFromSim, std::regex(apnBean.mvnoMatchData));
278 } catch (std::regex_error &e) {
279 TELEPHONY_LOGE("regex error");
280 return false;
281 }
282 }
283 if (apnBean.mvnoType.compare(MvnoType::GID1) == 0) {
284 return mvnoDataFromSim.compare(0, apnBean.mvnoMatchData.size(), apnBean.mvnoMatchData) == 0;
285 }
286 return false;
287 }
288
RegisterObserver(const sptr<AAFwk::IDataAbilityObserver> & dataObserver)289 void CellularDataRdbHelper::RegisterObserver(const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
290 {
291 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
292 if (dataShareHelper == nullptr) {
293 TELEPHONY_LOGE("dataShareHelper is null");
294 return;
295 }
296 Uri preferApnUri(CELLULAR_DATA_RDB_PREFER);
297 Uri resetApnUri(CELLULAR_DATA_RDB_RESET);
298 Uri initApnUri(CELLULAR_DATA_RDB_INIT);
299 dataShareHelper->RegisterObserver(resetApnUri, dataObserver);
300 dataShareHelper->RegisterObserver(preferApnUri, dataObserver);
301 dataShareHelper->RegisterObserver(initApnUri, dataObserver);
302 dataShareHelper->RegisterObserver(cellularDataUri_, dataObserver);
303 dataShareHelper->Release();
304 TELEPHONY_LOGI("RegisterObserver Success");
305 }
306
UnRegisterObserver(const sptr<AAFwk::IDataAbilityObserver> & dataObserver)307 void CellularDataRdbHelper::UnRegisterObserver(const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
308 {
309 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
310 if (dataShareHelper == nullptr) {
311 TELEPHONY_LOGE("dataShareHelper is null");
312 return;
313 }
314 Uri preferApnUri(CELLULAR_DATA_RDB_PREFER);
315 Uri resetApnUri(CELLULAR_DATA_RDB_RESET);
316 Uri initApnUri(CELLULAR_DATA_RDB_INIT);
317 dataShareHelper->UnregisterObserver(resetApnUri, dataObserver);
318 dataShareHelper->UnregisterObserver(preferApnUri, dataObserver);
319 dataShareHelper->UnregisterObserver(initApnUri, dataObserver);
320 dataShareHelper->UnregisterObserver(cellularDataUri_, dataObserver);
321 dataShareHelper->Release();
322 TELEPHONY_LOGI("UnRegisterObserver Success");
323 }
324
GetSimId()325 int32_t CellularDataRdbHelper::GetSimId()
326 {
327 int32_t slotId = CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
328 if ((slotId < DEFAULT_SIM_SLOT_ID) || (slotId > SIM_SLOT_COUNT)) {
329 TELEPHONY_LOGE("slotId invalid slotId = %{public}d", slotId);
330 return -1;
331 }
332 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId);
333 if (simId <= 0) {
334 TELEPHONY_LOGE("simId invalid simId = %{public}d", simId);
335 return -1;
336 }
337 TELEPHONY_LOGI("GetSimId simId = %{public}d", simId);
338 return simId;
339 }
340
GetOpKey(int slotId)341 std::string CellularDataRdbHelper::GetOpKey(int slotId)
342 {
343 std::string opkey;
344 std::u16string opkeyU16;
345 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpKey(slotId, opkeyU16);
346 opkey = Str16ToStr8(opkeyU16);
347 TELEPHONY_LOGI("GetOpKey##slotId = %{public}d, opkey = %{public}s", slotId, opkey.c_str());
348 return opkey;
349 }
350
QueryApnIds(const ApnInfo & apnInfo,std::vector<uint32_t> & apnIdList)351 void CellularDataRdbHelper::QueryApnIds(const ApnInfo &apnInfo, std::vector<uint32_t> &apnIdList)
352 {
353 if (GetSimId() == -1) {
354 return;
355 }
356 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
357 if (dataShareHelper == nullptr) {
358 return;
359 }
360 std::vector<std::string> columns;
361 DataShare::DataSharePredicates predicates;
362 predicates.EqualTo(Telephony::PdpProfileData::PROFILE_NAME, Str16ToStr8(apnInfo.apnName));
363 predicates.EqualTo(Telephony::PdpProfileData::APN, Str16ToStr8(apnInfo.apn));
364 predicates.EqualTo(Telephony::PdpProfileData::MCC, Str16ToStr8(apnInfo.mcc));
365 predicates.EqualTo(Telephony::PdpProfileData::MNC, Str16ToStr8(apnInfo.mnc));
366 if (strcmp(NOT_FILLED_IN, (Str16ToStr8(apnInfo.user)).c_str()) != 0) {
367 predicates.EqualTo(Telephony::PdpProfileData::AUTH_USER, Str16ToStr8(apnInfo.user));
368 }
369 if (strcmp(NOT_FILLED_IN, (Str16ToStr8(apnInfo.type)).c_str()) != 0) {
370 predicates.EqualTo(Telephony::PdpProfileData::APN_TYPES, Str16ToStr8(apnInfo.type));
371 }
372 if (strcmp(NOT_FILLED_IN, (Str16ToStr8(apnInfo.proxy)).c_str()) != 0) {
373 predicates.EqualTo(Telephony::PdpProfileData::PROXY_IP_ADDRESS, Str16ToStr8(apnInfo.proxy));
374 }
375 if (strcmp(NOT_FILLED_IN, (Str16ToStr8(apnInfo.mmsproxy)).c_str()) != 0) {
376 predicates.EqualTo(Telephony::PdpProfileData::MMS_IP_ADDRESS, Str16ToStr8(apnInfo.mmsproxy));
377 }
378 std::string opkey = GetOpKey(CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId());
379 predicates.EqualTo(Telephony::PdpProfileData::OPKEY, opkey);
380 Uri cellularDataUri(std::string(CELLULAR_DATA_RDB_SELECTION) + "?simId=" + std::to_string(GetSimId()));
381 std::shared_ptr<DataShare::DataShareResultSet> rst = dataShareHelper->Query(cellularDataUri, predicates, columns);
382 if (rst == nullptr) {
383 TELEPHONY_LOGE("QueryApnIds: query apns error");
384 dataShareHelper->Release();
385 return;
386 }
387 int rowCnt = 0;
388 rst->GetRowCount(rowCnt);
389 TELEPHONY_LOGI("QueryApnIds::query apns rowCnt = %{public}d, opkey= %{public}s", rowCnt, opkey.c_str());
390 for (int i = 0; i < rowCnt; ++i) {
391 int index = 0;
392 int profileId;
393 rst->GoToRow(i);
394 rst->GetColumnIndex(Telephony::PdpProfileData::PROFILE_ID, index);
395 rst->GetInt(index, profileId);
396 TELEPHONY_LOGI("profileId: %{public}d", profileId);
397 apnIdList.push_back(profileId);
398 }
399 rst->Close();
400 dataShareHelper->Release();
401 }
402
SetPreferApn(int32_t apnId)403 int32_t CellularDataRdbHelper::SetPreferApn(int32_t apnId)
404 {
405 if (GetSimId() == -1) {
406 return -1;
407 }
408 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
409 if (dataShareHelper == nullptr) {
410 TELEPHONY_LOGE("SetPreferApn dataShareHelper is null");
411 return -1;
412 }
413 TELEPHONY_LOGI("SetPreferApn apnId:%{public}d", apnId);
414 DataShare::DataSharePredicates predicates;
415 DataShare::DataShareValuesBucket values;
416 double profileIdAsDouble = static_cast<double>(apnId);
417 double simIdAsDouble = static_cast<double>(GetSimId());
418 values.Put(PdpProfileData::PROFILE_ID, profileIdAsDouble);
419 values.Put(PdpProfileData::SIM_ID, simIdAsDouble);
420 Uri preferApnUri(CELLULAR_DATA_RDB_PREFER);
421 int32_t result = dataShareHelper->Update(preferApnUri, predicates, values);
422 if (result < TELEPHONY_ERR_SUCCESS) {
423 TELEPHONY_LOGE("SetPreferApn fail! result:%{public}d", result);
424 dataShareHelper->Release();
425 return -1;
426 }
427 TELEPHONY_LOGI("SetPreferApn result:%{public}d", result);
428 dataShareHelper->Release();
429 return 0;
430 }
431
GetApnInfo(ApnInfo & apnInfo,int rowIndex,std::shared_ptr<DataShare::DataShareResultSet> result)432 void CellularDataRdbHelper::GetApnInfo(ApnInfo &apnInfo,
433 int rowIndex, std::shared_ptr<DataShare::DataShareResultSet> result)
434 {
435 int index = 0;
436 std::string apnName;
437 std::string apn;
438 std::string mcc;
439 std::string mnc;
440 std::string user;
441 std::string type;
442 std::string proxy;
443 std::string mmsproxy;
444 result->GoToRow(rowIndex);
445 result->GetColumnIndex(Telephony::PdpProfileData::PROFILE_NAME, index);
446 result->GetString(index, apnName);
447 result->GetColumnIndex(Telephony::PdpProfileData::APN, index);
448 result->GetString(index, apn);
449 result->GetColumnIndex(Telephony::PdpProfileData::MCC, index);
450 result->GetString(index, mcc);
451 result->GetColumnIndex(Telephony::PdpProfileData::MNC, index);
452 result->GetString(index, mnc);
453 result->GetColumnIndex(Telephony::PdpProfileData::AUTH_USER, index);
454 result->GetString(index, user);
455 result->GetColumnIndex(Telephony::PdpProfileData::APN_TYPES, index);
456 result->GetString(index, type);
457 result->GetColumnIndex(Telephony::PdpProfileData::PROXY_IP_ADDRESS, index);
458 result->GetString(index, proxy);
459 result->GetColumnIndex(Telephony::PdpProfileData::MMS_IP_ADDRESS, index);
460 result->GetString(index, mmsproxy);
461 apnInfo.apnName = Str8ToStr16(apnName);
462 apnInfo.apn = Str8ToStr16(apn);
463 apnInfo.mcc = Str8ToStr16(mcc);
464 apnInfo.mnc = Str8ToStr16(mnc);
465 apnInfo.user = Str8ToStr16(user);
466 apnInfo.type = Str8ToStr16(type);
467 apnInfo.proxy = Str8ToStr16(proxy);
468 apnInfo.mmsproxy = Str8ToStr16(mmsproxy);
469 }
470
QueryAllApnInfo(std::vector<ApnInfo> & apnInfoList)471 void CellularDataRdbHelper::QueryAllApnInfo(std::vector<ApnInfo> &apnInfoList)
472 {
473 TELEPHONY_LOGI("QueryAllApnInfo");
474 if (GetSimId() == -1) {
475 return;
476 }
477 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataAbilityHelper();
478 if (dataShareHelper == nullptr) {
479 TELEPHONY_LOGE("QueryAllApnInfo dataShareHelper is null");
480 return;
481 }
482 std::vector<std::string> columns;
483 DataShare::DataSharePredicates predicates;
484 std::string opkey = GetOpKey(CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId());
485 predicates.EqualTo(Telephony::PdpProfileData::OPKEY, opkey);
486 Uri cellularDataUri(std::string(CELLULAR_DATA_RDB_SELECTION) + "?simId=" + std::to_string(GetSimId()));
487 std::shared_ptr<DataShare::DataShareResultSet> result =
488 dataShareHelper->Query(cellularDataUri, predicates, columns);
489 if (result == nullptr) {
490 TELEPHONY_LOGE("QueryAllApnInfo error");
491 dataShareHelper->Release();
492 return;
493 }
494 int rowCnt = 0;
495 result->GetRowCount(rowCnt);
496 TELEPHONY_LOGI("QueryAllApnInfo rowCnt:%{public}d, simId:%{public}d,", rowCnt, GetSimId());
497 for (int i = 0; i < rowCnt; ++i) {
498 ApnInfo apnInfo;
499 GetApnInfo(apnInfo, i, result);
500 apnInfoList.push_back(apnInfo);
501 }
502 result->Close();
503 dataShareHelper->Release();
504 }
505 } // namespace Telephony
506 } // namespace OHOS
507