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 "apn_manager.h"
17 
18 #include "cellular_data_utils.h"
19 #include "core_manager_inner.h"
20 #include "net_specifier.h"
21 #include "string_ex.h"
22 #include "tel_profile_util.h"
23 #include "telephony_log_wrapper.h"
24 #include "telephony_ext_wrapper.h"
25 
26 namespace OHOS {
27 namespace Telephony {
28 const std::map<std::string, int32_t> ApnManager::apnIdApnNameMap_ {
29     {DATA_CONTEXT_ROLE_ALL, DATA_CONTEXT_ROLE_ALL_ID},
30     {DATA_CONTEXT_ROLE_DEFAULT, DATA_CONTEXT_ROLE_DEFAULT_ID},
31     {DATA_CONTEXT_ROLE_MMS, DATA_CONTEXT_ROLE_MMS_ID},
32     {DATA_CONTEXT_ROLE_SUPL, DATA_CONTEXT_ROLE_SUPL_ID},
33     {DATA_CONTEXT_ROLE_DUN, DATA_CONTEXT_ROLE_DUN_ID},
34     {DATA_CONTEXT_ROLE_IMS, DATA_CONTEXT_ROLE_IMS_ID},
35     {DATA_CONTEXT_ROLE_IA, DATA_CONTEXT_ROLE_IA_ID},
36     {DATA_CONTEXT_ROLE_EMERGENCY, DATA_CONTEXT_ROLE_EMERGENCY_ID},
37     {DATA_CONTEXT_ROLE_INTERNAL_DEFAULT, DATA_CONTEXT_ROLE_INTERNAL_DEFAULT_ID},
38     {DATA_CONTEXT_ROLE_XCAP, DATA_CONTEXT_ROLE_XCAP_ID}
39 };
40 const std::vector<ApnProfileState> ApnManager::apnStateArr_ = {
41     PROFILE_STATE_CONNECTED,
42     PROFILE_STATE_DISCONNECTING,
43     PROFILE_STATE_CONNECTING,
44     PROFILE_STATE_IDLE,
45     PROFILE_STATE_RETRYING,
46     PROFILE_STATE_FAILED
47 };
48 constexpr const char *CT_MCC_MNC_1 = "46003";
49 constexpr const char *CT_MCC_MNC_2 = "46011";
50 constexpr const char *GC_ICCID = "8985231";
51 constexpr const char *GC_MCC_MNC = "45431";
52 constexpr const char *GC_SPN = "CTExcel";
53 constexpr const char *MO_ICCID_1 = "8985302";
54 constexpr const char *MO_ICCID_2 = "8985307";
55 constexpr const char *MO_UNICOM_MCCMNC = "46001";
56 constexpr int32_t ICCID_LEN_MINIMUM = 7;
57 
58 ApnManager::ApnManager() = default;
59 
60 ApnManager::~ApnManager() = default;
61 
InitApnHolders()62 void ApnManager::InitApnHolders()
63 {
64     AddApnHolder(DATA_CONTEXT_ROLE_DEFAULT, static_cast<int32_t>(DataContextPriority::PRIORITY_LOW));
65     AddApnHolder(DATA_CONTEXT_ROLE_MMS, static_cast<int32_t>(DataContextPriority::PRIORITY_NORMAL));
66     AddApnHolder(DATA_CONTEXT_ROLE_INTERNAL_DEFAULT, static_cast<int32_t>(DataContextPriority::PRIORITY_NONE));
67     AddApnHolder(DATA_CONTEXT_ROLE_XCAP, static_cast<int32_t>(DataContextPriority::PRIORITY_NORMAL));
68     AddApnHolder(DATA_CONTEXT_ROLE_DUN, static_cast<int32_t>(DataContextPriority::PRIORITY_NORMAL));
69     AddApnHolder(DATA_CONTEXT_ROLE_IA, static_cast<int32_t>(DataContextPriority::PRIORITY_HIGH));
70     AddApnHolder(DATA_CONTEXT_ROLE_SUPL, static_cast<int32_t>(DataContextPriority::PRIORITY_NORMAL));
71 }
72 
FindApnHolderById(const int32_t id) const73 sptr<ApnHolder> ApnManager::FindApnHolderById(const int32_t id) const
74 {
75     if (apnIdApnHolderMap_.empty()) {
76         TELEPHONY_LOGE("apnIdApnHolderMap_ empty");
77         return nullptr;
78     }
79     if (id == DATA_CONTEXT_ROLE_INVALID_ID) {
80         TELEPHONY_LOGE("find a invalid capability!");
81         return nullptr;
82     }
83     std::map<int32_t, sptr<ApnHolder>>::const_iterator it = apnIdApnHolderMap_.find(id);
84     if (it != apnIdApnHolderMap_.end()) {
85         return it->second;
86     }
87     return nullptr;
88 }
89 
FindApnIdByApnName(const std::string & type)90 int32_t ApnManager::FindApnIdByApnName(const std::string &type)
91 {
92     std::map<std::string, int32_t>::const_iterator it = apnIdApnNameMap_.find(type);
93     if (it != apnIdApnNameMap_.end()) {
94         return it->second;
95     }
96     TELEPHONY_LOGE("apnType %{public}s is not exist!", type.c_str());
97     return DATA_CONTEXT_ROLE_INVALID_ID;
98 }
99 
FindApnNameByApnId(const int32_t id)100 std::string ApnManager::FindApnNameByApnId(const int32_t id)
101 {
102     for (std::pair<const std::string, int32_t> it : apnIdApnNameMap_) {
103         if (it.second == id) {
104             return it.first;
105         }
106     }
107     TELEPHONY_LOGI("apnId %{public}d is not exist!", id);
108     return DATA_CONTEXT_ROLE_DEFAULT;
109 }
110 
FindApnIdByCapability(const uint64_t capability)111 int32_t ApnManager::FindApnIdByCapability(const uint64_t capability)
112 {
113     switch (capability) {
114         case NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET:
115             return DATA_CONTEXT_ROLE_DEFAULT_ID;
116         case NetManagerStandard::NetCap::NET_CAPABILITY_MMS:
117             return DATA_CONTEXT_ROLE_MMS_ID;
118         case NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT:
119             return DATA_CONTEXT_ROLE_INTERNAL_DEFAULT_ID;
120         case NetManagerStandard::NetCap::NET_CAPABILITY_IA:
121             return DATA_CONTEXT_ROLE_IA_ID;
122         case NetManagerStandard::NetCap::NET_CAPABILITY_XCAP:
123             return DATA_CONTEXT_ROLE_XCAP_ID;
124         case NetManagerStandard::NetCap::NET_CAPABILITY_SUPL:
125             return DATA_CONTEXT_ROLE_SUPL_ID;
126         case NetManagerStandard::NetCap::NET_CAPABILITY_DUN:
127             return DATA_CONTEXT_ROLE_DUN_ID;
128         default:
129             return DATA_CONTEXT_ROLE_INVALID_ID;
130     }
131 }
132 
HasNetCap(const uint64_t capabilities,const NetManagerStandard::NetCap netCap)133 static bool HasNetCap(const uint64_t capabilities, const NetManagerStandard::NetCap netCap)
134 {
135     return (capabilities & (1L << netCap)) != 0;
136 }
137 
FindBestCapability(const uint64_t capabilities)138 NetManagerStandard::NetCap ApnManager::FindBestCapability(const uint64_t capabilities)
139 {
140     NetManagerStandard::NetCap netCap = NetManagerStandard::NetCap::NET_CAPABILITY_END;
141     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET)) {
142         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET;
143     }
144     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT)) {
145         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_INTERNAL_DEFAULT;
146     }
147     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_MMS)) {
148         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_MMS;
149     }
150     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_SUPL)) {
151         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_SUPL;
152     }
153     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_DUN)) {
154         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_DUN;
155     }
156     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_XCAP)) {
157         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_XCAP;
158     }
159     if (HasNetCap(capabilities, NetManagerStandard::NetCap::NET_CAPABILITY_IA)) {
160         netCap = NetManagerStandard::NetCap::NET_CAPABILITY_IA;
161     }
162     return netCap;
163 }
164 
AddApnHolder(const std::string & apnType,const int32_t priority)165 void ApnManager::AddApnHolder(const std::string &apnType, const int32_t priority)
166 {
167     int32_t apnId = FindApnIdByApnName(apnType);
168     if (apnId == DATA_CONTEXT_ROLE_INVALID_ID) {
169         TELEPHONY_LOGE("APN INVALID ID");
170         return;
171     }
172     sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>(apnType, priority).release();
173     if (apnHolder == nullptr) {
174         TELEPHONY_LOGE("apnHolder is null, type: %{public}s", apnType.c_str());
175         return;
176     }
177     apnHolder->SetApnState(PROFILE_STATE_IDLE);
178     apnHolders_.push_back(apnHolder);
179     apnIdApnHolderMap_.insert(std::pair<int32_t, sptr<ApnHolder>>(apnId, apnHolder));
180     sortedApnHolders_.emplace_back(apnHolder);
181     sort(sortedApnHolders_.begin(), sortedApnHolders_.end(),
182         [](const sptr<ApnHolder> &c1, const sptr<ApnHolder> &c2) {
183             if (c1 == nullptr || c2 == nullptr) {
184                 return false;
185             }
186             return c2->GetPriority() < c1->GetPriority();
187         });
188     TELEPHONY_LOGI("The Apn holder type:%{public}s, size:%{public}zu", apnType.c_str(), sortedApnHolders_.size());
189 }
190 
GetApnHolder(const std::string & apnType) const191 sptr<ApnHolder> ApnManager::GetApnHolder(const std::string &apnType) const
192 {
193     int32_t apnId = FindApnIdByApnName(apnType);
194     if (DATA_CONTEXT_ROLE_INVALID_ID == apnId) {
195         TELEPHONY_LOGE("APN INVALID ID");
196         return nullptr;
197     }
198     std::map<int32_t, sptr<ApnHolder>>::const_iterator it = apnIdApnHolderMap_.find(apnId);
199     if (it != apnIdApnHolderMap_.end()) {
200         return it->second;
201     }
202     TELEPHONY_LOGE("apnType %{public}s is not exist!", apnType.c_str());
203     return nullptr;
204 }
205 
GetAllApnHolder() const206 std::vector<sptr<ApnHolder>> ApnManager::GetAllApnHolder() const
207 {
208     return apnHolders_;
209 }
210 
GetSortApnHolder() const211 std::vector<sptr<ApnHolder>> ApnManager::GetSortApnHolder() const
212 {
213     return sortedApnHolders_;
214 }
215 
CreateAllApnItem()216 void ApnManager::CreateAllApnItem()
217 {
218     std::lock_guard<std::mutex> lock(mutex_);
219     allApnItem_.clear();
220     sptr<ApnItem> defaultApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT);
221     if (defaultApnItem != nullptr) {
222         allApnItem_.push_back(defaultApnItem);
223     }
224     sptr<ApnItem> mmsApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_MMS);
225     if (mmsApnItem != nullptr) {
226         allApnItem_.push_back(mmsApnItem);
227     }
228     sptr<ApnItem> suplApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_SUPL);
229     if (suplApnItem != nullptr) {
230         allApnItem_.push_back(suplApnItem);
231     }
232     sptr<ApnItem> dunApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DUN);
233     if (dunApnItem != nullptr) {
234         allApnItem_.push_back(dunApnItem);
235     }
236     sptr<ApnItem> imsApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_IMS);
237     if (imsApnItem != nullptr) {
238         allApnItem_.push_back(imsApnItem);
239     }
240     sptr<ApnItem> iaApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_IA);
241     if (iaApnItem != nullptr) {
242         allApnItem_.push_back(iaApnItem);
243     }
244     sptr<ApnItem> emergencyApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_EMERGENCY);
245     if (emergencyApnItem != nullptr) {
246         allApnItem_.push_back(emergencyApnItem);
247     }
248     auto internalDefaultApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_INTERNAL_DEFAULT);
249     if (internalDefaultApnItem != nullptr) {
250         allApnItem_.push_back(internalDefaultApnItem);
251     }
252     auto xcapApnItem = ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_XCAP);
253     if (xcapApnItem != nullptr) {
254         allApnItem_.push_back(xcapApnItem);
255     }
256 }
257 
CreateAllApnItemByDatabase(int32_t slotId)258 int32_t ApnManager::CreateAllApnItemByDatabase(int32_t slotId)
259 {
260     int32_t count = 0;
261     if (TELEPHONY_EXT_WRAPPER.createAllApnItemExt_) {
262         sptr<ApnItem> extraApnItem = ApnItem::MakeDefaultApn("default");
263         if (TELEPHONY_EXT_WRAPPER.createAllApnItemExt_(slotId, extraApnItem)) {
264             std::lock_guard<std::mutex> lock(mutex_);
265             allApnItem_.clear();
266             allApnItem_.push_back(extraApnItem);
267             return ++count;
268         }
269     }
270     std::u16string operatorNumeric;
271     CoreManagerInner::GetInstance().GetSimOperatorNumeric(slotId, operatorNumeric);
272     std::string numeric = Str16ToStr8(operatorNumeric);
273     GetCTOperator(slotId, numeric);
274     if (numeric.empty()) {
275         TELEPHONY_LOGE("numeric is empty!!!");
276         return count;
277     }
278     TELEPHONY_LOGI("current slotId = %{public}d, numeric = %{public}s", slotId, numeric.c_str());
279     auto helper = CellularDataRdbHelper::GetInstance();
280     if (helper == nullptr) {
281         TELEPHONY_LOGE("get cellularDataRdbHelper failed");
282         return count;
283     }
284     preferId_ = INVALID_PROFILE_ID;
285     std::vector<PdpProfile> preferApnVec;
286     if (helper->QueryPreferApn(slotId, preferApnVec)) {
287         preferId_ = preferApnVec[0].profileId;
288         TELEPHONY_LOGI("query preferId_ = %{public}d", preferId_);
289     }
290     std::string mcc = numeric.substr(0, DEFAULT_MCC_SIZE);
291     std::string mnc = numeric.substr(mcc.size(), numeric.size() - mcc.size());
292     int32_t mvnoCount = CreateMvnoApnItems(slotId, mcc, mnc);
293     if (mvnoCount > 0) {
294         return mvnoCount;
295     }
296     std::vector<PdpProfile> apnVec;
297     if (!helper->QueryApns(mcc, mnc, apnVec, slotId)) {
298         TELEPHONY_LOGE("query apns from data ability fail");
299         return count;
300     }
301     return MakeSpecificApnItem(apnVec);
302 }
303 
GetCTOperator(int32_t slotId,std::string & numeric)304 void ApnManager::GetCTOperator(int32_t slotId, std::string &numeric)
305 {
306     bool isCTSimCard = false;
307     CoreManagerInner::GetInstance().IsCTSimCard(slotId, isCTSimCard);
308     if (isCTSimCard && numeric.compare(CT_MCC_MNC_2)) {
309         numeric = CT_MCC_MNC_1;
310     }
311     if (!numeric.compare(CT_MCC_MNC_1)) {
312         std::u16string tempIccId;
313         CoreManagerInner::GetInstance().GetSimIccId(slotId, tempIccId);
314         std::string iccId = Str16ToStr8(tempIccId);
315         std::u16string tempSpn;
316         CoreManagerInner::GetInstance().GetSimSpn(slotId, tempSpn);
317         std::string spn = Str16ToStr8(tempSpn);
318         if (!iccId.compare(0, ICCID_LEN_MINIMUM, GC_ICCID) || !spn.compare(GC_SPN)) {
319             numeric = GC_MCC_MNC;
320         } else if (!iccId.compare(0, ICCID_LEN_MINIMUM, MO_ICCID_1) ||
321             !iccId.compare(0, ICCID_LEN_MINIMUM, MO_ICCID_2)) {
322             std::u16string tempPlmn;
323             CoreManagerInner::GetInstance().GetSimOperatorNumeric(slotId, tempPlmn);
324             std::string plmn = Str16ToStr8(tempPlmn);
325             if (!plmn.empty() && !plmn.compare(MO_UNICOM_MCCMNC)) {
326                 numeric = MO_UNICOM_MCCMNC;
327             }
328         }
329     }
330 }
331 
CreateMvnoApnItems(int32_t slotId,const std::string & mcc,const std::string & mnc)332 int32_t ApnManager::CreateMvnoApnItems(int32_t slotId, const std::string &mcc, const std::string &mnc)
333 {
334     int32_t count = 0;
335     auto helper = CellularDataRdbHelper::GetInstance();
336     if (helper == nullptr) {
337         TELEPHONY_LOGE("get cellularDataRdbHelper failed");
338         return count;
339     }
340     std::vector<PdpProfile> mvnoApnVec;
341     std::u16string spn;
342     CoreManagerInner::GetInstance().GetSimSpn(slotId, spn);
343     if (!helper->QueryMvnoApnsByType(mcc, mnc, MvnoType::SPN, Str16ToStr8(spn), mvnoApnVec, slotId)) {
344         TELEPHONY_LOGE("query mvno apns by spn fail");
345         return count;
346     }
347     std::u16string imsi;
348     CoreManagerInner::GetInstance().GetIMSI(slotId, imsi);
349     if (!helper->QueryMvnoApnsByType(mcc, mnc, MvnoType::IMSI, Str16ToStr8(imsi), mvnoApnVec, slotId)) {
350         TELEPHONY_LOGE("query mvno apns by imsi fail");
351         return count;
352     }
353     std::u16string gid1;
354     CoreManagerInner::GetInstance().GetSimGid1(slotId, gid1);
355     if (!helper->QueryMvnoApnsByType(mcc, mnc, MvnoType::GID1, Str16ToStr8(gid1), mvnoApnVec, slotId)) {
356         TELEPHONY_LOGE("query mvno apns by gid1 fail");
357         return count;
358     }
359     std::u16string iccId;
360     CoreManagerInner::GetInstance().GetSimIccId(slotId, iccId);
361     if (!helper->QueryMvnoApnsByType(mcc, mnc, MvnoType::ICCID, Str16ToStr8(iccId), mvnoApnVec, slotId)) {
362         TELEPHONY_LOGE("query mvno apns by iccId fail");
363         return count;
364     }
365     return MakeSpecificApnItem(mvnoApnVec);
366 }
367 
MakeSpecificApnItem(std::vector<PdpProfile> & apnVec)368 int32_t ApnManager::MakeSpecificApnItem(std::vector<PdpProfile> &apnVec)
369 {
370     std::lock_guard<std::mutex> lock(mutex_);
371     allApnItem_.clear();
372     int32_t count = 0;
373     for (PdpProfile &apnData : apnVec) {
374         TELEPHONY_LOGI("profileId = %{public}d, profileName = %{public}s, mvnoType = %{public}s",
375             apnData.profileId, apnData.profileName.c_str(), apnData.mvnoType.c_str());
376         if (apnData.profileId == preferId_ && apnData.apnTypes.empty()) {
377             apnData.apnTypes = DATA_CONTEXT_ROLE_DEFAULT;
378         }
379         sptr<ApnItem> apnItem = ApnItem::MakeApn(apnData);
380         if (apnItem != nullptr) {
381             allApnItem_.push_back(apnItem);
382             count++;
383         }
384     }
385     int32_t preferId = preferId_;
386     auto it = std::find_if(allApnItem_.begin(), allApnItem_.end(),
387         [preferId](auto &apn) { return apn != nullptr && apn->attr_.profileId_ == preferId; });
388     if (it != allApnItem_.end()) {
389         sptr<ApnItem> apnItem = *it;
390         allApnItem_.erase(it);
391         allApnItem_.insert(allApnItem_.begin(), apnItem);
392     }
393     return count;
394 }
395 
FilterMatchedApns(const std::string & requestApnType,const int32_t slotId)396 std::vector<sptr<ApnItem>> ApnManager::FilterMatchedApns(const std::string &requestApnType, const int32_t slotId)
397 {
398     std::lock_guard<std::mutex> lock(mutex_);
399     std::vector<sptr<ApnItem>> matchApnItemList;
400     if (requestApnType == DATA_CONTEXT_ROLE_DUN) {
401         FetchDunApns(matchApnItemList, slotId);
402         return matchApnItemList;
403     }
404     for (const sptr<ApnItem> &apnItem : allApnItem_) {
405         if (apnItem->CanDealWithType(requestApnType)) {
406             matchApnItemList.push_back(apnItem);
407         }
408     }
409     TELEPHONY_LOGD("apn size is :%{public}zu", matchApnItemList.size());
410     return matchApnItemList;
411 }
412 
IsDataConnectionNotUsed(const std::shared_ptr<CellularDataStateMachine> & stateMachine) const413 bool ApnManager::IsDataConnectionNotUsed(const std::shared_ptr<CellularDataStateMachine> &stateMachine) const
414 {
415     if (stateMachine == nullptr) {
416         TELEPHONY_LOGE("CellularDataHandler:stateMachine is null");
417         return false;
418     }
419     for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
420         if (apnHolder == nullptr) {
421             TELEPHONY_LOGE("apn holder is null");
422             continue;
423         }
424         std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = apnHolder->GetCellularDataStateMachine();
425         if (cellularDataStateMachine != nullptr && stateMachine == cellularDataStateMachine) {
426             TELEPHONY_LOGE("cellularDataStateMachine in use");
427             return false;
428         }
429     }
430     return true;
431 }
432 
HasAnyConnectedState() const433 bool ApnManager::HasAnyConnectedState() const
434 {
435     for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
436         if (apnHolder == nullptr) {
437             TELEPHONY_LOGE("apn holder is null");
438             continue;
439         }
440         if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTED ||
441             apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_DISCONNECTING) {
442             return true;
443         }
444     }
445     return false;
446 }
447 
GetOverallApnState() const448 ApnProfileState ApnManager::GetOverallApnState() const
449 {
450     if (apnHolders_.empty()) {
451         TELEPHONY_LOGE("apn overall state is STATE_IDLE");
452         return ApnProfileState::PROFILE_STATE_IDLE;
453     }
454     if (HasAnyConnectedState()) {
455         TELEPHONY_LOGI("apn overall state is STATE_CONNECTED");
456         return ApnProfileState::PROFILE_STATE_CONNECTED;
457     }
458     bool failState = false;
459     for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
460         if (apnHolder == nullptr) {
461             continue;
462         }
463         if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTING ||
464             apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_RETRYING) {
465             TELEPHONY_LOGI("apn overall state is STATE_CONNECTING");
466             return ApnProfileState::PROFILE_STATE_CONNECTING;
467         } else if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_IDLE) {
468             failState = true;
469         }
470     }
471     if (failState) {
472         TELEPHONY_LOGD("apn overall state is STATE_IDLE");
473         return ApnProfileState::PROFILE_STATE_IDLE;
474     }
475     TELEPHONY_LOGI("apn overall state is STATE_FAILED");
476     return ApnProfileState::PROFILE_STATE_FAILED;
477 }
478 
GetOverallDefaultApnState() const479 ApnProfileState ApnManager::GetOverallDefaultApnState() const
480 {
481     if (apnHolders_.empty()) {
482         TELEPHONY_LOGE("apn overall state is STATE_IDLE");
483         return ApnProfileState::PROFILE_STATE_IDLE;
484     }
485     ApnProfileState defaultApnState = ApnProfileState::PROFILE_STATE_IDLE;
486     ApnProfileState internalApnState = ApnProfileState::PROFILE_STATE_IDLE;
487 
488     for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
489         if (apnHolder == nullptr) {
490             continue;
491         }
492         if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT) {
493             defaultApnState = apnHolder->GetApnState();
494         }
495         if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
496             internalApnState = apnHolder->GetApnState();
497         }
498     }
499     TELEPHONY_LOGI("defaultApnState is %{public}d, internalApnState is %{public}d", defaultApnState,
500         internalApnState);
501     for (auto apnState : apnStateArr_) {
502         if (defaultApnState == apnState || internalApnState == apnState) {
503             return apnState;
504         }
505     }
506     return ApnProfileState::PROFILE_STATE_IDLE;
507 }
508 
GetRilAttachApn()509 sptr<ApnItem> ApnManager::GetRilAttachApn()
510 {
511     std::lock_guard<std::mutex> lock(mutex_);
512     if (allApnItem_.empty()) {
513         TELEPHONY_LOGE("apn item is null");
514         return nullptr;
515     }
516     sptr<ApnItem> attachApn = nullptr;
517     for (const sptr<ApnItem> &apnItem : allApnItem_) {
518         if (apnItem->CanDealWithType(DATA_CONTEXT_ROLE_IA)) {
519             attachApn = apnItem;
520             break;
521         }
522         if (attachApn == nullptr && apnItem->CanDealWithType(DATA_CONTEXT_ROLE_DEFAULT)) {
523             attachApn = apnItem;
524         }
525     }
526     if (attachApn == nullptr) {
527         attachApn = allApnItem_[0];
528     }
529     return attachApn;
530 }
531 
GetApnItemById(const int32_t id)532 sptr<ApnItem> ApnManager::GetApnItemById(const int32_t id)
533 {
534     std::lock_guard<std::mutex> lock(mutex_);
535     if (allApnItem_.empty()) {
536         TELEPHONY_LOGE("apn item is null");
537         return nullptr;
538     }
539     sptr<ApnItem> attachApn = nullptr;
540     for (const sptr<ApnItem> &apnItem : allApnItem_) {
541         if (id == apnItem->attr_.profileId_) {
542             attachApn = apnItem;
543             break;
544         }
545     }
546     return attachApn;
547 }
548 
ResetApns(int32_t slotId)549 bool ApnManager::ResetApns(int32_t slotId)
550 {
551     auto helper = CellularDataRdbHelper::GetInstance();
552     if (helper == nullptr) {
553         TELEPHONY_LOGE("get cellularDataRdbHelper failed");
554         return false;
555     }
556     return helper->ResetApns(slotId);
557 }
558 
FetchDunApns(std::vector<sptr<ApnItem>> & matchApnItemList,const int32_t slotId)559 void ApnManager::FetchDunApns(std::vector<sptr<ApnItem>> &matchApnItemList, const int32_t slotId)
560 {
561     bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId) > 0;
562     if (roamingState && !IsPreferredApnUserEdited()) {
563         TELEPHONY_LOGI("FetchDunApns: Dun apn is not used in roaming network");
564         return;
565     }
566     int32_t preferId = preferId_;
567     sptr<ApnItem> preferredApn = nullptr;
568     auto it = std::find_if(allApnItem_.begin(), allApnItem_.end(), [preferId](auto &apn) {
569         return apn != nullptr && apn->attr_.profileId_ == preferId;
570     });
571     if (it != allApnItem_.end()) {
572         preferredApn = *it;
573     }
574     if (preferredApn != nullptr && preferredApn->CanDealWithType(DATA_CONTEXT_ROLE_DUN)) {
575         matchApnItemList.insert(matchApnItemList.begin(), preferredApn);
576     }
577     if (matchApnItemList.empty()) {
578         for (const auto &item : allApnItem_) {
579             if (item->CanDealWithType(DATA_CONTEXT_ROLE_DUN)) {
580                 matchApnItemList.push_back(item);
581             }
582         }
583     }
584 }
585 
IsPreferredApnUserEdited()586 bool ApnManager::IsPreferredApnUserEdited()
587 {
588     bool isUserEdited = false;
589     int32_t preferId = preferId_;
590     auto it = std::find_if(allApnItem_.begin(), allApnItem_.end(), [preferId](auto &apn) {
591         return apn->attr_.profileId_ == preferId;
592     });
593     if (it != allApnItem_.end() && *it != nullptr) {
594         isUserEdited = (*it)->attr_.isEdited_;
595     }
596     return isUserEdited;
597 }
598 }  // namespace Telephony
599 }  // namespace OHOS
600