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 auto helper = CellularDataRdbHelper::GetInstance();
169 if (helper == nullptr) {
170 TELEPHONY_LOGE("get cellularDataRdbHelper failed");
171 return count;
172 }
173 if (!helper->QueryApns(mcc, mnc, apnVec)) {
174 TELEPHONY_LOGE("query apns from data ability fail");
175 return count;
176 }
177 for (const PdpProfile &apnData : apnVec) {
178 TELEPHONY_LOGI("profileId = %{public}d, profileName = %{public}s",
179 apnData.profileId, apnData.profileName.c_str());
180 sptr<ApnItem> apnItem = ApnItem::MakeApn(apnData);
181 if (apnItem != nullptr) {
182 allApnItem_.push_back(apnItem);
183 count++;
184 }
185 }
186 return count;
187 }
188
FilterMatchedApns(const std::string & requestApnType) const189 std::vector<sptr<ApnItem>> ApnManager::FilterMatchedApns(const std::string &requestApnType) const
190 {
191 std::vector<sptr<ApnItem>> matchApnItemList;
192 for (const sptr<ApnItem> &apnItem : allApnItem_) {
193 if (apnItem->CanDealWithType(requestApnType)) {
194 matchApnItemList.push_back(apnItem);
195 }
196 }
197 TELEPHONY_LOGI("FilterMatchedApns,apn size is :%{public}zu", matchApnItemList.size());
198 return matchApnItemList;
199 }
200
IsDataConnectionNotUsed(const std::shared_ptr<CellularDataStateMachine> & stateMachine) const201 bool ApnManager::IsDataConnectionNotUsed(const std::shared_ptr<CellularDataStateMachine> &stateMachine) const
202 {
203 if (stateMachine == nullptr) {
204 TELEPHONY_LOGE("CellularDataHandler:stateMachine is null");
205 return false;
206 }
207 for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
208 if (apnHolder == nullptr) {
209 TELEPHONY_LOGE("apn holder is null");
210 continue;
211 }
212 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = apnHolder->GetCellularDataStateMachine();
213 if (cellularDataStateMachine != nullptr && stateMachine == cellularDataStateMachine) {
214 TELEPHONY_LOGE("cellularDataStateMachine in use");
215 return false;
216 }
217 }
218 return true;
219 }
220
HasAnyConnectedState() const221 bool ApnManager::HasAnyConnectedState() const
222 {
223 for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
224 if (apnHolder == nullptr) {
225 TELEPHONY_LOGE("apn holder is null");
226 continue;
227 }
228 if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTED ||
229 apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_DISCONNECTING) {
230 return true;
231 }
232 }
233 return false;
234 }
235
GetOverallApnState() const236 ApnProfileState ApnManager::GetOverallApnState() const
237 {
238 if (apnHolders_.empty()) {
239 TELEPHONY_LOGE("apn overall state is STATE_IDLE");
240 return ApnProfileState::PROFILE_STATE_IDLE;
241 }
242 if (HasAnyConnectedState()) {
243 TELEPHONY_LOGI("apn overall state is STATE_CONNECTED");
244 return ApnProfileState::PROFILE_STATE_CONNECTED;
245 }
246 bool failState = false;
247 for (const sptr<ApnHolder> &apnHolder : apnHolders_) {
248 if (apnHolder == nullptr) {
249 continue;
250 }
251 if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTING ||
252 apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_RETRYING) {
253 TELEPHONY_LOGI("apn overall state is STATE_CONNECTING");
254 return ApnProfileState::PROFILE_STATE_CONNECTING;
255 } else if (apnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_IDLE) {
256 failState = true;
257 }
258 }
259 if (failState) {
260 TELEPHONY_LOGI("apn overall state is STATE_IDLE");
261 return ApnProfileState::PROFILE_STATE_IDLE;
262 }
263 TELEPHONY_LOGI("apn overall state is STATE_FAILED");
264 return ApnProfileState::PROFILE_STATE_FAILED;
265 }
266
GetRilAttachApn() const267 sptr<ApnItem> ApnManager::GetRilAttachApn() const
268 {
269 if (allApnItem_.empty()) {
270 TELEPHONY_LOGE("apn item is null");
271 return nullptr;
272 }
273 sptr<ApnItem> attachApn = nullptr;
274 for (const sptr<ApnItem> &apnItem : allApnItem_) {
275 if (apnItem->CanDealWithType(DATA_CONTEXT_ROLE_IA)) {
276 attachApn = apnItem;
277 break;
278 }
279 if (attachApn == nullptr && apnItem->CanDealWithType(DATA_CONTEXT_ROLE_DEFAULT)) {
280 attachApn = apnItem;
281 }
282 }
283 if (attachApn == nullptr) {
284 attachApn = allApnItem_[0];
285 }
286 return attachApn;
287 }
288 } // namespace Telephony
289 } // namespace OHOS
290