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