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 "net_specifier.h"
19 #include "telephony_log_wrapper.h"
20
21 #include "cellular_data_utils.h"
22
23 namespace OHOS {
24 namespace Telephony {
25 const std::map<std::string, int32_t> ApnManager::apnIdApnNameMap_ {
26 {DATA_CONTEXT_ROLE_ALL, DATA_CONTEXT_ROLE_ALL_ID},
27 {DATA_CONTEXT_ROLE_DEFAULT, DATA_CONTEXT_ROLE_DEFAULT_ID},
28 {DATA_CONTEXT_ROLE_MMS, DATA_CONTEXT_ROLE_MMS_ID},
29 {DATA_CONTEXT_ROLE_SUPL, DATA_CONTEXT_ROLE_SUPL_ID},
30 {DATA_CONTEXT_ROLE_DUN, DATA_CONTEXT_ROLE_DUN_ID},
31 {DATA_CONTEXT_ROLE_IMS, DATA_CONTEXT_ROLE_IMS_ID},
32 {DATA_CONTEXT_ROLE_IA, DATA_CONTEXT_ROLE_IA_ID},
33 {DATA_CONTEXT_ROLE_EMERGENCY, DATA_CONTEXT_ROLE_EMERGENCY_ID}
34 };
35
36 ApnManager::ApnManager() = default;
37
38 ApnManager::~ApnManager() = default;
39
InitApnHolders()40 void ApnManager::InitApnHolders()
41 {
42 AddApnHolder(DATA_CONTEXT_ROLE_DEFAULT, static_cast<int32_t>(DataContextPriority::PRIORITY_LOW));
43 AddApnHolder(DATA_CONTEXT_ROLE_MMS, static_cast<int32_t>(DataContextPriority::PRIORITY_NORMAL));
44 }
45
FindApnHolderById(const int32_t id) const46 sptr<ApnHolder> ApnManager::FindApnHolderById(const int32_t id) const
47 {
48 if (apnIdApnHolderMap_.empty()) {
49 TELEPHONY_LOGE("apnIdApnHolderMap_ empty");
50 return nullptr;
51 }
52 if (id == DATA_CONTEXT_ROLE_INVALID_ID) {
53 TELEPHONY_LOGE("find a invalid capability!");
54 return nullptr;
55 }
56 std::map<int32_t, sptr<ApnHolder>>::const_iterator it = apnIdApnHolderMap_.find(id);
57 if (it != apnIdApnHolderMap_.end()) {
58 return it->second;
59 }
60 return nullptr;
61 }
62
FindApnIdByApnName(const std::string & type)63 int32_t ApnManager::FindApnIdByApnName(const std::string &type)
64 {
65 std::map<std::string, int32_t>::const_iterator it = apnIdApnNameMap_.find(type);
66 if (it != apnIdApnNameMap_.end()) {
67 return it->second;
68 }
69 TELEPHONY_LOGE("apnType %{public}s is not exist!", type.c_str());
70 return DATA_CONTEXT_ROLE_INVALID_ID;
71 }
72
FindApnNameByApnId(const int32_t id)73 std::string ApnManager::FindApnNameByApnId(const int32_t id)
74 {
75 for (std::pair<const std::string, int32_t> it : apnIdApnNameMap_) {
76 if (it.second == id) {
77 return it.first;
78 }
79 }
80 TELEPHONY_LOGI("apnId %{public}d is not exist!", id);
81 return DATA_CONTEXT_ROLE_DEFAULT;
82 }
83
FindApnIdByCapability(const uint64_t capability)84 int32_t ApnManager::FindApnIdByCapability(const uint64_t capability)
85 {
86 switch (capability) {
87 case NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET:
88 return DATA_CONTEXT_ROLE_DEFAULT_ID;
89 case NetManagerStandard::NetCap::NET_CAPABILITY_MMS:
90 return DATA_CONTEXT_ROLE_MMS_ID;
91 default:
92 return DATA_CONTEXT_ROLE_INVALID_ID;
93 }
94 }
95
AddApnHolder(const std::string & apnType,const int32_t priority)96 void ApnManager::AddApnHolder(const std::string &apnType, const int32_t priority)
97 {
98 int32_t apnId = FindApnIdByApnName(apnType);
99 if (apnId == DATA_CONTEXT_ROLE_INVALID_ID) {
100 TELEPHONY_LOGE("APN INVALID ID");
101 return;
102 }
103 sptr<ApnHolder> apnHolder = std::make_unique<ApnHolder>(apnType, priority).release();
104 if (apnHolder == nullptr) {
105 TELEPHONY_LOGE("apnHolder is null, type: %{public}s", apnType.c_str());
106 return;
107 }
108 apnHolder->SetApnState(PROFILE_STATE_IDLE);
109 apnHolders_.push_back(apnHolder);
110 apnIdApnHolderMap_.insert(std::pair<int32_t, sptr<ApnHolder>>(apnId, apnHolder));
111 sortedApnHolders_.emplace_back(apnHolder);
112 sort(sortedApnHolders_.begin(), sortedApnHolders_.end(),
113 [](const sptr<ApnHolder> &c1, const sptr<ApnHolder> &c2) {
114 return c2->GetPriority() - c1->GetPriority();
115 });
116 TELEPHONY_LOGI("The Apn holder type:%{public}s, size:%{public}zu", apnType.c_str(), sortedApnHolders_.size());
117 }
118
GetApnHolder(const std::string & apnType) const119 sptr<ApnHolder> ApnManager::GetApnHolder(const std::string &apnType) const
120 {
121 int32_t apnId = FindApnIdByApnName(apnType);
122 if (DATA_CONTEXT_ROLE_INVALID_ID == apnId) {
123 TELEPHONY_LOGE("APN INVALID ID");
124 return nullptr;
125 }
126 std::map<int32_t, sptr<ApnHolder>>::const_iterator it = apnIdApnHolderMap_.find(apnId);
127 if (it != apnIdApnHolderMap_.end()) {
128 return it->second;
129 }
130 TELEPHONY_LOGE("ApnManager::GetApnHolder:apnType %{public}s is not exist!", apnType.c_str());
131 return nullptr;
132 }
133
GetAllApnHolder() const134 std::vector<sptr<ApnHolder>> ApnManager::GetAllApnHolder() const
135 {
136 return apnHolders_;
137 }
138
GetSortApnHolder() const139 std::vector<sptr<ApnHolder>> ApnManager::GetSortApnHolder() const
140 {
141 return sortedApnHolders_;
142 }
143
CreateAllApnItem()144 void ApnManager::CreateAllApnItem()
145 {
146 allApnItem_.clear();
147 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DEFAULT));
148 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_MMS));
149 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_SUPL));
150 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_DUN));
151 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_IMS));
152 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_IA));
153 allApnItem_.push_back(ApnItem::MakeDefaultApn(DATA_CONTEXT_ROLE_EMERGENCY));
154 }
155
CreateAllApnItemByDatabase(const std::string & numeric)156 int32_t ApnManager::CreateAllApnItemByDatabase(const std::string &numeric)
157 {
158 int32_t count = 0;
159 if (numeric.empty()) {
160 TELEPHONY_LOGE("numeric is empty!!!");
161 return count;
162 }
163 allApnItem_.clear();
164 std::string mcc = numeric.substr(0, DEFAULT_MCC_SIZE);
165 std::string mnc = numeric.substr(mcc.size(), numeric.size() - mcc.size());
166 TELEPHONY_LOGI("mcc = %{public}s, mnc = %{public}s", mcc.c_str(), mnc.c_str());
167 std::vector<PdpProfile> apnVec;
168 if (!CellularDataRdbHelper::GetInstance()->QueryApns(mcc, mnc, apnVec)) {
169 TELEPHONY_LOGE("query apns from data ability fail");
170 return count;
171 }
172 for (const PdpProfile &apnData : apnVec) {
173 TELEPHONY_LOGI("profileId = %{public}d, profileName = %{public}s",
174 apnData.profileId, apnData.profileName.c_str());
175 sptr<ApnItem> apnItem = ApnItem::MakeApn(apnData);
176 if (apnItem != nullptr) {
177 allApnItem_.push_back(apnItem);
178 count++;
179 }
180 }
181 return count;
182 }
183
FilterMatchedApns(const std::string & requestApnType) const184 std::vector<sptr<ApnItem>> ApnManager::FilterMatchedApns(const std::string &requestApnType) const
185 {
186 std::vector<sptr<ApnItem>> matchApnItemList;
187 for (const sptr<ApnItem> &apnItem : allApnItem_) {
188 if (apnItem->CanDealWithType(requestApnType)) {
189 matchApnItemList.push_back(apnItem);
190 }
191 }
192 TELEPHONY_LOGI("FilterMatchedApns,apn size is :%{public}zu", matchApnItemList.size());
193 return matchApnItemList;
194 }
195
IsDataConnectionNotUsed(const std::shared_ptr<CellularDataStateMachine> & stateMachine) const196 bool ApnManager::IsDataConnectionNotUsed(const std::shared_ptr<CellularDataStateMachine> &stateMachine) const
197 {
198 if (stateMachine == nullptr) {
199 TELEPHONY_LOGE("CellularDataHandler:stateMachine is null");
200 return false;
201 }
202 for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
203 if (apnHolder == nullptr) {
204 TELEPHONY_LOGE("apn holder is null");
205 continue;
206 }
207 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = apnHolder->GetCellularDataStateMachine();
208 if (cellularDataStateMachine != nullptr && stateMachine == cellularDataStateMachine) {
209 TELEPHONY_LOGE("cellularDataStateMachine in use");
210 return false;
211 }
212 }
213 return true;
214 }
215
HasAnyConnectedState() const216 bool ApnManager::HasAnyConnectedState() const
217 {
218 for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
219 if (apnHolder == nullptr) {
220 TELEPHONY_LOGE("apn holder is null");
221 continue;
222 }
223 if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTED ||
224 apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_DISCONNECTING) {
225 return true;
226 }
227 }
228 return false;
229 }
230
GetOverallApnState() const231 ApnProfileState ApnManager::GetOverallApnState() const
232 {
233 if (apnHolders_.empty()) {
234 TELEPHONY_LOGE("apn overall state is STATE_IDLE");
235 return ApnProfileState::PROFILE_STATE_IDLE;
236 }
237 if (HasAnyConnectedState()) {
238 TELEPHONY_LOGI("apn overall state is STATE_CONNECTED");
239 return ApnProfileState::PROFILE_STATE_CONNECTED;
240 }
241 bool failState = false;
242 for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
243 if (apnHolder == nullptr) {
244 continue;
245 }
246 if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTING ||
247 apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_RETRYING) {
248 TELEPHONY_LOGI("apn overall state is STATE_CONNECTING");
249 return ApnProfileState::PROFILE_STATE_CONNECTING;
250 } else if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_IDLE) {
251 failState = true;
252 }
253 }
254 if (failState) {
255 TELEPHONY_LOGI("apn overall state is STATE_IDLE");
256 return ApnProfileState::PROFILE_STATE_IDLE;
257 }
258 TELEPHONY_LOGI("apn overall state is STATE_FAILED");
259 return ApnProfileState::PROFILE_STATE_FAILED;
260 }
261
GetRilAttachApn() const262 sptr<ApnItem> ApnManager::GetRilAttachApn() const
263 {
264 if (allApnItem_.empty()) {
265 TELEPHONY_LOGE("apn item is null");
266 return nullptr;
267 }
268 sptr<ApnItem> attachApn = nullptr;
269 for (const sptr<ApnItem> &apnItem : allApnItem_) {
270 if (apnItem->CanDealWithType(DATA_CONTEXT_ROLE_IA)) {
271 attachApn = apnItem;
272 break;
273 }
274 if (attachApn == nullptr && apnItem->CanDealWithType(DATA_CONTEXT_ROLE_DEFAULT)) {
275 attachApn = apnItem;
276 }
277 }
278 if (attachApn == nullptr) {
279 attachApn = allApnItem_[0];
280 }
281 return attachApn;
282 }
283 } // namespace Telephony
284 } // namespace OHOS