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