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_handler.h"
17
18 #include "cellular_data_constant.h"
19 #include "cellular_data_error.h"
20 #include "cellular_data_hisysevent.h"
21 #include "cellular_data_service.h"
22 #include "cellular_data_settings_rdb_helper.h"
23 #include "cellular_data_types.h"
24 #include "cellular_data_utils.h"
25 #include "common_event_manager.h"
26 #include "common_event_support.h"
27 #include "core_manager_inner.h"
28 #include "hitrace_meter.h"
29 #include "tel_ril_call_parcel.h"
30 #include "net_specifier.h"
31 #include "net_all_capabilities.h"
32 #include "radio_event.h"
33 #include "str_convert.h"
34 #include "string_ex.h"
35 #include "telephony_log_wrapper.h"
36 #include "telephony_types.h"
37 #include "telephony_ext_wrapper.h"
38 #include "telephony_permission.h"
39 #include "ipc_skeleton.h"
40 namespace OHOS {
41 namespace Telephony {
42 using namespace AppExecFwk;
43 using namespace OHOS::EventFwk;
44 using namespace NetManagerStandard;
45 static const int32_t ESM_FLAG_INVALID = -1;
46 const std::string DEFAULT_DATA_ROAMING = "persist.telephony.defaultdataroaming";
CellularDataHandler(const EventFwk::CommonEventSubscribeInfo & sp,int32_t slotId)47 CellularDataHandler::CellularDataHandler(const EventFwk::CommonEventSubscribeInfo &sp, int32_t slotId)
48 : TelEventHandler("CellularDataHandler"), CommonEventSubscriber(sp), slotId_(slotId)
49 {}
50
Init()51 void CellularDataHandler::Init()
52 {
53 apnManager_ = std::make_unique<ApnManager>().release();
54 dataSwitchSettings_ = std::make_unique<DataSwitchSettings>(slotId_);
55 connectionManager_ = std::make_unique<DataConnectionManager>(slotId_).release();
56 settingObserver_ = new (std::nothrow) CellularDataSettingObserver(
57 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())));
58 roamingObserver_ = new (std::nothrow) CellularDataRoamingObserver(
59 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())), slotId_);
60 incallObserver_ = new (std::nothrow) CellularDataIncallObserver(
61 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())));
62 cellularDataRdbObserver_ = new (std::nothrow) CellularDataRdbObserver(
63 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())));
64 if ((apnManager_ == nullptr) || (dataSwitchSettings_ == nullptr) || (connectionManager_ == nullptr)) {
65 TELEPHONY_LOGE("Slot%{public}d: apnManager_ or dataSwitchSettings_ or connectionManager_ is null", slotId_);
66 return;
67 }
68 connectionManager_->Init();
69 apnManager_->InitApnHolders();
70 apnManager_->CreateAllApnItem();
71 dataSwitchSettings_->LoadSwitchValue();
72 GetConfigurationFor5G();
73 SetRilLinkBandwidths();
74 }
75
~CellularDataHandler()76 CellularDataHandler::~CellularDataHandler()
77 {
78 UnRegisterDataSettingObserver();
79 }
80
ReleaseNet(const NetRequest & request)81 bool CellularDataHandler::ReleaseNet(const NetRequest &request)
82 {
83 std::unique_ptr<NetRequest> netRequest = std::make_unique<NetRequest>();
84 if (netRequest == nullptr) {
85 TELEPHONY_LOGE("Netrequest is null");
86 return false;
87 }
88 netRequest->capability = ApnManager::FindBestCapability(request.capability);
89 netRequest->ident = request.ident;
90 AppExecFwk::InnerEvent::Pointer event =
91 InnerEvent::Get(CellularDataEventCode::MSG_REQUEST_NETWORK, netRequest, TYPE_RELEASE_NET);
92 if (event == nullptr) {
93 TELEPHONY_LOGE("event is null");
94 return false;
95 }
96 return SendEvent(event);
97 }
98
RequestNet(const NetRequest & request)99 bool CellularDataHandler::RequestNet(const NetRequest &request)
100 {
101 std::unique_ptr<NetRequest> netRequest = std::make_unique<NetRequest>();
102 if (netRequest == nullptr) {
103 TELEPHONY_LOGE("Netrequest is null");
104 return false;
105 }
106 netRequest->capability = ApnManager::FindBestCapability(request.capability);
107 netRequest->ident = request.ident;
108 netRequest->registerType = request.registerType;
109 netRequest->bearTypes = request.bearTypes;
110 AppExecFwk::InnerEvent::Pointer event =
111 InnerEvent::Get(CellularDataEventCode::MSG_REQUEST_NETWORK, netRequest, TYPE_REQUEST_NET);
112 return SendEvent(event);
113 }
114
SetCellularDataEnable(bool userDataOn)115 int32_t CellularDataHandler::SetCellularDataEnable(bool userDataOn)
116 {
117 if (dataSwitchSettings_ == nullptr) {
118 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
119 return TELEPHONY_ERR_LOCAL_PTR_NULL;
120 }
121 bool dataEnabled = true;
122 int32_t result = dataSwitchSettings_->QueryUserDataStatus(dataEnabled);
123 if (result != TELEPHONY_ERR_SUCCESS) {
124 TELEPHONY_LOGE("Slot%{public}d: Query result: %{public}d", slotId_, result);
125 }
126 if (dataEnabled == userDataOn) {
127 TELEPHONY_LOGI("Slot%{public}d: The status of the cellular data switch has not changed", slotId_);
128 return TELEPHONY_ERR_SUCCESS;
129 }
130
131 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
132 if (TELEPHONY_EXT_WRAPPER.sendDataSwitchChangeInfo_) {
133 int32_t callingUid = IPCSkeleton::GetCallingUid();
134 std::string bundleName = "";
135 TelephonyPermission::GetBundleNameByUid(callingUid, bundleName);
136 TELEPHONY_EXT_WRAPPER.sendDataSwitchChangeInfo_(bundleName.c_str(), userDataOn);
137 }
138 #endif
139 return dataSwitchSettings_->SetUserDataOn(userDataOn);
140 }
141
SetIntelligenceSwitchEnable(bool userSwitchOn)142 int32_t CellularDataHandler::SetIntelligenceSwitchEnable(bool userSwitchOn)
143 {
144 if (dataSwitchSettings_ == nullptr) {
145 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
146 return TELEPHONY_ERR_LOCAL_PTR_NULL;
147 }
148 bool switchEnabled = false;
149 int32_t result = dataSwitchSettings_->QueryIntelligenceSwitchStatus(switchEnabled);
150 if (result != TELEPHONY_ERR_SUCCESS) {
151 TELEPHONY_LOGE("Slot%{public}d: Query result: %{public}d", slotId_, result);
152 }
153 if (switchEnabled == userSwitchOn) {
154 TELEPHONY_LOGI("Slot%{public}d: The status of the cellular data switch has not changed", slotId_);
155 return TELEPHONY_ERR_SUCCESS;
156 }
157 return dataSwitchSettings_->SetIntelliSwitchOn(userSwitchOn);
158 }
159
IsCellularDataEnabled(bool & dataEnabled) const160 int32_t CellularDataHandler::IsCellularDataEnabled(bool &dataEnabled) const
161 {
162 if (dataSwitchSettings_ == nullptr) {
163 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null", slotId_);
164 return TELEPHONY_ERR_LOCAL_PTR_NULL;
165 }
166 return dataSwitchSettings_->QueryUserDataStatus(dataEnabled);
167 }
168
IsCellularDataRoamingEnabled(bool & dataRoamingEnabled) const169 int32_t CellularDataHandler::IsCellularDataRoamingEnabled(bool &dataRoamingEnabled) const
170 {
171 if (slotId_ != CELLULAR_DATA_VSIM_SLOT_ID) {
172 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
173 if (simId <= INVALID_SIM_ID) {
174 TELEPHONY_LOGE("Slot%{public}d: invalid sim id %{public}d", slotId_, simId);
175 return TELEPHONY_ERR_LOCAL_PTR_NULL;
176 }
177 }
178 dataRoamingEnabled = defaultDataRoamingEnable_;
179 if (dataSwitchSettings_ == nullptr) {
180 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null", slotId_);
181 return TELEPHONY_ERR_LOCAL_PTR_NULL;
182 }
183 dataSwitchSettings_->QueryUserDataRoamingStatus(dataRoamingEnabled);
184 return TELEPHONY_ERR_SUCCESS;
185 }
186
GetIntelligenceSwitchState(bool & switchState)187 int32_t CellularDataHandler::GetIntelligenceSwitchState(bool &switchState)
188 {
189 if (dataSwitchSettings_ == nullptr) {
190 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
191 return TELEPHONY_ERR_LOCAL_PTR_NULL;
192 }
193 bool switchEnabled = false;
194 int32_t result = dataSwitchSettings_->QueryIntelligenceSwitchStatus(switchEnabled);
195 if (result != TELEPHONY_ERR_SUCCESS) {
196 TELEPHONY_LOGE("Slot%{public}d: Query result: %{public}d", slotId_, result);
197 }
198 TELEPHONY_LOGI("GetIntelligenceSwitchState: %{public}d -- %{public}d", switchState, switchEnabled);
199 switchState = switchEnabled;
200 return result;
201 }
202
SetCellularDataRoamingEnabled(bool dataRoamingEnabled)203 int32_t CellularDataHandler::SetCellularDataRoamingEnabled(bool dataRoamingEnabled)
204 {
205 if (dataSwitchSettings_ == nullptr || apnManager_ == nullptr) {
206 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ or apnManager_ is null", slotId_);
207 return TELEPHONY_ERR_LOCAL_PTR_NULL;
208 }
209 bool currentDataEnabled = dataSwitchSettings_->IsUserDataRoamingOn();
210 if (currentDataEnabled == dataRoamingEnabled) {
211 TELEPHONY_LOGI("Slot%{public}d: The roaming switch status has not changed", slotId_);
212 return TELEPHONY_ERR_SUCCESS;
213 }
214 int32_t result = dataSwitchSettings_->SetUserDataRoamingOn(dataRoamingEnabled);
215 if (result != TELEPHONY_ERR_SUCCESS) {
216 return result;
217 }
218 bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0;
219 if (roamingState) {
220 ApnProfileState apnState = apnManager_->GetOverallApnState();
221 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
222 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
223 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
224 }
225 EstablishAllApnsIfConnectable();
226 } else {
227 TELEPHONY_LOGI("Slot%{public}d: Not roaming(%{public}d), not doing anything", slotId_, roamingState);
228 }
229 return TELEPHONY_ERR_SUCCESS;
230 }
231
ClearAllConnections(DisConnectionReason reason)232 void CellularDataHandler::ClearAllConnections(DisConnectionReason reason)
233 {
234 if (apnManager_ == nullptr) {
235 TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
236 return;
237 }
238 ApnProfileState currentState = apnManager_->GetOverallApnState();
239 if (currentState == ApnProfileState::PROFILE_STATE_CONNECTED ||
240 currentState == ApnProfileState::PROFILE_STATE_CONNECTING) {
241 int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
242 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
243 StateNotification::GetInstance().UpdateCellularDataConnectState(
244 slotId_, PROFILE_STATE_DISCONNECTING, networkType);
245 }
246 for (const sptr<ApnHolder> &apn : apnManager_->GetAllApnHolder()) {
247 ClearConnection(apn, reason);
248 }
249
250 if (connectionManager_ == nullptr) {
251 TELEPHONY_LOGE("Slot%{public}d: connectionManager_ is null", slotId_);
252 return;
253 }
254 connectionManager_->StopStallDetectionTimer();
255 connectionManager_->EndNetStatistics();
256
257 ResetDataFlowType();
258 }
259
ResetDataFlowType()260 void CellularDataHandler::ResetDataFlowType()
261 {
262 if (dataSwitchSettings_ == nullptr) {
263 TELEPHONY_LOGE("Slot%{public}d: in ClearAllConnections dataSwitchSettings_ is null", slotId_);
264 return;
265 }
266 bool dataEnabled = dataSwitchSettings_->IsUserDataOn();
267 if (!dataEnabled) {
268 connectionManager_->SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
269 }
270 }
271
ClearConnection(const sptr<ApnHolder> & apn,DisConnectionReason reason)272 void CellularDataHandler::ClearConnection(const sptr<ApnHolder> &apn, DisConnectionReason reason)
273 {
274 if (apn == nullptr) {
275 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
276 return;
277 }
278 std::shared_ptr<CellularDataStateMachine> stateMachine = apn->GetCellularDataStateMachine();
279 if (stateMachine == nullptr) {
280 TELEPHONY_LOGD("Slot%{public}d: stateMachine is null", slotId_);
281 return;
282 }
283 TELEPHONY_LOGI("Slot%{public}d: The APN holder is of type %{public}s", slotId_, apn->GetApnType().c_str());
284 std::unique_ptr<DataDisconnectParams> object = std::make_unique<DataDisconnectParams>(apn->GetApnType(), reason);
285 if (object == nullptr) {
286 TELEPHONY_LOGE("Slot%{public}d: ClearConnection fail, object is null", slotId_);
287 return;
288 }
289 apn->SetApnState(PROFILE_STATE_DISCONNECTING);
290 apn->SetCellularDataStateMachine(nullptr);
291 InnerEvent::Pointer event = InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, object);
292 stateMachine->SendEvent(event);
293 }
294
GetCellularDataState() const295 ApnProfileState CellularDataHandler::GetCellularDataState() const
296 {
297 if (apnManager_ == nullptr) {
298 TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
299 return ApnProfileState::PROFILE_STATE_IDLE;
300 }
301 return apnManager_->GetOverallApnState();
302 }
303
GetCellularDataState(const std::string & apnType) const304 ApnProfileState CellularDataHandler::GetCellularDataState(const std::string &apnType) const
305 {
306 if (apnManager_ == nullptr) {
307 TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
308 return ApnProfileState::PROFILE_STATE_IDLE;
309 }
310 sptr<ApnHolder> apnHolder = apnManager_->GetApnHolder(apnType);
311 if (apnHolder == nullptr) {
312 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
313 return ApnProfileState::PROFILE_STATE_IDLE;
314 }
315 return apnHolder->GetApnState();
316 }
317
RadioPsConnectionAttached(const InnerEvent::Pointer & event)318 void CellularDataHandler::RadioPsConnectionAttached(const InnerEvent::Pointer &event)
319 {
320 TELEPHONY_LOGI("Slot%{public}d: ps attached", slotId_);
321 if (event == nullptr || apnManager_ == nullptr) {
322 TELEPHONY_LOGE("Slot%{public}d: event or apnManager_ is null", slotId_);
323 return;
324 }
325 EstablishAllApnsIfConnectable();
326 }
327
RadioPsConnectionDetached(const InnerEvent::Pointer & event)328 void CellularDataHandler::RadioPsConnectionDetached(const InnerEvent::Pointer &event)
329 {
330 TELEPHONY_LOGI("Slot%{public}d: ps detached", slotId_);
331 if (event == nullptr) {
332 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
333 return;
334 }
335 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
336 }
337
RoamingStateOn(const InnerEvent::Pointer & event)338 void CellularDataHandler::RoamingStateOn(const InnerEvent::Pointer &event)
339 {
340 TELEPHONY_LOGI("Slot%{public}d: roaming on", slotId_);
341 if (event == nullptr || dataSwitchSettings_ == nullptr || apnManager_ == nullptr) {
342 TELEPHONY_LOGE("Slot%{public}d: event or dataSwitchSettings_ or apnManager_ is null", slotId_);
343 return;
344 }
345 bool roamingState = false;
346 if (CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0) {
347 roamingState = true;
348 }
349 if (!roamingState) {
350 TELEPHONY_LOGE("Slot%{public}d: device not currently roaming state", slotId_);
351 return;
352 }
353 ApnProfileState apnState = apnManager_->GetOverallApnState();
354 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING || apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
355 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
356 }
357 EstablishAllApnsIfConnectable();
358 }
359
RoamingStateOff(const InnerEvent::Pointer & event)360 void CellularDataHandler::RoamingStateOff(const InnerEvent::Pointer &event)
361 {
362 TELEPHONY_LOGI("Slot%{public}d: roaming off", slotId_);
363 if (event == nullptr || dataSwitchSettings_ == nullptr || apnManager_ == nullptr) {
364 TELEPHONY_LOGE("Slot%{public}d: event or dataSwitchSettings_ or apnManager_ is null", slotId_);
365 return;
366 }
367 ApnProfileState apnState = apnManager_->GetOverallApnState();
368 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING || apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
369 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
370 }
371 EstablishAllApnsIfConnectable();
372 }
373
PsRadioEmergencyStateOpen(const InnerEvent::Pointer & event)374 void CellularDataHandler::PsRadioEmergencyStateOpen(const InnerEvent::Pointer &event)
375 {
376 TELEPHONY_LOGI("Slot%{public}d: emergency on", slotId_);
377 ApnProfileState currentState = apnManager_->GetOverallApnState();
378 if (currentState == ApnProfileState::PROFILE_STATE_CONNECTED ||
379 currentState == ApnProfileState::PROFILE_STATE_CONNECTING) {
380 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
381 }
382 }
383
PsRadioEmergencyStateClose(const InnerEvent::Pointer & event)384 void CellularDataHandler::PsRadioEmergencyStateClose(const InnerEvent::Pointer &event)
385 {
386 TELEPHONY_LOGI("Slot%{public}d: emergency off", slotId_);
387 ApnProfileState currentState = apnManager_->GetOverallApnState();
388 if (currentState == ApnProfileState::PROFILE_STATE_IDLE ||
389 currentState == ApnProfileState::PROFILE_STATE_DISCONNECTING) {
390 EstablishAllApnsIfConnectable();
391 }
392 }
393
EstablishAllApnsIfConnectable()394 void CellularDataHandler::EstablishAllApnsIfConnectable()
395 {
396 if (apnManager_ == nullptr) {
397 TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
398 return;
399 }
400 for (sptr<ApnHolder> apnHolder : apnManager_->GetSortApnHolder()) {
401 if (apnHolder == nullptr) {
402 TELEPHONY_LOGE("Slot%{public}d: apn is null", slotId_);
403 continue;
404 }
405 if (apnHolder->IsDataCallEnabled() || IsVSimSlotId(slotId_)) {
406 ApnProfileState apnState = apnHolder->GetApnState();
407 if (apnState == PROFILE_STATE_FAILED || apnState == PROFILE_STATE_RETRYING) {
408 apnHolder->ReleaseDataConnection();
409 }
410 AttemptEstablishDataConnection(apnHolder);
411 }
412 }
413 }
414
SetDataPermittedForMms(bool dataPermittedForMms)415 bool CellularDataHandler::SetDataPermittedForMms(bool dataPermittedForMms)
416 {
417 if (incallDataStateMachine_ != nullptr) {
418 TELEPHONY_LOGI("Slot%{public}d: incall data active", slotId_);
419 return false;
420 }
421 if (CheckDataPermittedByDsds()) {
422 TELEPHONY_LOGI("Slot%{public}d: data permitted", slotId_);
423 return false;
424 }
425 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
426 const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
427 SetDataPermitted(defSlotId, !dataPermittedForMms);
428 SetDataPermitted(slotId_, dataPermittedForMms);
429 DelayedRefSingleton<CellularDataService>::GetInstance().ChangeConnectionForDsds(defSlotId, !dataPermittedForMms);
430 return true;
431 }
432
CheckDataPermittedByDsds()433 bool CellularDataHandler::CheckDataPermittedByDsds()
434 {
435 if (TELEPHONY_EXT_WRAPPER.getVSimSlotId_) {
436 int vSimSlotId = INVALID_SLOT_ID;
437 TELEPHONY_EXT_WRAPPER.getVSimSlotId_(vSimSlotId);
438 if (vSimSlotId == CELLULAR_DATA_VSIM_SLOT_ID) {
439 return slotId_ == CELLULAR_DATA_VSIM_SLOT_ID;
440 }
441 }
442 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
443 const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
444 int32_t dsdsMode = DSDS_MODE_V2;
445 coreInner.GetDsdsMode(dsdsMode);
446 if (defSlotId != slotId_ && dsdsMode == DSDS_MODE_V2) {
447 TELEPHONY_LOGI("Slot%{public}d: default:%{public}d, current:%{public}d, dsdsMode:%{public}d", slotId_,
448 defSlotId, slotId_, dsdsMode);
449 return false;
450 }
451 return true;
452 }
453
CheckCellularDataSlotId(sptr<ApnHolder> & apnHolder)454 bool CellularDataHandler::CheckCellularDataSlotId(sptr<ApnHolder> &apnHolder)
455 {
456 if (apnHolder == nullptr) {
457 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
458 return false;
459 }
460 if (IsVSimSlotId(slotId_)) {
461 return true;
462 }
463
464 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
465 if (TELEPHONY_EXT_WRAPPER.isDualCellularCardAllowed_) {
466 if (TELEPHONY_EXT_WRAPPER.isDualCellularCardAllowed_()) {
467 return true;
468 }
469 }
470 #endif
471
472 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
473 const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
474 std::string apnType = apnHolder->GetApnType();
475 if (defSlotId != slotId_ && !apnType.compare(DATA_CONTEXT_ROLE_DEFAULT)) {
476 TELEPHONY_LOGD("Slot%{public}d: default:%{public}d, current:%{public}d", slotId_, defSlotId, slotId_);
477 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
478 CellularDataErrorCode::DATA_ERROR_CELLULAR_DATA_SLOT_ID_MISMATCH,
479 "Default cellular data slot id is not current slot id");
480 return false;
481 }
482 if (defSlotId != slotId_ && !apnType.compare(DATA_CONTEXT_ROLE_INTERNAL_DEFAULT)) {
483 TELEPHONY_LOGD("Slot%{public}d: default:%{public}d, current:%{public}d", slotId_, defSlotId, slotId_);
484 return false;
485 }
486 return true;
487 }
488
CheckAttachAndSimState(sptr<ApnHolder> & apnHolder)489 bool CellularDataHandler::CheckAttachAndSimState(sptr<ApnHolder> &apnHolder)
490 {
491 if (apnHolder == nullptr) {
492 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
493 return false;
494 }
495 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
496 bool attached = coreInner.GetPsRegState(slotId_) == (int32_t)RegServiceState::REG_STATE_IN_SERVICE;
497 SimState simState = SimState::SIM_STATE_UNKNOWN;
498 coreInner.GetSimState(slotId_, simState);
499 TELEPHONY_LOGD("Slot%{public}d: attached: %{public}d simState: %{public}d isSimAccountLoaded: %{public}d",
500 slotId_, attached, simState, isSimAccountLoaded_);
501 bool isEmergencyApn = apnHolder->IsEmergencyType();
502 if (!isEmergencyApn && !attached) {
503 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
504 CellularDataErrorCode::DATA_ERROR_PS_NOT_ATTACH, "It is not emergencyApn and not attached");
505 return false;
506 }
507 if (!isEmergencyApn && (simState != SimState::SIM_STATE_READY)) {
508 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
509 CellularDataErrorCode::DATA_ERROR_SIM_NOT_READY, "It is not emergencyApn and sim not ready");
510 return false;
511 }
512 return isEmergencyApn || isSimAccountLoaded_;
513 }
514
CheckRoamingState(sptr<ApnHolder> & apnHolder)515 bool CellularDataHandler::CheckRoamingState(sptr<ApnHolder> &apnHolder)
516 {
517 if (dataSwitchSettings_ == nullptr || apnHolder == nullptr) {
518 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ or apnManager_ is null", slotId_);
519 return false;
520 }
521 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
522 bool isEmergencyApn = apnHolder->IsEmergencyType();
523 bool isMmsApn = apnHolder->IsMmsType();
524 bool isAllowActiveData = dataSwitchSettings_->IsAllowActiveData();
525 bool roamingState = coreInner.GetPsRoamingState(slotId_) > 0;
526 bool dataRoamingEnabled = dataSwitchSettings_->IsUserDataRoamingOn();
527 if (roamingState && !dataRoamingEnabled) {
528 isAllowActiveData = false;
529 } else if (isMmsApn) {
530 isAllowActiveData = true;
531 }
532 if (isEmergencyApn) {
533 isAllowActiveData = true;
534 }
535
536 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
537 if (TELEPHONY_EXT_WRAPPER.isApnAllowedActive_) {
538 std::string apnHolderType = apnHolder->GetApnType();
539 isAllowActiveData =
540 TELEPHONY_EXT_WRAPPER.isApnAllowedActive_(slotId_, apnHolderType.c_str(), isAllowActiveData);
541 }
542 #endif
543
544 if (!isAllowActiveData) {
545 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
546 CellularDataErrorCode::DATA_ERROR_ROAMING_SWITCH_OFF_AND_ROAMING, "Data roaming is not on and is roaming");
547 TELEPHONY_LOGD("Slot%{public}d: AllowActiveData:%{public}d lastCallState_:%{public}d", slotId_,
548 isAllowActiveData, lastCallState_);
549 return false;
550 }
551 if (IsRestrictedMode()) {
552 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
553 CellularDataErrorCode::DATA_ERROR_CALL_AND_DATA_NOT_CONCURRENCY,
554 "CS call and data are not allowed concurrency");
555 TELEPHONY_LOGD("Slot%{public}d: AllowActiveData:%{public}d lastCallState_:%{public}d", slotId_,
556 isAllowActiveData, lastCallState_);
557 return false;
558 }
559 return true;
560 }
561
CheckApnState(sptr<ApnHolder> & apnHolder)562 bool CellularDataHandler::CheckApnState(sptr<ApnHolder> &apnHolder)
563 {
564 if (apnManager_ == nullptr || apnHolder == nullptr) {
565 TELEPHONY_LOGE("Slot%{public}d: apnManager_ or apnManager_ is null", slotId_);
566 return false;
567 }
568 if (apnHolder->GetApnState() == PROFILE_STATE_DISCONNECTING &&
569 !HasInnerEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION)) {
570 TELEPHONY_LOGI("Slot%{public}d: APN holder is disconnecting", slotId_);
571 int32_t id = apnManager_->FindApnIdByApnName(apnHolder->GetApnType());
572 SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, id, ESTABLISH_DATA_CONNECTION_DELAY);
573 return false;
574 }
575 if (apnHolder->GetApnState() == PROFILE_STATE_FAILED) {
576 apnHolder->SetApnState(PROFILE_STATE_IDLE);
577 }
578
579 if (apnHolder->GetApnState() != PROFILE_STATE_IDLE) {
580 TELEPHONY_LOGD("Slot%{public}d: APN holder is not idle, apn state is %{public}d",
581 slotId_, apnHolder->GetApnState());
582 return false;
583 }
584 std::vector<sptr<ApnItem>> matchedApns = apnManager_->FilterMatchedApns(apnHolder->GetApnType(), slotId_);
585 if (matchedApns.empty()) {
586 TELEPHONY_LOGE("Slot%{public}d: AttemptEstablishDataConnection:matchedApns is empty", slotId_);
587 return false;
588 }
589 apnHolder->SetAllMatchedApns(matchedApns);
590 return true;
591 }
592
AttemptEstablishDataConnection(sptr<ApnHolder> & apnHolder)593 void CellularDataHandler::AttemptEstablishDataConnection(sptr<ApnHolder> &apnHolder)
594 {
595 if (!CheckCellularDataSlotId(apnHolder) || !CheckAttachAndSimState(apnHolder) || !CheckRoamingState(apnHolder)) {
596 return;
597 }
598 DelayedSingleton<CellularDataHiSysEvent>::GetInstance()->SetCellularDataActivateStartTime();
599 StartTrace(HITRACE_TAG_OHOS, "ActivateCellularData");
600 if (!CheckApnState(apnHolder)) {
601 FinishTrace(HITRACE_TAG_OHOS);
602 return;
603 }
604 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
605 int32_t radioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
606 coreInner.GetPsRadioTech(slotId_, radioTech);
607 if (!EstablishDataConnection(apnHolder, radioTech)) {
608 TELEPHONY_LOGE("Slot%{public}d: Establish data connection fail", slotId_);
609 }
610 FinishTrace(HITRACE_TAG_OHOS);
611 DelayedSingleton<CellularDataHiSysEvent>::GetInstance()->JudgingDataActivateTimeOut(slotId_, SWITCH_ON);
612 }
613
FindIdleCellularDataConnection() const614 std::shared_ptr<CellularDataStateMachine> CellularDataHandler::FindIdleCellularDataConnection() const
615 {
616 if (connectionManager_ == nullptr) {
617 TELEPHONY_LOGE("Slot%{public}d: connectionManager_ is null", slotId_);
618 return nullptr;
619 }
620 std::vector<std::shared_ptr<CellularDataStateMachine>> allMachines = connectionManager_->GetAllConnectionMachine();
621 for (const std::shared_ptr<CellularDataStateMachine> &connect : allMachines) {
622 if (connect == nullptr || apnManager_ == nullptr) {
623 TELEPHONY_LOGE("Slot%{public}d: CellularDataHandler:stateMachine or apnManager_ is null", slotId_);
624 return nullptr;
625 }
626 if (connect->IsInactiveState() && apnManager_->IsDataConnectionNotUsed(connect)) {
627 return connect;
628 }
629 }
630 return nullptr;
631 }
632
CreateCellularDataConnect()633 std::shared_ptr<CellularDataStateMachine> CellularDataHandler::CreateCellularDataConnect()
634 {
635 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = std::make_shared<CellularDataStateMachine>(
636 connectionManager_, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
637 if (cellularDataStateMachine == nullptr) {
638 TELEPHONY_LOGE("Slot%{public}d: cellularDataStateMachine is null", slotId_);
639 return nullptr;
640 }
641 return cellularDataStateMachine;
642 }
643
EstablishDataConnection(sptr<ApnHolder> & apnHolder,int32_t radioTech)644 bool CellularDataHandler::EstablishDataConnection(sptr<ApnHolder> &apnHolder, int32_t radioTech)
645 {
646 sptr<ApnItem> apnItem = apnHolder->GetNextRetryApn();
647 if (apnItem == nullptr) {
648 TELEPHONY_LOGE("Slot%{public}d: apnItem is null", slotId_);
649 return false;
650 }
651 std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = nullptr;
652 if (apnHolder->GetApnType() != DATA_CONTEXT_ROLE_DUN) {
653 cellularDataStateMachine = CheckForCompatibleDataConnection(apnHolder);
654 if (cellularDataStateMachine != nullptr) {
655 sptr<ApnItem> dcApnItem = cellularDataStateMachine->GetApnItem();
656 if (dcApnItem != nullptr) {
657 apnItem = dcApnItem;
658 }
659 }
660 }
661 if (cellularDataStateMachine == nullptr) {
662 if (IsSingleConnectionEnabled(radioTech)) {
663 if (HasAnyHigherPriorityConnection(apnHolder)) {
664 TELEPHONY_LOGE("Slot%{public}d: has higher priority connection", slotId_);
665 return false;
666 }
667 ApnProfileState apnState = apnManager_->GetOverallApnState();
668 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
669 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
670 ClearAllConnections(DisConnectionReason::REASON_CHANGE_CONNECTION);
671 return false;
672 }
673 }
674 cellularDataStateMachine = FindIdleCellularDataConnection();
675 if (cellularDataStateMachine == nullptr) {
676 cellularDataStateMachine = CreateCellularDataConnect();
677 if (cellularDataStateMachine == nullptr) {
678 TELEPHONY_LOGE("Slot%{public}d: cellularDataStateMachine is null", slotId_);
679 return false;
680 }
681 cellularDataStateMachine->Init();
682 if (connectionManager_ == nullptr) {
683 TELEPHONY_LOGE("Slot%{public}d: connectionManager_ is null", slotId_);
684 return false;
685 }
686 connectionManager_->AddConnectionStateMachine(cellularDataStateMachine);
687 }
688 }
689 cellularDataStateMachine->SetCapability(apnHolder->GetCapability());
690 apnHolder->SetCurrentApn(apnItem);
691 apnHolder->SetApnState(PROFILE_STATE_CONNECTING);
692 apnHolder->SetCellularDataStateMachine(cellularDataStateMachine);
693 bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0;
694 bool userDataRoaming = dataSwitchSettings_->IsUserDataRoamingOn();
695 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
696 apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
697 ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
698 StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, radioTech);
699 }
700 std::unique_ptr<DataConnectionParams> object = std::make_unique<DataConnectionParams>(
701 apnHolder, apnItem->attr_.profileId_, radioTech, roamingState, userDataRoaming, true);
702 TELEPHONY_LOGI("Slot%{public}d: MSG_SM_CONNECT profileId:%{public}d type:%{public}s networkType:%{public}d",
703 slotId_, apnItem->attr_.profileId_, apnHolder->GetApnType().c_str(), radioTech);
704 InnerEvent::Pointer event = InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, object);
705 if (event == nullptr) {
706 TELEPHONY_LOGE("event is null");
707 return false;
708 }
709 cellularDataStateMachine->SendEvent(event);
710 return true;
711 }
712
EstablishDataConnectionComplete(const InnerEvent::Pointer & event)713 void CellularDataHandler::EstablishDataConnectionComplete(const InnerEvent::Pointer &event)
714 {
715 if (event == nullptr) {
716 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
717 return;
718 }
719 std::shared_ptr<SetupDataCallResultInfo> resultInfo = event->GetSharedObject<SetupDataCallResultInfo>();
720 if ((resultInfo != nullptr) && (apnManager_ != nullptr)) {
721 sptr<ApnHolder> apnHolder = apnManager_->GetApnHolder(apnManager_->FindApnNameByApnId(resultInfo->flag));
722 if (apnHolder == nullptr) {
723 TELEPHONY_LOGE("Slot%{public}d: flag:%{public}d complete apnHolder is null", slotId_, resultInfo->flag);
724 return;
725 }
726 apnHolder->SetApnState(PROFILE_STATE_CONNECTED);
727 apnHolder->InitialApnRetryCount();
728 std::shared_ptr<CellularDataStateMachine> stateMachine = apnHolder->GetCellularDataStateMachine();
729 if (stateMachine != nullptr) {
730 std::string proxyIpAddress = "";
731 sptr<ApnItem> attachApn = apnManager_->GetRilAttachApn();
732 if (attachApn != nullptr) {
733 proxyIpAddress = attachApn->attr_.proxyIpAddress_;
734 }
735 stateMachine->UpdateHttpProxy(proxyIpAddress);
736 stateMachine->UpdateNetworkInfo(*resultInfo);
737 } else {
738 TELEPHONY_LOGE(
739 "Slot%{public}d:update network info stateMachine(%{public}d) is null", slotId_, resultInfo->flag);
740 }
741 if (connectionManager_ != nullptr) {
742 connectionManager_->StartStallDetectionTimer();
743 connectionManager_->BeginNetStatistics();
744 }
745 if (!physicalConnectionActiveState_) {
746 physicalConnectionActiveState_ = true;
747 CoreManagerInner::GetInstance().DcPhysicalLinkActiveUpdate(slotId_, physicalConnectionActiveState_);
748 }
749 if (incallDataStateMachine_ != nullptr) {
750 InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_CONNECTED);
751 incallDataStateMachine_->SendEvent(incallEvent);
752 }
753 int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
754 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
755 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
756 apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
757 ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
758 StateNotification::GetInstance().UpdateCellularDataConnectState(
759 slotId_, apnState, networkType);
760 }
761 }
762 }
763
GetSlotId() const764 int32_t CellularDataHandler::GetSlotId() const
765 {
766 return slotId_;
767 }
768
DisconnectDataComplete(const InnerEvent::Pointer & event)769 void CellularDataHandler::DisconnectDataComplete(const InnerEvent::Pointer &event)
770 {
771 if (event == nullptr || apnManager_ == nullptr || connectionManager_ == nullptr) {
772 TELEPHONY_LOGE("Slot%{public}d: event or apnManager or connectionManager_ is null", slotId_);
773 return;
774 }
775 std::unique_ptr<DataDisconnectParams> object = event->GetUniqueObject<DataDisconnectParams>();
776 if (object == nullptr) {
777 TELEPHONY_LOGE("Slot%{public}d: object is null", slotId_);
778 return;
779 }
780 int32_t apnId = apnManager_->FindApnIdByApnName(object->GetApnType());
781 sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(apnId);
782 if (apnHolder == nullptr) {
783 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null, apnId is %{public}d", slotId_, apnId);
784 return;
785 }
786 DisConnectionReason reason = object->GetReason();
787 apnHolder->SetApnState(PROFILE_STATE_IDLE);
788 int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
789 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
790 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
791 apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
792 ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
793 StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, networkType);
794 }
795 UpdatePhysicalConnectionState(connectionManager_->isNoActiveConnection());
796 if (apnHolder->IsDataCallEnabled()) {
797 if (apnHolder->GetApnState() == PROFILE_STATE_IDLE || apnHolder->GetApnState() == PROFILE_STATE_FAILED) {
798 apnHolder->SetCellularDataStateMachine(nullptr);
799 }
800 if (reason == DisConnectionReason::REASON_RETRY_CONNECTION) {
801 SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, apnId, apnHolder->GetRetryDelay());
802 }
803 }
804 if (!apnManager_->HasAnyConnectedState()) {
805 connectionManager_->StopStallDetectionTimer();
806 connectionManager_->EndNetStatistics();
807 if (incallDataStateMachine_ != nullptr) {
808 InnerEvent::Pointer incallEvent =
809 InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_DISCONNECTED);
810 incallDataStateMachine_->SendEvent(incallEvent);
811 }
812 }
813 if (reason == DisConnectionReason::REASON_CHANGE_CONNECTION) {
814 HandleSortConnection();
815 }
816 }
817
UpdatePhysicalConnectionState(bool noActiveConnection)818 void CellularDataHandler::UpdatePhysicalConnectionState(bool noActiveConnection)
819 {
820 if (noActiveConnection && physicalConnectionActiveState_) {
821 physicalConnectionActiveState_ = false;
822 CoreManagerInner::GetInstance().DcPhysicalLinkActiveUpdate(slotId_, physicalConnectionActiveState_);
823 } else if (!noActiveConnection && !physicalConnectionActiveState_) {
824 physicalConnectionActiveState_ = true;
825 CoreManagerInner::GetInstance().DcPhysicalLinkActiveUpdate(slotId_, physicalConnectionActiveState_);
826 }
827 }
828
HandleSortConnection()829 void CellularDataHandler::HandleSortConnection()
830 {
831 ApnProfileState state = apnManager_->GetOverallApnState();
832 if (state == PROFILE_STATE_IDLE || state == PROFILE_STATE_FAILED) {
833 for (const sptr<ApnHolder> &sortApnHolder : apnManager_->GetSortApnHolder()) {
834 if (sortApnHolder->IsDataCallEnabled()) {
835 int32_t apnId = apnManager_->FindApnIdByApnName(sortApnHolder->GetApnType());
836 TELEPHONY_LOGI("Slot%{public}d: HandleSortConnection the apn type is %{public}s", slotId_,
837 sortApnHolder->GetApnType().c_str());
838 SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, apnId, 0);
839 break;
840 }
841 }
842 }
843 }
844
MsgEstablishDataConnection(const InnerEvent::Pointer & event)845 void CellularDataHandler::MsgEstablishDataConnection(const InnerEvent::Pointer &event)
846 {
847 if (apnManager_ == nullptr || event == nullptr) {
848 TELEPHONY_LOGE("Slot%{public}d: apnManager_ or event is null", slotId_);
849 return;
850 }
851 sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(event->GetParam());
852 if (apnHolder == nullptr) {
853 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
854 return;
855 }
856 TELEPHONY_LOGD("Slot%{public}d: APN holder type:%{public}s call:%{public}d", slotId_,
857 apnHolder->GetApnType().c_str(), apnHolder->IsDataCallEnabled());
858 if (apnHolder->IsMmsType()) {
859 SetDataPermittedForMms(apnHolder->IsDataCallEnabled());
860 }
861 if (apnHolder->IsDataCallEnabled()) {
862 AttemptEstablishDataConnection(apnHolder);
863 } else {
864 DisConnectionReason reason = DisConnectionReason::REASON_CHANGE_CONNECTION;
865 int32_t radioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
866 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, radioTech);
867 if (!IsSingleConnectionEnabled(radioTech)) {
868 reason = DisConnectionReason::REASON_CLEAR_CONNECTION;
869 }
870 ClearConnection(apnHolder, reason);
871 }
872 }
873
MsgRequestNetwork(const InnerEvent::Pointer & event)874 void CellularDataHandler::MsgRequestNetwork(const InnerEvent::Pointer &event)
875 {
876 if (apnManager_ == nullptr || event == nullptr) {
877 TELEPHONY_LOGE("Slot%{public}d: apnManager_ or event is null", slotId_);
878 return;
879 }
880 std::unique_ptr<NetRequest> netRequest = event->GetUniqueObject<NetRequest>();
881 if (netRequest == nullptr) {
882 TELEPHONY_LOGE("Slot%{public}d: netRequest is null", slotId_);
883 return;
884 }
885 NetRequest request;
886 request.ident = netRequest->ident;
887 request.capability = netRequest->capability;
888 request.registerType = netRequest->registerType;
889 request.bearTypes = netRequest->bearTypes;
890 int32_t id = ApnManager::FindApnIdByCapability(request.capability);
891 sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(id);
892 if (apnHolder == nullptr) {
893 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null.", slotId_);
894 return;
895 }
896 bool isAllCellularDataAllowed = true;
897 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
898 if (TELEPHONY_EXT_WRAPPER.isAllCellularDataAllowed_) {
899 isAllCellularDataAllowed = TELEPHONY_EXT_WRAPPER.isAllCellularDataAllowed_(request);
900 }
901 #endif
902 if (isAllCellularDataAllowed) {
903 TELEPHONY_LOGD("allow cellular data");
904 if (event->GetParam() == TYPE_REQUEST_NET) {
905 apnHolder->RequestCellularData(request);
906 } else {
907 apnHolder->ReleaseCellularData(request);
908 if (apnHolder->IsDataCallEnabled()) {
909 return;
910 }
911 }
912 } else {
913 if (event->GetParam() == TYPE_REQUEST_NET) {
914 TELEPHONY_LOGD("not allow reqeust cellular data because of in controled");
915 return;
916 } else {
917 TELEPHONY_LOGI("release all cellular data");
918 apnHolder->ReleaseAllCellularData();
919 }
920 }
921 InnerEvent::Pointer innerEvent = InnerEvent::Get(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, id);
922 if (!SendEvent(innerEvent)) {
923 TELEPHONY_LOGE("Slot%{public}d: send data connection event failed", slotId_);
924 }
925 }
926
ProcessEvent(const InnerEvent::Pointer & event)927 void CellularDataHandler::ProcessEvent(const InnerEvent::Pointer &event)
928 {
929 if (event == nullptr) {
930 TELEPHONY_LOGE("Slot%{public}d: event is null!", slotId_);
931 return;
932 }
933 uint32_t eventCode = event->GetInnerEventId();
934 std::map<uint32_t, Fun>::iterator it = eventIdMap_.find(eventCode);
935 if (it != eventIdMap_.end()) {
936 it->second(event);
937 }
938 }
939
OnReceiveEvent(const EventFwk::CommonEventData & data)940 void CellularDataHandler::OnReceiveEvent(const EventFwk::CommonEventData &data)
941 {
942 const AAFwk::Want &want = data.GetWant();
943 std::string action = want.GetAction();
944 int32_t slotId = want.GetIntParam("slotId", 0);
945 TELEPHONY_LOGI("[slot%{public}d] action=%{public}s code=%{public}d", slotId_, action.c_str(), data.GetCode());
946 if (EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED == action) {
947 if (slotId_ != slotId) {
948 return;
949 }
950 int32_t state = want.GetIntParam("state", CALL_STATUS_UNKNOWN);
951 if (state == CALL_STATUS_UNKNOWN) {
952 TELEPHONY_LOGE("Slot%{public}d: unknown call state=%{public}d", slotId, state);
953 return;
954 }
955 HandleCallChanged(state);
956 } else if (action == CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED) {
957 HandleDefaultDataSubscriptionChanged();
958 } else if (action == CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED) {
959 if (slotId_ != slotId) {
960 return;
961 }
962 GetConfigurationFor5G();
963 } else if (action == CommonEventSupport::COMMON_EVENT_SCREEN_ON) {
964 if (slotId_ != slotId) {
965 return;
966 }
967 HandleScreenStateChanged(true);
968 } else if (action == CommonEventSupport::COMMON_EVENT_SCREEN_OFF) {
969 if (slotId_ != slotId) {
970 return;
971 }
972 HandleScreenStateChanged(false);
973 } else if (action == CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY) {
974 RegisterDataSettingObserver();
975 } else {
976 TELEPHONY_LOGI("Slot%{public}d: action=%{public}s code=%{public}d", slotId_, action.c_str(), data.GetCode());
977 }
978 }
979
HandleScreenStateChanged(bool isScreenOn) const980 void CellularDataHandler::HandleScreenStateChanged(bool isScreenOn) const
981 {
982 if (connectionManager_ == nullptr) {
983 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null!", slotId_);
984 return;
985 }
986 connectionManager_->HandleScreenStateChanged(isScreenOn);
987 }
988
HandleSettingSwitchChanged(const InnerEvent::Pointer & event)989 void CellularDataHandler::HandleSettingSwitchChanged(const InnerEvent::Pointer &event)
990 {
991 if (event == nullptr) {
992 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
993 return;
994 }
995 bool setting_switch = event->GetParam();
996 TELEPHONY_LOGI("Slot%{public}d: setting switch = %{public}d", slotId_, setting_switch);
997 }
998
HandleDBSettingIncallChanged(const AppExecFwk::InnerEvent::Pointer & event)999 void CellularDataHandler::HandleDBSettingIncallChanged(const AppExecFwk::InnerEvent::Pointer &event)
1000 {
1001 if (event == nullptr) {
1002 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1003 return;
1004 }
1005 if (incallDataStateMachine_ == nullptr) {
1006 TELEPHONY_LOGE("Slot%{public}d: incallDataStateMachine_ is null", slotId_);
1007 return;
1008 }
1009 int64_t value = event->GetParam();
1010 if (value == static_cast<int64_t>(DataSwitchCode::CELLULAR_DATA_ENABLED)) {
1011 InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_SETTINGS_ON);
1012 incallDataStateMachine_->SendEvent(incallEvent);
1013 } else {
1014 InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_SETTINGS_OFF);
1015 incallDataStateMachine_->SendEvent(incallEvent);
1016 }
1017 }
1018
CreateIncallDataStateMachine(int32_t callState)1019 std::shared_ptr<IncallDataStateMachine> CellularDataHandler::CreateIncallDataStateMachine(int32_t callState)
1020 {
1021 std::shared_ptr<IncallDataStateMachine> incallDataStateMachine = std::make_shared<IncallDataStateMachine>(slotId_,
1022 std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())), apnManager_);
1023 if (incallDataStateMachine == nullptr) {
1024 TELEPHONY_LOGE("Slot%{public}d: incallDataStateMachine is null", slotId_);
1025 return nullptr;
1026 }
1027 incallDataStateMachine->Init(callState);
1028 return incallDataStateMachine;
1029 }
1030
IncallDataComplete(const InnerEvent::Pointer & event)1031 void CellularDataHandler::IncallDataComplete(const InnerEvent::Pointer &event)
1032 {
1033 TELEPHONY_LOGI("Slot%{public}d: MSG_INCALL_DATA_COMPLETE", slotId_);
1034 if (incallDataStateMachine_ != nullptr) {
1035 incallDataStateMachine_ = nullptr;
1036 }
1037 }
1038
HandleCallChanged(int32_t state)1039 void CellularDataHandler::HandleCallChanged(int32_t state)
1040 {
1041 TELEPHONY_LOGI("Slot%{public}d: lastState:%{public}d, state:%{public}d", slotId_, lastCallState_, state);
1042 if (lastCallState_ == state) {
1043 TELEPHONY_LOGE("Slot%{public}d: call state=%{public}d, not changed", slotId_, state);
1044 return;
1045 }
1046 if (connectionManager_ == nullptr) {
1047 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null!", slotId_);
1048 return;
1049 }
1050 lastCallState_ = state;
1051 connectionManager_->UpdateCallState(state);
1052 ImsRegInfo voiceInfo;
1053 CoreManagerInner::GetInstance().GetImsRegStatus(slotId_, ImsServiceType::TYPE_VOICE, voiceInfo);
1054 ImsRegInfo videoInfo;
1055 CoreManagerInner::GetInstance().GetImsRegStatus(slotId_, ImsServiceType::TYPE_VIDEO, videoInfo);
1056 if (voiceInfo.imsRegState == ImsRegState::IMS_REGISTERED || videoInfo.imsRegState == ImsRegState::IMS_REGISTERED) {
1057 HandleImsCallChanged(state);
1058 } else {
1059 HandleVoiceCallChanged(state);
1060 }
1061 }
1062
HandleImsCallChanged(int32_t state)1063 void CellularDataHandler::HandleImsCallChanged(int32_t state)
1064 {
1065 if (state == TelCallStatus::CALL_STATUS_DIALING || state == TelCallStatus::CALL_STATUS_INCOMING) {
1066 if (incallDataStateMachine_ == nullptr) {
1067 incallDataStateMachine_ = CreateIncallDataStateMachine(state);
1068 }
1069 }
1070 if (incallDataStateMachine_ == nullptr) {
1071 TELEPHONY_LOGE("Slot%{public}d: incallDataStateMachine_ is null!", slotId_);
1072 return;
1073 }
1074 incallDataStateMachine_->UpdateCallState(state);
1075 if (state == TelCallStatus::CALL_STATUS_DIALING || state == TelCallStatus::CALL_STATUS_INCOMING) {
1076 InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_CALL_STARTED);
1077 incallDataStateMachine_->SendEvent(incallEvent);
1078 }
1079 if (state == TelCallStatus::CALL_STATUS_DISCONNECTED || state == TelCallStatus::CALL_STATUS_IDLE) {
1080 InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_CALL_ENDED);
1081 incallDataStateMachine_->SendEvent(incallEvent);
1082 }
1083 }
1084
HandleVoiceCallChanged(int32_t state)1085 void CellularDataHandler::HandleVoiceCallChanged(int32_t state)
1086 {
1087 if (apnManager_ == nullptr || connectionManager_ == nullptr) {
1088 TELEPHONY_LOGE("Slot%{public}d: apnManager or connectionManager is null!", slotId_);
1089 return;
1090 }
1091 // next to check if radio technology support voice and data at same time.
1092 int32_t psRadioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
1093 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, psRadioTech);
1094 bool support = (psRadioTech == static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_GSM));
1095 if (state != TelCallStatus::CALL_STATUS_IDLE && state != TelCallStatus::CALL_STATUS_DISCONNECTED) {
1096 if (apnManager_->HasAnyConnectedState() && support) {
1097 connectionManager_->EndNetStatistics();
1098 connectionManager_->SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_DORMANT);
1099 connectionManager_->StopStallDetectionTimer();
1100 disconnectionReason_ = DisConnectionReason::REASON_GSM_AND_CALLING_ONLY;
1101 }
1102 } else {
1103 if (apnManager_->HasAnyConnectedState() && support) {
1104 connectionManager_->StartStallDetectionTimer();
1105 connectionManager_->BeginNetStatistics();
1106 }
1107 disconnectionReason_ = DisConnectionReason::REASON_NORMAL;
1108 TELEPHONY_LOGI("Slot%{public}d: HandleVoiceCallChanged EstablishAllApnsIfConnectable", slotId_);
1109 EstablishAllApnsIfConnectable();
1110 }
1111 TELEPHONY_LOGI("Slot%{public}d: disconnectionReason_=%{public}d", slotId_, disconnectionReason_);
1112 }
1113
HandleDefaultDataSubscriptionChanged()1114 void CellularDataHandler::HandleDefaultDataSubscriptionChanged()
1115 {
1116 TELEPHONY_LOGI("Slot%{public}d", slotId_);
1117 if (CheckDataPermittedByDsds()) {
1118 SetDataPermitted(slotId_, true);
1119 } else {
1120 SetDataPermitted(slotId_, false);
1121 }
1122 if (dataSwitchSettings_ != nullptr) {
1123 dataSwitchSettings_->LoadSwitchValue();
1124 }
1125 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1126 const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
1127 if (defSlotId == slotId_) {
1128 EstablishAllApnsIfConnectable();
1129 } else {
1130 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1131 }
1132 }
1133
ReleaseAllNetworkRequest()1134 void CellularDataHandler::ReleaseAllNetworkRequest()
1135 {
1136 if (apnManager_ == nullptr) {
1137 TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1138 return;
1139 }
1140 for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1141 if (apnHolder == nullptr) {
1142 continue;
1143 }
1144 apnHolder->ReleaseAllCellularData();
1145 }
1146 }
1147
HandleSimStateChanged()1148 void CellularDataHandler::HandleSimStateChanged()
1149 {
1150 SimState simState = SimState::SIM_STATE_UNKNOWN;
1151 CoreManagerInner::GetInstance().GetSimState(slotId_, simState);
1152 TELEPHONY_LOGI("Slot%{public}d: sim state is :%{public}d", slotId_, simState);
1153 if (simState != SimState::SIM_STATE_READY) {
1154 isSimAccountLoaded_ = false;
1155 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1156 if (simState == SimState::SIM_STATE_NOT_PRESENT) {
1157 CellularDataNetAgent::GetInstance().UnregisterNetSupplierForSimUpdate(slotId_);
1158 ReleaseAllNetworkRequest();
1159 UnRegisterDataSettingObserver();
1160 }
1161 } else {
1162 std::u16string iccId;
1163 CoreManagerInner::GetInstance().GetSimIccId(slotId_, iccId);
1164 if (lastIccId_ != u"" && lastIccId_ == iccId) {
1165 EstablishAllApnsIfConnectable();
1166 }
1167 }
1168 }
1169
HandleSimStateOrRecordsChanged(const AppExecFwk::InnerEvent::Pointer & event)1170 void CellularDataHandler::HandleSimStateOrRecordsChanged(const AppExecFwk::InnerEvent::Pointer &event)
1171 {
1172 if (event == nullptr) {
1173 return;
1174 }
1175 if (dataSwitchSettings_ != nullptr) {
1176 dataSwitchSettings_->LoadSwitchValue();
1177 }
1178 switch (event->GetInnerEventId()) {
1179 case RadioEvent::RADIO_SIM_STATE_CHANGE: {
1180 HandleSimStateChanged();
1181 break;
1182 }
1183 case RadioEvent::RADIO_SIM_RECORDS_LOADED: {
1184 std::u16string iccId;
1185 CoreManagerInner::GetInstance().GetSimIccId(slotId_, iccId);
1186 SimState simState = SimState::SIM_STATE_UNKNOWN;
1187 CoreManagerInner::GetInstance().GetSimState(slotId_, simState);
1188 if (simState != SimState::SIM_STATE_READY || iccId == u"") {
1189 TELEPHONY_LOGI("sim state error or iccId nullptr");
1190 break;
1191 }
1192 if (iccId != lastIccId_) {
1193 if (dataSwitchSettings_ != nullptr) {
1194 dataSwitchSettings_->SetPolicyDataOn(true);
1195 }
1196 lastIccId_ = iccId;
1197 } else if (lastIccId_ == iccId) {
1198 TELEPHONY_LOGI("Slot%{public}d: sim state changed, but iccId not changed.", slotId_);
1199 // the sim card status has changed to ready, so try to connect
1200 EstablishAllApnsIfConnectable();
1201 }
1202 break;
1203 }
1204 default:
1205 break;
1206 }
1207 }
1208
HandleSimAccountLoaded(const InnerEvent::Pointer & event)1209 void CellularDataHandler::HandleSimAccountLoaded(const InnerEvent::Pointer &event)
1210 {
1211 if (event == nullptr) {
1212 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1213 return;
1214 }
1215 TELEPHONY_LOGI("Slot%{public}d", slotId_);
1216 if (isSimAccountLoaded_) {
1217 TELEPHONY_LOGE("Slot%{public}d has already loaded", slotId_);
1218 return;
1219 }
1220 auto slotId = event->GetParam();
1221 if (slotId == slotId_) {
1222 isSimAccountLoaded_ = true;
1223 ReleaseAllNetworkRequest();
1224 ClearAllConnections(DisConnectionReason::REASON_CHANGE_CONNECTION);
1225 CellularDataNetAgent::GetInstance().UnregisterNetSupplierForSimUpdate(slotId_);
1226 if (!CellularDataNetAgent::GetInstance().RegisterNetSupplier(slotId_)) {
1227 TELEPHONY_LOGE("Slot%{public}d register supplierid fail", slotId_);
1228 isSimAccountLoaded_ = false;
1229 }
1230 if (slotId_ == 0) {
1231 CellularDataNetAgent::GetInstance().UnregisterPolicyCallback();
1232 CellularDataNetAgent::GetInstance().RegisterPolicyCallback();
1233 }
1234 RegisterDataSettingObserver();
1235 if (dataSwitchSettings_ != nullptr) {
1236 dataSwitchSettings_->LoadSwitchValue();
1237 }
1238 GetConfigurationFor5G();
1239 CreateApnItem();
1240 }
1241 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1242 const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
1243 if (defSlotId == slotId_) {
1244 EstablishAllApnsIfConnectable();
1245 } else {
1246 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1247 }
1248 }
1249
CreateApnItem()1250 void CellularDataHandler::CreateApnItem()
1251 {
1252 if (apnManager_ == nullptr) {
1253 TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1254 return;
1255 }
1256 int32_t result = 0;
1257 for (int32_t i = 0; i < DEFAULT_READ_APN_TIME; ++i) {
1258 result = apnManager_->CreateAllApnItemByDatabase(slotId_);
1259 if (result != 0) {
1260 break;
1261 }
1262 }
1263 if (result == 0) {
1264 apnManager_->CreateAllApnItem();
1265 }
1266 SetRilAttachApn();
1267 }
1268
HandleApnChanged()1269 bool CellularDataHandler::HandleApnChanged()
1270 {
1271 if (apnManager_ == nullptr) {
1272 TELEPHONY_LOGE("apnManager is null");
1273 return false;
1274 }
1275 for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1276 TELEPHONY_LOGI("Slot%{public}d: apn type:%{public}s state:%{public}d", slotId_, apnHolder->GetApnType().c_str(),
1277 apnHolder->GetApnState());
1278 }
1279 InnerEvent::Pointer event = InnerEvent::Get(CellularDataEventCode::MSG_APN_CHANGED);
1280 if (event == nullptr) {
1281 TELEPHONY_LOGE("Slot%{public}d: get apn changed event is null", slotId_);
1282 return false;
1283 }
1284 return SendEvent(event);
1285 }
1286
HandleApnChanged(const InnerEvent::Pointer & event)1287 void CellularDataHandler::HandleApnChanged(const InnerEvent::Pointer &event)
1288 {
1289 if (apnManager_ == nullptr) {
1290 TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1291 return;
1292 }
1293 CreateApnItem();
1294 ApnProfileState apnState = apnManager_->GetOverallApnState();
1295 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING || apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
1296 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
1297 }
1298 for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1299 if (apnHolder == nullptr) {
1300 continue;
1301 }
1302 int32_t id = apnManager_->FindApnIdByApnName(apnHolder->GetApnType());
1303 SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, id, ESTABLISH_DATA_CONNECTION_DELAY);
1304 }
1305 }
1306
GetCellularDataFlowType()1307 int32_t CellularDataHandler::GetCellularDataFlowType()
1308 {
1309 if (connectionManager_ == nullptr) {
1310 TELEPHONY_LOGE("Slot%{public}d: connection manager is null", slotId_);
1311 return 0;
1312 }
1313 return connectionManager_->GetDataFlowType();
1314 }
1315
HandleRadioStateChanged(const AppExecFwk::InnerEvent::Pointer & event)1316 void CellularDataHandler::HandleRadioStateChanged(const AppExecFwk::InnerEvent::Pointer &event)
1317 {
1318 if (apnManager_ == nullptr || event == nullptr) {
1319 TELEPHONY_LOGE("Slot%{public}d: radio off or not available apnManager or event is null!", slotId_);
1320 return;
1321 }
1322 std::shared_ptr<Int32Parcel> object = event->GetSharedObject<Int32Parcel>();
1323 if (object == nullptr) {
1324 TELEPHONY_LOGE("Slot%{public}d: object is nullptr!", slotId_);
1325 return;
1326 }
1327 TELEPHONY_LOGI("Slot%{public}d: Radio changed with state: %{public}d", slotId_, object->data);
1328 switch (object->data) {
1329 case CORE_SERVICE_POWER_OFF:
1330 case CORE_SERVICE_POWER_NOT_AVAILABLE: {
1331 ApnProfileState apnState = apnManager_->GetOverallApnState();
1332 TELEPHONY_LOGI("Slot%{public}d: apn state is %{public}d", slotId_, apnState);
1333 if (apnState != ApnProfileState::PROFILE_STATE_IDLE) {
1334 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1335 }
1336 break;
1337 }
1338 case CORE_SERVICE_POWER_ON:
1339 SetRilLinkBandwidths();
1340 EstablishAllApnsIfConnectable();
1341 break;
1342 default:
1343 TELEPHONY_LOGI("Slot%{public}d: un-handle state:%{public}d", slotId_, object->data);
1344 break;
1345 }
1346 }
1347
HandleDsdsModeChanged(const AppExecFwk::InnerEvent::Pointer & event)1348 void CellularDataHandler::HandleDsdsModeChanged(const AppExecFwk::InnerEvent::Pointer &event)
1349 {
1350 if (event == nullptr) {
1351 TELEPHONY_LOGE("Slot%{public}d: event is null!", slotId_);
1352 return;
1353 }
1354 std::shared_ptr<Int32Parcel> object = event->GetSharedObject<Int32Parcel>();
1355 if (object == nullptr) {
1356 TELEPHONY_LOGE("Slot%{public}d: object is null!", slotId_);
1357 return;
1358 }
1359 TELEPHONY_LOGI("Slot%{public}d: DSDS changed with mode: %{public}d", slotId_, object->data);
1360 int32_t dsdsMode = DSDS_MODE_V2;
1361 CoreManagerInner::GetInstance().GetDsdsMode(dsdsMode);
1362 if (object->data == dsdsMode) {
1363 TELEPHONY_LOGE("Slot%{public}d: DSDS mode is the same!", slotId_);
1364 return;
1365 }
1366 if (object->data < DSDS_MODE_V2) {
1367 TELEPHONY_LOGE("Slot%{public}d: DSDS mode is illegal!", slotId_);
1368 return;
1369 }
1370 CoreManagerInner::GetInstance().SetDsdsMode(object->data);
1371 int32_t defaultSlotId = CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
1372 int32_t simNum = CoreManagerInner::GetInstance().GetMaxSimCount();
1373 bool dataEnableStatus = true;
1374 IsCellularDataEnabled(dataEnableStatus);
1375 for (int32_t i = 0; i < simNum; ++i) {
1376 if (defaultSlotId != i && object->data == DSDS_MODE_V2) {
1377 SetDataPermitted(i, false);
1378 } else {
1379 if (dataEnableStatus) {
1380 SetDataPermitted(i, true);
1381 }
1382 DelayedRefSingleton<CellularDataService>::GetInstance().ChangeConnectionForDsds(i, true);
1383 }
1384 }
1385 if (incallDataStateMachine_ != nullptr) {
1386 InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DSDS_CHANGED);
1387 incallDataStateMachine_->SendEvent(incallEvent);
1388 }
1389 }
1390
ClearConnectionIfRequired()1391 void CellularDataHandler::ClearConnectionIfRequired()
1392 {
1393 if (apnManager_ == nullptr) {
1394 TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1395 return;
1396 }
1397 for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1398 if (apnHolder == nullptr) {
1399 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
1400 continue;
1401 }
1402 ApnProfileState apnState = apnHolder->GetApnState();
1403 std::string apnType = apnHolder->GetApnType();
1404 std::vector<sptr<ApnItem>> matchedApns = apnManager_->FilterMatchedApns(apnType, slotId_);
1405 if (matchedApns.empty()) {
1406 TELEPHONY_LOGE("Slot%{public}d: matchedApns is empty", slotId_);
1407 continue;
1408 }
1409 bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0;
1410 if (!apnHolder->IsSameMatchedApns(matchedApns, roamingState)) {
1411 apnHolder->SetAllMatchedApns(matchedApns);
1412 if (apnState != ApnProfileState::PROFILE_STATE_IDLE &&
1413 apnState != ApnProfileState::PROFILE_STATE_FAILED) {
1414 TELEPHONY_LOGI("Slot%{public}d: the connection of APN type:%{public}s will be cleared.",
1415 slotId_, apnType.c_str());
1416 ClearConnection(apnHolder, DisConnectionReason::REASON_RETRY_CONNECTION);
1417 }
1418 }
1419 }
1420 if (connectionManager_ == nullptr) {
1421 TELEPHONY_LOGE("Slot%{public}d: connectionManager_ is null", slotId_);
1422 return;
1423 }
1424 if (!apnManager_->HasAnyConnectedState()) {
1425 connectionManager_->StopStallDetectionTimer();
1426 connectionManager_->EndNetStatistics();
1427 ResetDataFlowType();
1428 }
1429 }
1430
PsDataRatChanged(const InnerEvent::Pointer & event)1431 void CellularDataHandler::PsDataRatChanged(const InnerEvent::Pointer &event)
1432 {
1433 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1434 int32_t radioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
1435 coreInner.GetPsRadioTech(slotId_, radioTech);
1436 TELEPHONY_LOGI("Slot%{public}d: radioTech is %{public}d", slotId_, radioTech);
1437 if (event == nullptr) {
1438 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1439 return;
1440 }
1441 bool dataEnabled = dataSwitchSettings_->IsUserDataOn();
1442 if (!dataEnabled) {
1443 TELEPHONY_LOGE("Slot%{public}d: data enable is close", slotId_);
1444 return;
1445 }
1446 bool attached = coreInner.GetPsRegState(slotId_) == (int32_t)RegServiceState::REG_STATE_IN_SERVICE;
1447 if (!attached) {
1448 TELEPHONY_LOGE("Slot%{public}d: attached is false", slotId_);
1449 return;
1450 }
1451 ClearConnectionIfRequired();
1452 EstablishAllApnsIfConnectable();
1453 }
1454
SetPolicyDataOn(bool enable)1455 void CellularDataHandler::SetPolicyDataOn(bool enable)
1456 {
1457 if (dataSwitchSettings_ == nullptr) {
1458 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings is null", slotId_);
1459 return;
1460 }
1461 bool policyDataOn = dataSwitchSettings_->IsPolicyDataOn();
1462 if (policyDataOn != enable) {
1463 dataSwitchSettings_->SetPolicyDataOn(enable);
1464 if (enable) {
1465 EstablishAllApnsIfConnectable();
1466 } else {
1467 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1468 }
1469 }
1470 }
1471
IsRestrictedMode() const1472 bool CellularDataHandler::IsRestrictedMode() const
1473 {
1474 int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
1475 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
1476 bool support = (networkType == (int32_t)RadioTech::RADIO_TECHNOLOGY_GSM);
1477 bool inCall = (lastCallState_ != TelCallStatus::CALL_STATUS_IDLE &&
1478 lastCallState_ != TelCallStatus::CALL_STATUS_DISCONNECTED);
1479 TELEPHONY_LOGD("Slot%{public}d: radio technology is gsm only:%{public}d and call is busy:%{public}d", slotId_,
1480 support, inCall);
1481 return inCall && support;
1482 }
1483
GetDisConnectionReason()1484 DisConnectionReason CellularDataHandler::GetDisConnectionReason()
1485 {
1486 return disconnectionReason_;
1487 }
1488
SetDataPermitted(int32_t slotId,bool dataPermitted)1489 void CellularDataHandler::SetDataPermitted(int32_t slotId, bool dataPermitted)
1490 {
1491 TELEPHONY_LOGI("Slot%{public}d: dataPermitted is %{public}d.", slotId, dataPermitted);
1492 int32_t maxSimCount = CoreManagerInner::GetInstance().GetMaxSimCount();
1493 if (maxSimCount <= 1) {
1494 TELEPHONY_LOGE("Slot%{public}d: maxSimCount is: %{public}d", slotId_, maxSimCount);
1495 return;
1496 }
1497 bool hasSimCard = false;
1498 CoreManagerInner::GetInstance().HasSimCard(slotId, hasSimCard);
1499 if (!hasSimCard && !IsVSimSlotId(slotId)) {
1500 TELEPHONY_LOGE("Slot%{public}d: no sim :%{public}d", slotId_, slotId);
1501 return;
1502 }
1503 CoreManagerInner::GetInstance().SetDataPermitted(
1504 slotId, CellularDataEventCode::MSG_SET_DATA_PERMITTED, dataPermitted, shared_from_this());
1505 }
1506
SetDataPermittedResponse(const AppExecFwk::InnerEvent::Pointer & event)1507 void CellularDataHandler::SetDataPermittedResponse(const AppExecFwk::InnerEvent::Pointer &event)
1508 {
1509 if (event == nullptr) {
1510 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1511 return;
1512 }
1513 std::shared_ptr<TelRilResponseInfo<int32_t>> rilInfo = event->GetSharedObject<TelRilResponseInfo<int32_t>>();
1514 if (rilInfo == nullptr) {
1515 TELEPHONY_LOGE("Slot%{public}d: RadioResponseInfo is null", slotId_);
1516 return;
1517 }
1518 if (rilInfo->errorNo != 0) {
1519 TELEPHONY_LOGE("Slot%{public}d: SetDataPermitted error", slotId_);
1520 }
1521 }
1522
GetEsmFlagFromOpCfg()1523 bool CellularDataHandler::GetEsmFlagFromOpCfg()
1524 {
1525 int32_t esmFlagFromOpCfg = ESM_FLAG_INVALID;
1526 OperatorConfig configsForEsmFlag;
1527 CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForEsmFlag);
1528 if (configsForEsmFlag.intValue.find(KEY_PLMN_ESM_FLAG_INT) != configsForEsmFlag.intValue.end()) {
1529 esmFlagFromOpCfg = configsForEsmFlag.intValue[KEY_PLMN_ESM_FLAG_INT];
1530 }
1531 if (esmFlagFromOpCfg < 0 || esmFlagFromOpCfg > 1) {
1532 TELEPHONY_LOGE("esmFlag value is invalid");
1533 }
1534 return (esmFlagFromOpCfg != 0);
1535 }
1536
SetInitApnWithNullDp()1537 void CellularDataHandler::SetInitApnWithNullDp()
1538 {
1539 DataProfile dataProfile;
1540 dataProfile.profileId = 0;
1541 dataProfile.apn = "";
1542 dataProfile.protocol = "";
1543 dataProfile.verType = 0;
1544 dataProfile.userName = "";
1545 dataProfile.password = "";
1546 dataProfile.roamingProtocol = "";
1547 CoreManagerInner::GetInstance().SetInitApnInfo(
1548 slotId_, CellularDataEventCode::MSG_SET_RIL_ATTACH_APN, dataProfile, shared_from_this());
1549 return;
1550 }
1551
SetRilAttachApn()1552 void CellularDataHandler::SetRilAttachApn()
1553 {
1554 sptr<ApnItem> attachApn = apnManager_->GetRilAttachApn();
1555 if (attachApn == nullptr) {
1556 TELEPHONY_LOGE("Slot%{public}d: attachApn is null", slotId_);
1557 return;
1558 }
1559 if (!GetEsmFlagFromOpCfg()) {
1560 SetInitApnWithNullDp();
1561 return;
1562 }
1563 DataProfile dataProfile;
1564 dataProfile.profileId = attachApn->attr_.profileId_;
1565 dataProfile.apn = attachApn->attr_.apn_;
1566 dataProfile.protocol = attachApn->attr_.protocol_;
1567 dataProfile.verType = attachApn->attr_.authType_;
1568 dataProfile.userName = attachApn->attr_.user_;
1569 dataProfile.password = attachApn->attr_.password_;
1570 dataProfile.roamingProtocol = attachApn->attr_.roamingProtocol_;
1571 TELEPHONY_LOGI("DataProfile profileId = %{public}d", dataProfile.profileId);
1572 CoreManagerInner::GetInstance().SetInitApnInfo(
1573 slotId_, CellularDataEventCode::MSG_SET_RIL_ATTACH_APN, dataProfile, shared_from_this());
1574 }
1575
SetRilAttachApnResponse(const AppExecFwk::InnerEvent::Pointer & event)1576 void CellularDataHandler::SetRilAttachApnResponse(const AppExecFwk::InnerEvent::Pointer &event)
1577 {
1578 if (event == nullptr) {
1579 TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1580 return;
1581 }
1582 std::shared_ptr<TelRilResponseInfo<int32_t>> rilInfo = event->GetSharedObject<TelRilResponseInfo<int32_t>>();
1583 if (rilInfo == nullptr) {
1584 TELEPHONY_LOGE("Slot%{public}d: RadioResponseInfo is null", slotId_);
1585 return;
1586 }
1587 if (rilInfo->errorNo != 0) {
1588 TELEPHONY_LOGE("Slot%{public}d: SetRilAttachApn error", slotId_);
1589 }
1590 }
1591
HasAnyHigherPriorityConnection(const sptr<ApnHolder> & apnHolder)1592 bool CellularDataHandler::HasAnyHigherPriorityConnection(const sptr<ApnHolder> &apnHolder)
1593 {
1594 if (apnManager_ == nullptr) {
1595 TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
1596 return false;
1597 }
1598 std::vector<sptr<ApnHolder>> sortApnHolders = apnManager_->GetSortApnHolder();
1599 if (sortApnHolders.empty()) {
1600 TELEPHONY_LOGE("Slot%{public}d: SortApnHolder is null", slotId_);
1601 return false;
1602 }
1603 for (const sptr<ApnHolder> &sortApnHolder : sortApnHolders) {
1604 if (sortApnHolder->GetPriority() > apnHolder->GetPriority()) {
1605 if (sortApnHolder->IsDataCallEnabled() &&
1606 (sortApnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTED ||
1607 sortApnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTING ||
1608 sortApnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_DISCONNECTING)) {
1609 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
1610 CellularDataErrorCode::DATA_ERROR_HAS_HIGHER_PRIORITY_CONNECTION,
1611 "There is higher priority connection");
1612 return true;
1613 }
1614 }
1615 }
1616 return false;
1617 }
1618
HasInternetCapability(const int32_t cid) const1619 bool CellularDataHandler::HasInternetCapability(const int32_t cid) const
1620 {
1621 if (connectionManager_ == nullptr) {
1622 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1623 return false;
1624 }
1625 std::shared_ptr<CellularDataStateMachine> activeStateMachine = connectionManager_->GetActiveConnectionByCid(cid);
1626 if (activeStateMachine == nullptr) {
1627 TELEPHONY_LOGE("Slot%{public}d: get activeStateMachine by cid fail", slotId_);
1628 return false;
1629 }
1630 uint64_t netCapability = activeStateMachine->GetCapability();
1631 if (netCapability == NetCap::NET_CAPABILITY_INTERNET) {
1632 return true;
1633 }
1634 return false;
1635 }
1636
ChangeConnectionForDsds(bool enable)1637 bool CellularDataHandler::ChangeConnectionForDsds(bool enable)
1638 {
1639 if (dataSwitchSettings_ == nullptr) {
1640 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
1641 return false;
1642 }
1643 if (enable) {
1644 dataSwitchSettings_->SetInternalDataOn(true);
1645 EstablishAllApnsIfConnectable();
1646 } else {
1647 dataSwitchSettings_->SetInternalDataOn(false);
1648 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1649 }
1650 return true;
1651 }
1652
GetConfigurationFor5G()1653 void CellularDataHandler::GetConfigurationFor5G()
1654 {
1655 // get 5G configurations
1656 unMeteredAllNsaConfig_ = ParseOperatorConfig(u"allmeterednas");
1657 unMeteredNrNsaMmwaveConfig_ = ParseOperatorConfig(u"meterednrnsammware");
1658 unMeteredNrNsaSub6Config_ = ParseOperatorConfig(u"meteredNrnsasub6");
1659 unMeteredAllNrsaConfig_ = ParseOperatorConfig(u"meteredallnrsa");
1660 unMeteredNrsaMmwaveConfig_ = ParseOperatorConfig(u"meterednrsammware");
1661 unMeteredNrsaSub6Config_ = ParseOperatorConfig(u"meterednrsasub6");
1662 unMeteredRoamingConfig_ = ParseOperatorConfig(u"meteredroaming");
1663 GetDefaultConfiguration();
1664 }
1665
ParseOperatorConfig(const std::u16string & configName)1666 bool CellularDataHandler::ParseOperatorConfig(const std::u16string &configName)
1667 {
1668 OperatorConfig configsFor5G;
1669 CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsFor5G);
1670 if (configsFor5G.configValue.count(configName) > 0) {
1671 std::string flag = Str16ToStr8(configsFor5G.configValue[configName]);
1672 TELEPHONY_LOGI("Slot%{public}d: parse operator 5G config: %{public}s", slotId_, flag.c_str());
1673 if (flag == "true") {
1674 return true;
1675 }
1676 }
1677 return false;
1678 }
1679
GetSinglePdpEnabledFromOpCfg()1680 void CellularDataHandler::GetSinglePdpEnabledFromOpCfg()
1681 {
1682 OperatorConfig configsForSinglePdp;
1683 CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForSinglePdp);
1684 if (configsForSinglePdp.boolValue.find(KEY_SINGLE_PDP_ENABLED_BOOL) != configsForSinglePdp.boolValue.end()) {
1685 multipleConnectionsEnabled_ = !configsForSinglePdp.boolValue[KEY_SINGLE_PDP_ENABLED_BOOL];
1686 }
1687 return;
1688 }
1689
IsSingleConnectionEnabled(int32_t radioTech)1690 bool CellularDataHandler::IsSingleConnectionEnabled(int32_t radioTech)
1691 {
1692 std::vector<int32_t> singlePdpRadio;
1693 OperatorConfig configsForSinglePdpRadioType;
1694 CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForSinglePdpRadioType);
1695 if (configsForSinglePdpRadioType.intArrayValue.count(KEY_SINGLE_PDP_RADIO_TYPE_INT_ARRAY) >0) {
1696 singlePdpRadio = configsForSinglePdpRadioType.intArrayValue[KEY_SINGLE_PDP_RADIO_TYPE_INT_ARRAY];
1697 }
1698 if (singlePdpRadio.empty()) {
1699 TELEPHONY_LOGI("single pdp radio type array is empty");
1700 }
1701 if (std::find(singlePdpRadio.begin(), singlePdpRadio.end(), radioTech) != singlePdpRadio.end()) {
1702 TELEPHONY_LOGI("radio type array is matched single pdp type");
1703 multipleConnectionsEnabled_ = false;
1704 return !multipleConnectionsEnabled_;
1705 }
1706 GetSinglePdpEnabledFromOpCfg();
1707 return !multipleConnectionsEnabled_;
1708 }
1709
GetDefaultDataRoamingConfig()1710 void CellularDataHandler::GetDefaultDataRoamingConfig()
1711 {
1712 defaultDataRoamingEnable_ = false;
1713 OperatorConfig configsForDataRoaming;
1714 CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForDataRoaming);
1715 if (configsForDataRoaming.boolValue.find(KEY_DEFAULT_DATA_ROAMING_BOOL) != configsForDataRoaming.boolValue.end()) {
1716 defaultDataRoamingEnable_ = configsForDataRoaming.boolValue[KEY_DEFAULT_DATA_ROAMING_BOOL];
1717 TELEPHONY_LOGI("Slot%{public}d: OperatorConfig defaultDataRoamingEnable_ = %{public}d", slotId_,
1718 defaultDataRoamingEnable_);
1719 } else {
1720 std::string defaultDataRoaming = DEFAULT_DATA_ROAMING + std::to_string(slotId_);
1721 int32_t dataRoaming = static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED);
1722 dataRoaming = GetIntParameter(defaultDataRoaming.c_str(), dataRoaming);
1723 defaultDataRoamingEnable_ =
1724 (dataRoaming == static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED));
1725 TELEPHONY_LOGI(
1726 "Slot%{public}d: defaultDataRoamingEnable_ from prop is %{public}d", slotId_, defaultDataRoamingEnable_);
1727 }
1728 if (dataSwitchSettings_ == nullptr) {
1729 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null", slotId_);
1730 return;
1731 }
1732 bool dataRoamingEnabled = false;
1733 int32_t ret = dataSwitchSettings_->QueryUserDataRoamingStatus(dataRoamingEnabled);
1734 if (ret != TELEPHONY_ERR_SUCCESS && defaultDataRoamingEnable_ != dataSwitchSettings_->IsUserDataRoamingOn()) {
1735 dataSwitchSettings_->UpdateUserDataRoamingOn(defaultDataRoamingEnable_);
1736 if (apnManager_ == nullptr) {
1737 TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1738 return;
1739 }
1740 bool roamingState = false;
1741 if (CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0) {
1742 roamingState = true;
1743 }
1744 if (roamingState) {
1745 ApnProfileState apnState = apnManager_->GetOverallApnState();
1746 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
1747 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
1748 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
1749 }
1750 EstablishAllApnsIfConnectable();
1751 } else {
1752 TELEPHONY_LOGI("Slot%{public}d: Not roaming(%{public}d), not doing anything", slotId_, roamingState);
1753 }
1754 }
1755 }
1756
GetDefaultConfiguration()1757 void CellularDataHandler::GetDefaultConfiguration()
1758 {
1759 if (connectionManager_ == nullptr) {
1760 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1761 return;
1762 }
1763 connectionManager_->GetDefaultBandWidthsConfig();
1764 connectionManager_->GetDefaultTcpBufferConfig();
1765 GetDefaultUpLinkThresholdsConfig();
1766 GetDefaultDownLinkThresholdsConfig();
1767 defaultMobileMtuConfig_ = CellularDataUtils::GetDefaultMobileMtuConfig();
1768 TELEPHONY_LOGI("Slot%{public}d: defaultMobileMtuConfig_ = %{public}d", slotId_, defaultMobileMtuConfig_);
1769 defaultPreferApn_ = CellularDataUtils::GetDefaultPreferApnConfig();
1770 TELEPHONY_LOGI("Slot%{public}d: defaultPreferApn_ is %{public}d", slotId_, defaultPreferApn_);
1771 multipleConnectionsEnabled_ = CellularDataUtils::GetDefaultMultipleConnectionsConfig();
1772 GetSinglePdpEnabledFromOpCfg();
1773 GetDefaultDataRoamingConfig();
1774 TELEPHONY_LOGI("Slot%{public}d: multipleConnectionsEnabled_ = %{public}d, defaultDataRoamingEnable_ = %{public}d",
1775 slotId_, multipleConnectionsEnabled_, defaultDataRoamingEnable_);
1776 }
1777
HandleRadioNrStateChanged(const AppExecFwk::InnerEvent::Pointer & event)1778 void CellularDataHandler::HandleRadioNrStateChanged(const AppExecFwk::InnerEvent::Pointer &event)
1779 {
1780 if (connectionManager_ == nullptr) {
1781 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1782 return;
1783 }
1784 TELEPHONY_LOGI("Slot%{public}d: receive event", slotId_);
1785 std::vector<std::shared_ptr<CellularDataStateMachine>> stateMachines =
1786 connectionManager_->GetAllConnectionMachine();
1787 for (const std::shared_ptr<CellularDataStateMachine> &cellularDataStateMachine : stateMachines) {
1788 InnerEvent::Pointer eventCode = InnerEvent::Get(RadioEvent::RADIO_NR_STATE_CHANGED);
1789 cellularDataStateMachine->SendEvent(eventCode);
1790 }
1791 }
1792
HandleRadioNrFrequencyChanged(const AppExecFwk::InnerEvent::Pointer & event)1793 void CellularDataHandler::HandleRadioNrFrequencyChanged(const AppExecFwk::InnerEvent::Pointer &event)
1794 {
1795 if (connectionManager_ == nullptr) {
1796 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1797 return;
1798 }
1799 TELEPHONY_LOGI("Slot%{public}d: receive event", slotId_);
1800 std::vector<std::shared_ptr<CellularDataStateMachine>> stateMachines =
1801 connectionManager_->GetAllConnectionMachine();
1802 for (const std::shared_ptr<CellularDataStateMachine> &cellularDataStateMachine : stateMachines) {
1803 InnerEvent::Pointer eventCode = InnerEvent::Get(RadioEvent::RADIO_NR_FREQUENCY_CHANGED);
1804 cellularDataStateMachine->SendEvent(eventCode);
1805 }
1806 }
1807
GetDefaultUpLinkThresholdsConfig()1808 void CellularDataHandler::GetDefaultUpLinkThresholdsConfig()
1809 {
1810 upLinkThresholds_.clear();
1811 char upLinkConfig[UP_DOWN_LINK_SIZE] = { 0 };
1812 GetParameter(CONFIG_UPLINK_THRESHOLDS, CAPACITY_THRESHOLDS_FOR_UPLINK, upLinkConfig, UP_DOWN_LINK_SIZE);
1813 TELEPHONY_LOGI("Slot%{public}d: upLinkThresholds = %{public}s", slotId_, upLinkConfig);
1814 upLinkThresholds_ = CellularDataUtils::Split(upLinkConfig, ",");
1815 }
1816
GetDefaultDownLinkThresholdsConfig()1817 void CellularDataHandler::GetDefaultDownLinkThresholdsConfig()
1818 {
1819 downLinkThresholds_.clear();
1820 char downLinkConfig[UP_DOWN_LINK_SIZE] = { 0 };
1821 GetParameter(CONFIG_DOWNLINK_THRESHOLDS, CAPACITY_THRESHOLDS_FOR_DOWNLINK, downLinkConfig, UP_DOWN_LINK_SIZE);
1822 TELEPHONY_LOGI("Slot%{public}d: downLinkThresholds_ = %{public}s", slotId_, downLinkConfig);
1823 downLinkThresholds_ = CellularDataUtils::Split(downLinkConfig, ",");
1824 }
1825
SetRilLinkBandwidths()1826 void CellularDataHandler::SetRilLinkBandwidths()
1827 {
1828 LinkBandwidthRule linkBandwidth;
1829 CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, linkBandwidth.rat);
1830 linkBandwidth.delayMs = DELAY_SET_RIL_BANDWIDTH_MS;
1831 linkBandwidth.delayUplinkKbps = DELAY_SET_RIL_UP_DOWN_BANDWIDTH_MS;
1832 linkBandwidth.delayDownlinkKbps = DELAY_SET_RIL_UP_DOWN_BANDWIDTH_MS;
1833 for (std::string upLinkThreshold : upLinkThresholds_) {
1834 linkBandwidth.maximumUplinkKbps.push_back(atoi(upLinkThreshold.c_str()));
1835 }
1836 for (std::string downLinkThreshold : downLinkThresholds_) {
1837 linkBandwidth.maximumDownlinkKbps.push_back(atoi(downLinkThreshold.c_str()));
1838 }
1839 CoreManagerInner::GetInstance().SetLinkBandwidthReportingRule(
1840 slotId_, CellularDataEventCode::MSG_SET_RIL_BANDWIDTH, linkBandwidth, shared_from_this());
1841 }
1842
HandleDBSettingEnableChanged(const AppExecFwk::InnerEvent::Pointer & event)1843 void CellularDataHandler::HandleDBSettingEnableChanged(const AppExecFwk::InnerEvent::Pointer &event)
1844 {
1845 if (dataSwitchSettings_ == nullptr) {
1846 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
1847 return;
1848 }
1849 bool dataEnabled = true;
1850 dataSwitchSettings_->QueryUserDataStatus(dataEnabled);
1851 CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1852 const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
1853 if (dataEnabled && defSlotId == slotId_) {
1854 EstablishAllApnsIfConnectable();
1855 } else {
1856 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1857 }
1858 }
1859
HandleDBSettingRoamingChanged(const AppExecFwk::InnerEvent::Pointer & event)1860 void CellularDataHandler::HandleDBSettingRoamingChanged(const AppExecFwk::InnerEvent::Pointer &event)
1861 {
1862 if (event == nullptr) {
1863 return;
1864 }
1865 if (dataSwitchSettings_ == nullptr || apnManager_ == nullptr) {
1866 TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ or apnManager_ is null", slotId_);
1867 return;
1868 }
1869 int64_t value = event->GetParam();
1870 bool dataRoamingEnabled = false;
1871 dataSwitchSettings_->QueryUserDataRoamingStatus(dataRoamingEnabled);
1872 if (dataRoamingEnabled != value) {
1873 dataSwitchSettings_->SetUserDataRoamingOn(value);
1874 bool roamingState = false;
1875 if (CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0) {
1876 roamingState = true;
1877 }
1878 if (roamingState) {
1879 ApnProfileState apnState = apnManager_->GetOverallApnState();
1880 if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
1881 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
1882 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
1883 }
1884 EstablishAllApnsIfConnectable();
1885 } else {
1886 TELEPHONY_LOGI("Slot%{public}d: Not roaming(%{public}d), not doing anything", slotId_, roamingState);
1887 }
1888 } else {
1889 TELEPHONY_LOGI("Slot%{public}d: The roaming switch status has not changed", slotId_);
1890 }
1891 }
1892
UnRegisterDataSettingObserver()1893 void CellularDataHandler::UnRegisterDataSettingObserver()
1894 {
1895 if (settingObserver_ == nullptr || roamingObserver_ == nullptr || incallObserver_ == nullptr ||
1896 cellularDataRdbObserver_ == nullptr) {
1897 TELEPHONY_LOGE("Slot%{public}d: settingObserver_ or roamingObserver_ or incallObserver_ or "
1898 "cellularDataRdbObserver_ is null", slotId_);
1899 return;
1900 }
1901 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
1902 if (settingHelper == nullptr) {
1903 TELEPHONY_LOGE("Slot%{public}d: settingHelper is null", slotId_);
1904 return;
1905 }
1906 Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
1907 settingHelper->UnRegisterSettingsObserver(dataEnableUri, settingObserver_);
1908
1909 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
1910 if (simId <= INVALID_SIM_ID) {
1911 TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
1912 return;
1913 }
1914 Uri dataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
1915 settingHelper->UnRegisterSettingsObserver(dataRoamingUri, roamingObserver_);
1916 Uri dataIncallUri(CELLULAR_DATA_SETTING_DATA_INCALL_URI);
1917 settingHelper->UnRegisterSettingsObserver(dataIncallUri, incallObserver_);
1918
1919 std::shared_ptr<CellularDataRdbHelper> cellularDataRdbHelper = CellularDataRdbHelper::GetInstance();
1920 if (cellularDataRdbHelper == nullptr) {
1921 TELEPHONY_LOGE("Slot%{public}d: cellularDataRdbHelper is null", slotId_);
1922 return;
1923 }
1924 cellularDataRdbHelper->UnRegisterObserver(cellularDataRdbObserver_);
1925 }
1926
RegisterDataSettingObserver()1927 void CellularDataHandler::RegisterDataSettingObserver()
1928 {
1929 if (settingObserver_ == nullptr || roamingObserver_ == nullptr || incallObserver_ == nullptr ||
1930 cellularDataRdbObserver_ == nullptr) {
1931 TELEPHONY_LOGE("Slot%{public}d: settingObserver_ or roamingObserver_ or incallObserver_ or "
1932 "cellularDataRdbObserver_ is null", slotId_);
1933 return;
1934 }
1935 std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
1936 if (settingHelper == nullptr) {
1937 TELEPHONY_LOGE("Slot%{public}d: settingHelper is null", slotId_);
1938 return;
1939 }
1940 Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
1941 settingHelper->RegisterSettingsObserver(dataEnableUri, settingObserver_);
1942
1943 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
1944 if (simId <= INVALID_SIM_ID) {
1945 TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
1946 return;
1947 }
1948 Uri dataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
1949 settingHelper->RegisterSettingsObserver(dataRoamingUri, roamingObserver_);
1950 Uri dataIncallUri(CELLULAR_DATA_SETTING_DATA_INCALL_URI);
1951 settingHelper->RegisterSettingsObserver(dataIncallUri, incallObserver_);
1952
1953 std::shared_ptr<CellularDataRdbHelper> cellularDataRdbHelper = CellularDataRdbHelper::GetInstance();
1954 if (cellularDataRdbHelper == nullptr) {
1955 TELEPHONY_LOGE("Slot%{public}d: cellularDataRdbHelper is null", slotId_);
1956 return;
1957 }
1958 cellularDataRdbHelper->RegisterObserver(cellularDataRdbObserver_);
1959 }
1960
OnRilAdapterHostDied(const AppExecFwk::InnerEvent::Pointer & event)1961 void CellularDataHandler::OnRilAdapterHostDied(const AppExecFwk::InnerEvent::Pointer &event)
1962 {
1963 if (connectionManager_ == nullptr) {
1964 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1965 return;
1966 }
1967 TELEPHONY_LOGI("Slot%{public}d: receive event", slotId_);
1968 std::vector<std::shared_ptr<CellularDataStateMachine>> stateMachines =
1969 connectionManager_->GetAllConnectionMachine();
1970 for (const std::shared_ptr<CellularDataStateMachine> &cellularDataStateMachine : stateMachines) {
1971 InnerEvent::Pointer eventCode = InnerEvent::Get(CellularDataEventCode::MSG_SM_RIL_ADAPTER_HOST_DIED);
1972 cellularDataStateMachine->SendEvent(eventCode);
1973 }
1974 }
1975
GetDataConnApnAttr(ApnItem::Attribute & apnAttr) const1976 void CellularDataHandler::GetDataConnApnAttr(ApnItem::Attribute &apnAttr) const
1977 {
1978 if (apnManager_ == nullptr) {
1979 TELEPHONY_LOGE("Slot%{public}d: GetDataConnApnAttr:apnManager is null", slotId_);
1980 return;
1981 }
1982 for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1983 if (apnHolder == nullptr) {
1984 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
1985 continue;
1986 }
1987 if (apnHolder->IsDataCallEnabled()) {
1988 sptr<ApnItem> apnItem = apnHolder->GetCurrentApn();
1989 if (apnItem == nullptr) {
1990 continue;
1991 }
1992 apnAttr = apnItem->attr_;
1993 return;
1994 }
1995 }
1996 }
1997
GetDataConnIpType() const1998 std::string CellularDataHandler::GetDataConnIpType() const
1999 {
2000 if (apnManager_ == nullptr) {
2001 TELEPHONY_LOGE("Slot%{public}d: GetDataConnApnAttr:apnManager is null", slotId_);
2002 return "";
2003 }
2004 for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
2005 if (apnHolder == nullptr) {
2006 TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
2007 continue;
2008 }
2009 if (apnHolder->IsDataCallEnabled()) {
2010 auto stateMachine = apnHolder->GetCellularDataStateMachine();
2011 if (stateMachine == nullptr) {
2012 TELEPHONY_LOGE("Slot%{public}d: stateMachine is null", slotId_);
2013 continue;
2014 }
2015 return stateMachine->GetIpType();
2016 }
2017 }
2018 return "";
2019 }
2020
GetDataRecoveryState()2021 int32_t CellularDataHandler::GetDataRecoveryState()
2022 {
2023 if (connectionManager_ == nullptr) {
2024 TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
2025 return -1;
2026 }
2027 return connectionManager_->GetDataRecoveryState();
2028 }
2029
HandleFactoryReset(const InnerEvent::Pointer & event)2030 void CellularDataHandler::HandleFactoryReset(const InnerEvent::Pointer &event)
2031 {
2032 TELEPHONY_LOGI("Slot%{public}d: factory reset", slotId_);
2033 SetCellularDataEnable(true);
2034 SetCellularDataRoamingEnabled(defaultDataRoamingEnable_);
2035 if (apnManager_ == nullptr) {
2036 TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
2037 return;
2038 }
2039 apnManager_->ResetApns(slotId_);
2040 }
2041
IsNeedDoRecovery(bool needDoRecovery) const2042 void CellularDataHandler::IsNeedDoRecovery(bool needDoRecovery) const
2043 {
2044 if (connectionManager_ == nullptr) {
2045 TELEPHONY_LOGE("Slot%{public}d: in IsNeedDoRecovery connectionManager_ is null", slotId_);
2046 return;
2047 }
2048 connectionManager_->IsNeedDoRecovery(needDoRecovery);
2049 }
2050
OnCleanAllDataConnectionsDone(const AppExecFwk::InnerEvent::Pointer & event)2051 void CellularDataHandler::OnCleanAllDataConnectionsDone(const AppExecFwk::InnerEvent::Pointer &event)
2052 {
2053 TELEPHONY_LOGI("Slot%{public}d: receive OnCleanAllDataConnectionsDone event", slotId_);
2054 }
2055
IsVSimSlotId(int32_t slotId)2056 bool CellularDataHandler::IsVSimSlotId(int32_t slotId)
2057 {
2058 if (TELEPHONY_EXT_WRAPPER.getVSimSlotId_) {
2059 int vSimSlotId = INVALID_SLOT_ID;
2060 TELEPHONY_EXT_WRAPPER.getVSimSlotId_(vSimSlotId);
2061 return vSimSlotId == slotId;
2062 }
2063 return false;
2064 }
2065
CheckForCompatibleDataConnection(sptr<ApnHolder> & apnHolder)2066 std::shared_ptr<CellularDataStateMachine> CellularDataHandler::CheckForCompatibleDataConnection(
2067 sptr<ApnHolder> &apnHolder)
2068 {
2069 std::shared_ptr<CellularDataStateMachine> potentialDc = nullptr;
2070 if (apnHolder == nullptr || apnManager_ == nullptr) {
2071 TELEPHONY_LOGE("Slot%{public}d: CheckForCompatibleDataConnection failed, apnHolder or apnManager_null",
2072 slotId_);
2073 return potentialDc;
2074 }
2075 std::vector<sptr<ApnItem>> dunApnList;
2076 if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DUN) {
2077 apnManager_->FetchDunApns(dunApnList, slotId_);
2078 }
2079 if (dunApnList.size() == 0) {
2080 return potentialDc;
2081 }
2082 if (connectionManager_ == nullptr) {
2083 return potentialDc;
2084 }
2085 auto allDCs = connectionManager_->GetAllConnectionMachine();
2086 bool isRoaming = false;
2087 int32_t result = IsCellularDataRoamingEnabled(isRoaming);
2088 if (result != TELEPHONY_ERR_SUCCESS) {
2089 isRoaming = false;
2090 }
2091 for(const auto& curDc : allDCs) {
2092 sptr<ApnItem> apnItem = curDc->GetApnItem();
2093 for(const auto& dunItem : dunApnList) {
2094 if (!apnHolder->IsCompatibleApnItem(apnItem, dunItem, isRoaming)) {
2095 continue;
2096 }
2097 if (curDc->IsActiveState()) {
2098 return curDc;
2099 } else if (curDc->IsActivatingState()) {
2100 potentialDc = curDc;
2101 } else if (curDc->IsDisconnectingState()) {
2102 if (potentialDc == nullptr) {
2103 potentialDc = curDc;
2104 }
2105 }
2106 }
2107 }
2108 return potentialDc;
2109 }
2110
IsGsm()2111 bool CellularDataHandler::IsGsm()
2112 {
2113 bool isGsm = false;
2114 CoreManagerInner::GetInstance().IsGsm(slotId_, isGsm);
2115 return isGsm;
2116 }
2117
IsCdma()2118 bool CellularDataHandler::IsCdma()
2119 {
2120 bool isCdma = false;
2121 CoreManagerInner::GetInstance().IsCdma(slotId_, isCdma);
2122 return isCdma;
2123 }
2124 } // namespace Telephony
2125 } // namespace OHOS
2126