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     int32_t profileId = GetCurrentApnId();
647     sptr<ApnItem> apnItem = apnManager_->GetApnItemById(profileId);
648     if (apnItem == nullptr) {
649         TELEPHONY_LOGD("profileId: %{public}d: apnItem is null", profileId);
650         apnItem = apnHolder->GetNextRetryApn();
651     }
652     if (apnItem == nullptr) {
653         TELEPHONY_LOGE("Slot%{public}d: apnItem is null", slotId_);
654         return false;
655     }
656     std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine = nullptr;
657     if (apnHolder->GetApnType() != DATA_CONTEXT_ROLE_DUN) {
658         cellularDataStateMachine = CheckForCompatibleDataConnection(apnHolder);
659         if (cellularDataStateMachine != nullptr) {
660             sptr<ApnItem> dcApnItem = cellularDataStateMachine->GetApnItem();
661             if (dcApnItem != nullptr) {
662                 apnItem = dcApnItem;
663             }
664         }
665     }
666     if (cellularDataStateMachine == nullptr) {
667         if (IsSingleConnectionEnabled(radioTech)) {
668             if (HasAnyHigherPriorityConnection(apnHolder)) {
669                 TELEPHONY_LOGE("Slot%{public}d: has higher priority connection", slotId_);
670                 return false;
671             }
672             ApnProfileState apnState = apnManager_->GetOverallApnState();
673             if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
674                 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
675                 ClearAllConnections(DisConnectionReason::REASON_CHANGE_CONNECTION);
676                 return false;
677             }
678         }
679         cellularDataStateMachine = FindIdleCellularDataConnection();
680         if (cellularDataStateMachine == nullptr) {
681             cellularDataStateMachine = CreateCellularDataConnect();
682             if (cellularDataStateMachine == nullptr) {
683                 TELEPHONY_LOGE("Slot%{public}d: cellularDataStateMachine is null", slotId_);
684                 return false;
685             }
686             cellularDataStateMachine->Init();
687             if (connectionManager_ == nullptr) {
688                 TELEPHONY_LOGE("Slot%{public}d: connectionManager_ is null", slotId_);
689                 return false;
690             }
691             connectionManager_->AddConnectionStateMachine(cellularDataStateMachine);
692         }
693     }
694     cellularDataStateMachine->SetCapability(apnHolder->GetCapability());
695     apnHolder->SetCurrentApn(apnItem);
696     apnHolder->SetApnState(PROFILE_STATE_CONNECTING);
697     apnHolder->SetCellularDataStateMachine(cellularDataStateMachine);
698     bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0;
699     bool userDataRoaming = dataSwitchSettings_->IsUserDataRoamingOn();
700     if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
701         apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
702         ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
703         StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, radioTech);
704     }
705     std::unique_ptr<DataConnectionParams> object = std::make_unique<DataConnectionParams>(
706         apnHolder, apnItem->attr_.profileId_, radioTech, roamingState, userDataRoaming, true);
707     TELEPHONY_LOGI("Slot%{public}d: MSG_SM_CONNECT profileId:%{public}d type:%{public}s networkType:%{public}d",
708         slotId_, apnItem->attr_.profileId_, apnHolder->GetApnType().c_str(), radioTech);
709     InnerEvent::Pointer event = InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, object);
710     if (event == nullptr) {
711         TELEPHONY_LOGE("event is null");
712         return false;
713     }
714     cellularDataStateMachine->SendEvent(event);
715     return true;
716 }
717 
EstablishDataConnectionComplete(const InnerEvent::Pointer & event)718 void CellularDataHandler::EstablishDataConnectionComplete(const InnerEvent::Pointer &event)
719 {
720     if (event == nullptr) {
721         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
722         return;
723     }
724     std::shared_ptr<SetupDataCallResultInfo> resultInfo = event->GetSharedObject<SetupDataCallResultInfo>();
725     if ((resultInfo != nullptr) && (apnManager_ != nullptr)) {
726         sptr<ApnHolder> apnHolder = apnManager_->GetApnHolder(apnManager_->FindApnNameByApnId(resultInfo->flag));
727         if (apnHolder == nullptr) {
728             TELEPHONY_LOGE("Slot%{public}d: flag:%{public}d complete apnHolder is null", slotId_, resultInfo->flag);
729             return;
730         }
731         apnHolder->SetApnState(PROFILE_STATE_CONNECTED);
732         apnHolder->InitialApnRetryCount();
733         std::shared_ptr<CellularDataStateMachine> stateMachine = apnHolder->GetCellularDataStateMachine();
734         if (stateMachine != nullptr) {
735             std::string proxyIpAddress = "";
736             sptr<ApnItem> attachApn = apnManager_->GetRilAttachApn();
737             if (attachApn != nullptr) {
738                 proxyIpAddress = attachApn->attr_.proxyIpAddress_;
739             }
740             stateMachine->UpdateHttpProxy(proxyIpAddress);
741             stateMachine->UpdateNetworkInfo(*resultInfo);
742         } else {
743             TELEPHONY_LOGE(
744                 "Slot%{public}d:update network info stateMachine(%{public}d) is null", slotId_, resultInfo->flag);
745         }
746         if (connectionManager_ != nullptr) {
747             connectionManager_->StartStallDetectionTimer();
748             connectionManager_->BeginNetStatistics();
749         }
750         if (!physicalConnectionActiveState_) {
751             physicalConnectionActiveState_ = true;
752             CoreManagerInner::GetInstance().DcPhysicalLinkActiveUpdate(slotId_, physicalConnectionActiveState_);
753         }
754         if (incallDataStateMachine_ != nullptr) {
755             InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_CONNECTED);
756             incallDataStateMachine_->SendEvent(incallEvent);
757         }
758         int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
759         CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
760         if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
761             apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
762             ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
763             StateNotification::GetInstance().UpdateCellularDataConnectState(
764                 slotId_, apnState, networkType);
765         }
766     }
767 }
768 
CreatorDataShareHelper()769 std::shared_ptr<DataShare::DataShareHelper> CellularDataHandler::CreatorDataShareHelper()
770 {
771     sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
772     if (saManager == nullptr) {
773         TELEPHONY_LOGE("saManager is nullptr.");
774         return nullptr;
775     }
776     sptr<IRemoteObject> remoteObj = saManager->GetSystemAbility(TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID);
777     if (remoteObj == nullptr) {
778         TELEPHONY_LOGE("remoteObj is nullptr.");
779         return nullptr;
780     }
781     return DataShare::DataShareHelper::Creator(remoteObj, CELLULAR_DATA_RDB_URI);
782 }
783 
GetCurrentDataShareApnInfo(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,const int32_t simId,int32_t & profileIdValue)784 bool CellularDataHandler::GetCurrentDataShareApnInfo(std::shared_ptr<DataShare::DataShareHelper> dataShareHelper,
785     const int32_t simId, int32_t &profileIdValue)
786 {
787     Uri preferApnUri(std::string(CELLULAR_DATA_RDB_PREFER) + "?Proxy=true&simId=" + std::to_string(simId));
788     DataShare::DataSharePredicates predicates;
789     std::vector<std::string> columns;
790     std::shared_ptr<DataShare::DataShareResultSet> resultSet =
791         dataShareHelper->Query(preferApnUri, predicates, columns);
792     if (resultSet == nullptr) {
793         TELEPHONY_LOGI("Query CurrentDataShareApnInfo resultSet is nullptr.");
794         return false;
795     }
796     int count = 0;
797     resultSet->GetRowCount(count);
798     if (count <= 0) {
799         TELEPHONY_LOGI("GetRowCount is NULL.");
800         resultSet->Close();
801         return false;
802     }
803     int columnIndex = 0;
804     resultSet->GoToFirstRow();
805     resultSet->GetColumnIndex(PdpProfileData::PROFILE_ID, columnIndex);
806     resultSet->GetInt(columnIndex, profileIdValue);
807     resultSet->Close();
808     return true;
809 }
810 
GetCurrentApnId()811 int32_t CellularDataHandler::GetCurrentApnId()
812 {
813     int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
814     if (simId <= INVALID_SIM_ID) {
815         TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
816         return 0;
817     }
818     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreatorDataShareHelper();
819     if (dataShareHelper == nullptr) {
820         TELEPHONY_LOGE("dataShareHelper is nullptr.");
821         return 0;
822     }
823     int32_t profileIdValue = 0;
824     if (!GetCurrentDataShareApnInfo(dataShareHelper, simId, profileIdValue)) {
825         TELEPHONY_LOGE("GetCurrentDataShareApnInfo fail.");
826     }
827     dataShareHelper->Release();
828     return profileIdValue;
829 }
830 
GetSlotId() const831 int32_t CellularDataHandler::GetSlotId() const
832 {
833     return slotId_;
834 }
835 
DisconnectDataComplete(const InnerEvent::Pointer & event)836 void CellularDataHandler::DisconnectDataComplete(const InnerEvent::Pointer &event)
837 {
838     if (event == nullptr || apnManager_ == nullptr || connectionManager_ == nullptr) {
839         TELEPHONY_LOGE("Slot%{public}d: event or apnManager or connectionManager_ is null", slotId_);
840         return;
841     }
842     std::unique_ptr<DataDisconnectParams> object = event->GetUniqueObject<DataDisconnectParams>();
843     if (object == nullptr) {
844         TELEPHONY_LOGE("Slot%{public}d: object is null", slotId_);
845         return;
846     }
847     int32_t apnId = apnManager_->FindApnIdByApnName(object->GetApnType());
848     sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(apnId);
849     if (apnHolder == nullptr) {
850         TELEPHONY_LOGE("Slot%{public}d: apnHolder is null, apnId is %{public}d", slotId_, apnId);
851         return;
852     }
853     DisConnectionReason reason = object->GetReason();
854     apnHolder->SetApnState(PROFILE_STATE_IDLE);
855     int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
856     CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
857     if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
858         apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
859         ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
860         StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, networkType);
861     }
862     UpdatePhysicalConnectionState(connectionManager_->isNoActiveConnection());
863     if (apnHolder->IsDataCallEnabled()) {
864         if (apnHolder->GetApnState() == PROFILE_STATE_IDLE || apnHolder->GetApnState() == PROFILE_STATE_FAILED) {
865             apnHolder->SetCellularDataStateMachine(nullptr);
866         }
867         if (reason == DisConnectionReason::REASON_RETRY_CONNECTION) {
868             SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, apnId, apnHolder->GetRetryDelay());
869         }
870     }
871     if (!apnManager_->HasAnyConnectedState()) {
872         connectionManager_->StopStallDetectionTimer();
873         connectionManager_->EndNetStatistics();
874         if (incallDataStateMachine_ != nullptr) {
875             InnerEvent::Pointer incallEvent =
876                 InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_DISCONNECTED);
877             incallDataStateMachine_->SendEvent(incallEvent);
878         }
879     }
880     if (reason == DisConnectionReason::REASON_CHANGE_CONNECTION) {
881         HandleSortConnection();
882     }
883 }
884 
UpdatePhysicalConnectionState(bool noActiveConnection)885 void CellularDataHandler::UpdatePhysicalConnectionState(bool noActiveConnection)
886 {
887     if (noActiveConnection && physicalConnectionActiveState_) {
888         physicalConnectionActiveState_ = false;
889         CoreManagerInner::GetInstance().DcPhysicalLinkActiveUpdate(slotId_, physicalConnectionActiveState_);
890     } else if (!noActiveConnection && !physicalConnectionActiveState_) {
891         physicalConnectionActiveState_ = true;
892         CoreManagerInner::GetInstance().DcPhysicalLinkActiveUpdate(slotId_, physicalConnectionActiveState_);
893     }
894 }
895 
HandleSortConnection()896 void CellularDataHandler::HandleSortConnection()
897 {
898     ApnProfileState state = apnManager_->GetOverallApnState();
899     if (state == PROFILE_STATE_IDLE || state == PROFILE_STATE_FAILED) {
900         for (const sptr<ApnHolder> &sortApnHolder : apnManager_->GetSortApnHolder()) {
901             if (sortApnHolder->IsDataCallEnabled()) {
902                 int32_t apnId = apnManager_->FindApnIdByApnName(sortApnHolder->GetApnType());
903                 TELEPHONY_LOGI("Slot%{public}d: HandleSortConnection the apn type is %{public}s", slotId_,
904                     sortApnHolder->GetApnType().c_str());
905                 SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, apnId, 0);
906                 break;
907             }
908         }
909     }
910 }
911 
MsgEstablishDataConnection(const InnerEvent::Pointer & event)912 void CellularDataHandler::MsgEstablishDataConnection(const InnerEvent::Pointer &event)
913 {
914     if (apnManager_ == nullptr || event == nullptr) {
915         TELEPHONY_LOGE("Slot%{public}d: apnManager_ or event is null", slotId_);
916         return;
917     }
918     sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(event->GetParam());
919     if (apnHolder == nullptr) {
920         TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
921         return;
922     }
923     TELEPHONY_LOGD("Slot%{public}d: APN holder type:%{public}s call:%{public}d", slotId_,
924         apnHolder->GetApnType().c_str(), apnHolder->IsDataCallEnabled());
925     if (apnHolder->IsMmsType()) {
926         SetDataPermittedForMms(apnHolder->IsDataCallEnabled());
927     }
928     if (apnHolder->IsDataCallEnabled()) {
929         AttemptEstablishDataConnection(apnHolder);
930     } else {
931         DisConnectionReason reason = DisConnectionReason::REASON_CHANGE_CONNECTION;
932         int32_t radioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
933         CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, radioTech);
934         if (!IsSingleConnectionEnabled(radioTech)) {
935             reason = DisConnectionReason::REASON_CLEAR_CONNECTION;
936         }
937         ClearConnection(apnHolder, reason);
938     }
939 }
940 
MsgRequestNetwork(const InnerEvent::Pointer & event)941 void CellularDataHandler::MsgRequestNetwork(const InnerEvent::Pointer &event)
942 {
943     if (apnManager_ == nullptr || event == nullptr) {
944         TELEPHONY_LOGE("Slot%{public}d: apnManager_ or event is null", slotId_);
945         return;
946     }
947     std::unique_ptr<NetRequest> netRequest = event->GetUniqueObject<NetRequest>();
948     if (netRequest == nullptr) {
949         TELEPHONY_LOGE("Slot%{public}d: netRequest is null", slotId_);
950         return;
951     }
952     NetRequest request;
953     request.ident = netRequest->ident;
954     request.capability = netRequest->capability;
955     request.registerType = netRequest->registerType;
956     request.bearTypes = netRequest->bearTypes;
957     int32_t id = ApnManager::FindApnIdByCapability(request.capability);
958     sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(id);
959     if (apnHolder == nullptr) {
960         TELEPHONY_LOGE("Slot%{public}d: apnHolder is null.", slotId_);
961         return;
962     }
963     bool isAllCellularDataAllowed = true;
964 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
965     if (TELEPHONY_EXT_WRAPPER.isAllCellularDataAllowed_) {
966         isAllCellularDataAllowed = TELEPHONY_EXT_WRAPPER.isAllCellularDataAllowed_(request);
967     }
968 #endif
969     if (isAllCellularDataAllowed) {
970         TELEPHONY_LOGD("allow cellular data");
971         if (event->GetParam() == TYPE_REQUEST_NET) {
972             apnHolder->RequestCellularData(request);
973         } else {
974             apnHolder->ReleaseCellularData(request);
975             if (apnHolder->IsDataCallEnabled()) {
976                 return;
977             }
978         }
979     } else {
980         if (event->GetParam() == TYPE_REQUEST_NET) {
981             TELEPHONY_LOGD("not allow reqeust cellular data because of in controled");
982             return;
983         } else {
984             TELEPHONY_LOGI("release all cellular data");
985             apnHolder->ReleaseAllCellularData();
986         }
987     }
988     InnerEvent::Pointer innerEvent = InnerEvent::Get(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, id);
989     if (!SendEvent(innerEvent)) {
990         TELEPHONY_LOGE("Slot%{public}d: send data connection event failed", slotId_);
991     }
992 }
993 
ProcessEvent(const InnerEvent::Pointer & event)994 void CellularDataHandler::ProcessEvent(const InnerEvent::Pointer &event)
995 {
996     if (event == nullptr) {
997         TELEPHONY_LOGE("Slot%{public}d: event is null!", slotId_);
998         return;
999     }
1000     uint32_t eventCode = event->GetInnerEventId();
1001     std::map<uint32_t, Fun>::iterator it = eventIdMap_.find(eventCode);
1002     if (it != eventIdMap_.end()) {
1003         it->second(event);
1004     }
1005 }
1006 
OnReceiveEvent(const EventFwk::CommonEventData & data)1007 void CellularDataHandler::OnReceiveEvent(const EventFwk::CommonEventData &data)
1008 {
1009     const AAFwk::Want &want = data.GetWant();
1010     std::string action = want.GetAction();
1011     int32_t slotId = want.GetIntParam("slotId", 0);
1012     TELEPHONY_LOGI("[slot%{public}d] action=%{public}s code=%{public}d", slotId_, action.c_str(), data.GetCode());
1013     if (EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED == action) {
1014         if (slotId_ != slotId) {
1015             return;
1016         }
1017         int32_t state = want.GetIntParam("state", CALL_STATUS_UNKNOWN);
1018         if (state == CALL_STATUS_UNKNOWN) {
1019             TELEPHONY_LOGE("Slot%{public}d: unknown call state=%{public}d", slotId, state);
1020             return;
1021         }
1022         HandleCallChanged(state);
1023     } else if (action == CommonEventSupport::COMMON_EVENT_SIM_CARD_DEFAULT_DATA_SUBSCRIPTION_CHANGED) {
1024         HandleDefaultDataSubscriptionChanged();
1025     } else if (action == CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED) {
1026         if (slotId_ != slotId) {
1027             return;
1028         }
1029         GetConfigurationFor5G();
1030     } else if (action == CommonEventSupport::COMMON_EVENT_SCREEN_ON) {
1031         if (slotId_ != slotId) {
1032             return;
1033         }
1034         HandleScreenStateChanged(true);
1035     } else if (action == CommonEventSupport::COMMON_EVENT_SCREEN_OFF) {
1036         if (slotId_ != slotId) {
1037             return;
1038         }
1039         HandleScreenStateChanged(false);
1040     } else if (action == CommonEventSupport::COMMON_EVENT_DATA_SHARE_READY) {
1041         RegisterDataSettingObserver();
1042     } else {
1043         TELEPHONY_LOGI("Slot%{public}d: action=%{public}s code=%{public}d", slotId_, action.c_str(), data.GetCode());
1044     }
1045 }
1046 
HandleScreenStateChanged(bool isScreenOn) const1047 void CellularDataHandler::HandleScreenStateChanged(bool isScreenOn) const
1048 {
1049     if (connectionManager_ == nullptr) {
1050         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null!", slotId_);
1051         return;
1052     }
1053     connectionManager_->HandleScreenStateChanged(isScreenOn);
1054 }
1055 
HandleSettingSwitchChanged(const InnerEvent::Pointer & event)1056 void CellularDataHandler::HandleSettingSwitchChanged(const InnerEvent::Pointer &event)
1057 {
1058     if (event == nullptr) {
1059         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1060         return;
1061     }
1062     bool setting_switch = event->GetParam();
1063     TELEPHONY_LOGI("Slot%{public}d: setting switch = %{public}d", slotId_, setting_switch);
1064 }
1065 
HandleDBSettingIncallChanged(const AppExecFwk::InnerEvent::Pointer & event)1066 void CellularDataHandler::HandleDBSettingIncallChanged(const AppExecFwk::InnerEvent::Pointer &event)
1067 {
1068     if (event == nullptr) {
1069         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1070         return;
1071     }
1072     if (incallDataStateMachine_ == nullptr) {
1073         TELEPHONY_LOGE("Slot%{public}d: incallDataStateMachine_ is null", slotId_);
1074         return;
1075     }
1076     int64_t value = event->GetParam();
1077     if (value == static_cast<int64_t>(DataSwitchCode::CELLULAR_DATA_ENABLED)) {
1078         InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_SETTINGS_ON);
1079         incallDataStateMachine_->SendEvent(incallEvent);
1080     } else {
1081         InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_SETTINGS_OFF);
1082         incallDataStateMachine_->SendEvent(incallEvent);
1083     }
1084 }
1085 
CreateIncallDataStateMachine(int32_t callState)1086 std::shared_ptr<IncallDataStateMachine> CellularDataHandler::CreateIncallDataStateMachine(int32_t callState)
1087 {
1088     std::shared_ptr<IncallDataStateMachine> incallDataStateMachine = std::make_shared<IncallDataStateMachine>(slotId_,
1089         std::weak_ptr<TelEventHandler>(std::static_pointer_cast<TelEventHandler>(shared_from_this())), apnManager_);
1090     if (incallDataStateMachine == nullptr) {
1091         TELEPHONY_LOGE("Slot%{public}d: incallDataStateMachine is null", slotId_);
1092         return nullptr;
1093     }
1094     incallDataStateMachine->Init(callState);
1095     return incallDataStateMachine;
1096 }
1097 
IncallDataComplete(const InnerEvent::Pointer & event)1098 void CellularDataHandler::IncallDataComplete(const InnerEvent::Pointer &event)
1099 {
1100     TELEPHONY_LOGI("Slot%{public}d: MSG_INCALL_DATA_COMPLETE", slotId_);
1101     if (incallDataStateMachine_ != nullptr) {
1102         incallDataStateMachine_ = nullptr;
1103     }
1104 }
1105 
HandleCallChanged(int32_t state)1106 void CellularDataHandler::HandleCallChanged(int32_t state)
1107 {
1108     TELEPHONY_LOGI("Slot%{public}d: lastState:%{public}d, state:%{public}d", slotId_, lastCallState_, state);
1109     if (lastCallState_ == state) {
1110         TELEPHONY_LOGE("Slot%{public}d: call state=%{public}d, not changed", slotId_, state);
1111         return;
1112     }
1113     if (connectionManager_ == nullptr) {
1114         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null!", slotId_);
1115         return;
1116     }
1117     lastCallState_ = state;
1118     connectionManager_->UpdateCallState(state);
1119     ImsRegInfo voiceInfo;
1120     CoreManagerInner::GetInstance().GetImsRegStatus(slotId_, ImsServiceType::TYPE_VOICE, voiceInfo);
1121     ImsRegInfo videoInfo;
1122     CoreManagerInner::GetInstance().GetImsRegStatus(slotId_, ImsServiceType::TYPE_VIDEO, videoInfo);
1123     if (voiceInfo.imsRegState == ImsRegState::IMS_REGISTERED || videoInfo.imsRegState == ImsRegState::IMS_REGISTERED) {
1124         HandleImsCallChanged(state);
1125     } else {
1126         HandleVoiceCallChanged(state);
1127     }
1128 }
1129 
HandleImsCallChanged(int32_t state)1130 void CellularDataHandler::HandleImsCallChanged(int32_t state)
1131 {
1132     if (state == TelCallStatus::CALL_STATUS_DIALING || state == TelCallStatus::CALL_STATUS_INCOMING) {
1133         if (incallDataStateMachine_ == nullptr) {
1134             incallDataStateMachine_ = CreateIncallDataStateMachine(state);
1135         }
1136     }
1137     if (incallDataStateMachine_ == nullptr) {
1138         TELEPHONY_LOGE("Slot%{public}d: incallDataStateMachine_ is null!", slotId_);
1139         return;
1140     }
1141     incallDataStateMachine_->UpdateCallState(state);
1142     if (state == TelCallStatus::CALL_STATUS_DIALING || state == TelCallStatus::CALL_STATUS_INCOMING) {
1143         InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_CALL_STARTED);
1144         incallDataStateMachine_->SendEvent(incallEvent);
1145     }
1146     if (state == TelCallStatus::CALL_STATUS_DISCONNECTED || state == TelCallStatus::CALL_STATUS_IDLE) {
1147         InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_CALL_ENDED);
1148         incallDataStateMachine_->SendEvent(incallEvent);
1149     }
1150 }
1151 
HandleVoiceCallChanged(int32_t state)1152 void CellularDataHandler::HandleVoiceCallChanged(int32_t state)
1153 {
1154     if (apnManager_ == nullptr || connectionManager_ == nullptr) {
1155         TELEPHONY_LOGE("Slot%{public}d: apnManager or connectionManager is null!", slotId_);
1156         return;
1157     }
1158     // next to check if radio technology support voice and data at same time.
1159     int32_t psRadioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
1160     CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, psRadioTech);
1161     bool support = (psRadioTech == static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_GSM));
1162     if (state != TelCallStatus::CALL_STATUS_IDLE && state != TelCallStatus::CALL_STATUS_DISCONNECTED) {
1163         if (apnManager_->HasAnyConnectedState() && support) {
1164             connectionManager_->EndNetStatistics();
1165             connectionManager_->SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_DORMANT);
1166             connectionManager_->StopStallDetectionTimer();
1167             disconnectionReason_ = DisConnectionReason::REASON_GSM_AND_CALLING_ONLY;
1168         }
1169     } else {
1170         if (apnManager_->HasAnyConnectedState() && support) {
1171             connectionManager_->StartStallDetectionTimer();
1172             connectionManager_->BeginNetStatistics();
1173         }
1174         disconnectionReason_ = DisConnectionReason::REASON_NORMAL;
1175         TELEPHONY_LOGI("Slot%{public}d: HandleVoiceCallChanged EstablishAllApnsIfConnectable", slotId_);
1176         EstablishAllApnsIfConnectable();
1177     }
1178     TELEPHONY_LOGI("Slot%{public}d: disconnectionReason_=%{public}d", slotId_, disconnectionReason_);
1179 }
1180 
HandleDefaultDataSubscriptionChanged()1181 void CellularDataHandler::HandleDefaultDataSubscriptionChanged()
1182 {
1183     TELEPHONY_LOGI("Slot%{public}d", slotId_);
1184     if (CheckDataPermittedByDsds()) {
1185         SetDataPermitted(slotId_, true);
1186     } else {
1187         SetDataPermitted(slotId_, false);
1188     }
1189     if (dataSwitchSettings_ != nullptr) {
1190         dataSwitchSettings_->LoadSwitchValue();
1191     }
1192     CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1193     const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
1194     if (defSlotId == slotId_) {
1195         EstablishAllApnsIfConnectable();
1196     } else {
1197         ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1198     }
1199 }
1200 
ReleaseAllNetworkRequest()1201 void CellularDataHandler::ReleaseAllNetworkRequest()
1202 {
1203     if (apnManager_ == nullptr) {
1204         TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1205         return;
1206     }
1207     for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1208         if (apnHolder == nullptr) {
1209             continue;
1210         }
1211         apnHolder->ReleaseAllCellularData();
1212     }
1213 }
1214 
HandleSimStateChanged()1215 void CellularDataHandler::HandleSimStateChanged()
1216 {
1217     SimState simState = SimState::SIM_STATE_UNKNOWN;
1218     CoreManagerInner::GetInstance().GetSimState(slotId_, simState);
1219     TELEPHONY_LOGI("Slot%{public}d: sim state is :%{public}d", slotId_, simState);
1220     if (simState != SimState::SIM_STATE_READY) {
1221         isSimAccountLoaded_ = false;
1222         ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1223         if (simState == SimState::SIM_STATE_NOT_PRESENT) {
1224             CellularDataNetAgent::GetInstance().UnregisterNetSupplierForSimUpdate(slotId_);
1225             ReleaseAllNetworkRequest();
1226             UnRegisterDataSettingObserver();
1227         }
1228     } else {
1229         std::u16string iccId;
1230         CoreManagerInner::GetInstance().GetSimIccId(slotId_, iccId);
1231         if (lastIccId_ != u"" && lastIccId_ == iccId) {
1232             EstablishAllApnsIfConnectable();
1233         }
1234     }
1235 }
1236 
HandleSimStateOrRecordsChanged(const AppExecFwk::InnerEvent::Pointer & event)1237 void CellularDataHandler::HandleSimStateOrRecordsChanged(const AppExecFwk::InnerEvent::Pointer &event)
1238 {
1239     if (event == nullptr) {
1240         return;
1241     }
1242     if (dataSwitchSettings_ != nullptr) {
1243         dataSwitchSettings_->LoadSwitchValue();
1244     }
1245     switch (event->GetInnerEventId()) {
1246         case RadioEvent::RADIO_SIM_STATE_CHANGE: {
1247             HandleSimStateChanged();
1248             break;
1249         }
1250         case RadioEvent::RADIO_SIM_RECORDS_LOADED: {
1251             std::u16string iccId;
1252             CoreManagerInner::GetInstance().GetSimIccId(slotId_, iccId);
1253             SimState simState = SimState::SIM_STATE_UNKNOWN;
1254             CoreManagerInner::GetInstance().GetSimState(slotId_, simState);
1255             if (simState != SimState::SIM_STATE_READY || iccId == u"") {
1256                 TELEPHONY_LOGI("sim state error or iccId nullptr");
1257                 break;
1258             }
1259             if (iccId != lastIccId_) {
1260                 if (dataSwitchSettings_ != nullptr) {
1261                     dataSwitchSettings_->SetPolicyDataOn(true);
1262                 }
1263                 lastIccId_ = iccId;
1264             } else if (lastIccId_ == iccId) {
1265                 TELEPHONY_LOGI("Slot%{public}d: sim state changed, but iccId not changed.", slotId_);
1266                 // the sim card status has changed to ready, so try to connect
1267                 EstablishAllApnsIfConnectable();
1268             }
1269             break;
1270         }
1271         default:
1272             break;
1273     }
1274 }
1275 
HandleSimAccountLoaded(const InnerEvent::Pointer & event)1276 void CellularDataHandler::HandleSimAccountLoaded(const InnerEvent::Pointer &event)
1277 {
1278     if (event == nullptr) {
1279         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1280         return;
1281     }
1282     TELEPHONY_LOGI("Slot%{public}d", slotId_);
1283     if (isSimAccountLoaded_) {
1284         TELEPHONY_LOGE("Slot%{public}d has already loaded", slotId_);
1285         return;
1286     }
1287     auto slotId = event->GetParam();
1288     if (slotId == slotId_) {
1289         isSimAccountLoaded_ = true;
1290         ReleaseAllNetworkRequest();
1291         ClearAllConnections(DisConnectionReason::REASON_CHANGE_CONNECTION);
1292         CellularDataNetAgent::GetInstance().UnregisterNetSupplierForSimUpdate(slotId_);
1293         if (!CellularDataNetAgent::GetInstance().RegisterNetSupplier(slotId_)) {
1294             TELEPHONY_LOGE("Slot%{public}d register supplierid fail", slotId_);
1295             isSimAccountLoaded_ = false;
1296         }
1297         if (slotId_ == 0) {
1298             CellularDataNetAgent::GetInstance().UnregisterPolicyCallback();
1299             CellularDataNetAgent::GetInstance().RegisterPolicyCallback();
1300         }
1301         RegisterDataSettingObserver();
1302         if (dataSwitchSettings_ != nullptr) {
1303             dataSwitchSettings_->LoadSwitchValue();
1304         }
1305         GetConfigurationFor5G();
1306         CreateApnItem();
1307     }
1308     CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1309     const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
1310     if (defSlotId == slotId_) {
1311         EstablishAllApnsIfConnectable();
1312     } else {
1313         ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1314     }
1315 }
1316 
CreateApnItem()1317 void CellularDataHandler::CreateApnItem()
1318 {
1319     if (apnManager_ == nullptr) {
1320         TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1321         return;
1322     }
1323     int32_t result = 0;
1324     for (int32_t i = 0; i < DEFAULT_READ_APN_TIME; ++i) {
1325         result = apnManager_->CreateAllApnItemByDatabase(slotId_);
1326         if (result != 0) {
1327             break;
1328         }
1329     }
1330     if (result == 0) {
1331         apnManager_->CreateAllApnItem();
1332     }
1333     SetRilAttachApn();
1334 }
1335 
HandleApnChanged()1336 bool CellularDataHandler::HandleApnChanged()
1337 {
1338     if (apnManager_ == nullptr) {
1339         TELEPHONY_LOGE("apnManager is null");
1340         return false;
1341     }
1342     for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1343         TELEPHONY_LOGI("Slot%{public}d: apn type:%{public}s state:%{public}d", slotId_, apnHolder->GetApnType().c_str(),
1344             apnHolder->GetApnState());
1345     }
1346     InnerEvent::Pointer event = InnerEvent::Get(CellularDataEventCode::MSG_APN_CHANGED);
1347     if (event == nullptr) {
1348         TELEPHONY_LOGE("Slot%{public}d: get apn changed event is null", slotId_);
1349         return false;
1350     }
1351     return SendEvent(event);
1352 }
1353 
HandleApnChanged(const InnerEvent::Pointer & event)1354 void CellularDataHandler::HandleApnChanged(const InnerEvent::Pointer &event)
1355 {
1356     if (apnManager_ == nullptr) {
1357         TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1358         return;
1359     }
1360     CreateApnItem();
1361     ApnProfileState apnState = apnManager_->GetOverallApnState();
1362     if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING || apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
1363         ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
1364     }
1365     for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1366         if (apnHolder == nullptr) {
1367             continue;
1368         }
1369         int32_t id = apnManager_->FindApnIdByApnName(apnHolder->GetApnType());
1370         SendEvent(CellularDataEventCode::MSG_ESTABLISH_DATA_CONNECTION, id, ESTABLISH_DATA_CONNECTION_DELAY);
1371     }
1372 }
1373 
GetCellularDataFlowType()1374 int32_t CellularDataHandler::GetCellularDataFlowType()
1375 {
1376     if (connectionManager_ == nullptr) {
1377         TELEPHONY_LOGE("Slot%{public}d: connection manager is null", slotId_);
1378         return 0;
1379     }
1380     return connectionManager_->GetDataFlowType();
1381 }
1382 
HandleRadioStateChanged(const AppExecFwk::InnerEvent::Pointer & event)1383 void CellularDataHandler::HandleRadioStateChanged(const AppExecFwk::InnerEvent::Pointer &event)
1384 {
1385     if (apnManager_ == nullptr || event == nullptr) {
1386         TELEPHONY_LOGE("Slot%{public}d: radio off or not available apnManager or event is null!", slotId_);
1387         return;
1388     }
1389     std::shared_ptr<Int32Parcel> object = event->GetSharedObject<Int32Parcel>();
1390     if (object == nullptr) {
1391         TELEPHONY_LOGE("Slot%{public}d: object is nullptr!", slotId_);
1392         return;
1393     }
1394     TELEPHONY_LOGI("Slot%{public}d: Radio changed with state: %{public}d", slotId_, object->data);
1395     switch (object->data) {
1396         case CORE_SERVICE_POWER_OFF:
1397         case CORE_SERVICE_POWER_NOT_AVAILABLE: {
1398             ApnProfileState apnState = apnManager_->GetOverallApnState();
1399             TELEPHONY_LOGI("Slot%{public}d: apn state is %{public}d", slotId_, apnState);
1400             if (apnState != ApnProfileState::PROFILE_STATE_IDLE) {
1401                 ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1402             }
1403             break;
1404         }
1405         case CORE_SERVICE_POWER_ON:
1406             SetRilLinkBandwidths();
1407             EstablishAllApnsIfConnectable();
1408             break;
1409         default:
1410             TELEPHONY_LOGI("Slot%{public}d: un-handle state:%{public}d", slotId_, object->data);
1411             break;
1412     }
1413 }
1414 
HandleDsdsModeChanged(const AppExecFwk::InnerEvent::Pointer & event)1415 void CellularDataHandler::HandleDsdsModeChanged(const AppExecFwk::InnerEvent::Pointer &event)
1416 {
1417     if (event == nullptr) {
1418         TELEPHONY_LOGE("Slot%{public}d: event is null!", slotId_);
1419         return;
1420     }
1421     std::shared_ptr<Int32Parcel> object = event->GetSharedObject<Int32Parcel>();
1422     if (object == nullptr) {
1423         TELEPHONY_LOGE("Slot%{public}d: object is null!", slotId_);
1424         return;
1425     }
1426     TELEPHONY_LOGI("Slot%{public}d: DSDS changed with mode: %{public}d", slotId_, object->data);
1427     int32_t dsdsMode = DSDS_MODE_V2;
1428     CoreManagerInner::GetInstance().GetDsdsMode(dsdsMode);
1429     if (object->data == dsdsMode) {
1430         TELEPHONY_LOGE("Slot%{public}d: DSDS mode is the same!", slotId_);
1431         return;
1432     }
1433     if (object->data < DSDS_MODE_V2) {
1434         TELEPHONY_LOGE("Slot%{public}d: DSDS mode is illegal!", slotId_);
1435         return;
1436     }
1437     CoreManagerInner::GetInstance().SetDsdsMode(object->data);
1438     int32_t defaultSlotId = CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
1439     int32_t simNum = CoreManagerInner::GetInstance().GetMaxSimCount();
1440     bool dataEnableStatus = true;
1441     IsCellularDataEnabled(dataEnableStatus);
1442     for (int32_t i = 0; i < simNum; ++i) {
1443         if (defaultSlotId != i && object->data == DSDS_MODE_V2) {
1444             SetDataPermitted(i, false);
1445         } else {
1446             if (dataEnableStatus) {
1447                 SetDataPermitted(i, true);
1448             }
1449             DelayedRefSingleton<CellularDataService>::GetInstance().ChangeConnectionForDsds(i, true);
1450         }
1451     }
1452     if (incallDataStateMachine_ != nullptr) {
1453         InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DSDS_CHANGED);
1454         incallDataStateMachine_->SendEvent(incallEvent);
1455     }
1456 }
1457 
ClearConnectionIfRequired()1458 void CellularDataHandler::ClearConnectionIfRequired()
1459 {
1460     if (apnManager_ == nullptr) {
1461         TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1462         return;
1463     }
1464     for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
1465         if (apnHolder == nullptr) {
1466             TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
1467             continue;
1468         }
1469         ApnProfileState apnState = apnHolder->GetApnState();
1470         std::string apnType = apnHolder->GetApnType();
1471         std::vector<sptr<ApnItem>> matchedApns = apnManager_->FilterMatchedApns(apnType, slotId_);
1472         if (matchedApns.empty()) {
1473             TELEPHONY_LOGE("Slot%{public}d: matchedApns is empty", slotId_);
1474             continue;
1475         }
1476         bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0;
1477         if (!apnHolder->IsSameMatchedApns(matchedApns, roamingState)) {
1478             apnHolder->SetAllMatchedApns(matchedApns);
1479             if (apnState != ApnProfileState::PROFILE_STATE_IDLE &&
1480                 apnState != ApnProfileState::PROFILE_STATE_FAILED) {
1481                 TELEPHONY_LOGI("Slot%{public}d: the connection of APN type:%{public}s will be cleared.",
1482                     slotId_, apnType.c_str());
1483                 ClearConnection(apnHolder, DisConnectionReason::REASON_RETRY_CONNECTION);
1484             }
1485         }
1486     }
1487     if (connectionManager_ == nullptr) {
1488         TELEPHONY_LOGE("Slot%{public}d: connectionManager_ is null", slotId_);
1489         return;
1490     }
1491     if (!apnManager_->HasAnyConnectedState()) {
1492         connectionManager_->StopStallDetectionTimer();
1493         connectionManager_->EndNetStatistics();
1494         ResetDataFlowType();
1495     }
1496 }
1497 
PsDataRatChanged(const InnerEvent::Pointer & event)1498 void CellularDataHandler::PsDataRatChanged(const InnerEvent::Pointer &event)
1499 {
1500     CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1501     int32_t radioTech = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
1502     coreInner.GetPsRadioTech(slotId_, radioTech);
1503     TELEPHONY_LOGI("Slot%{public}d: radioTech is %{public}d", slotId_, radioTech);
1504     if (event == nullptr) {
1505         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1506         return;
1507     }
1508     bool dataEnabled = dataSwitchSettings_->IsUserDataOn();
1509     if (!dataEnabled) {
1510         TELEPHONY_LOGE("Slot%{public}d: data enable is close", slotId_);
1511         return;
1512     }
1513     bool attached = coreInner.GetPsRegState(slotId_) == (int32_t)RegServiceState::REG_STATE_IN_SERVICE;
1514     if (!attached) {
1515         TELEPHONY_LOGE("Slot%{public}d: attached is false", slotId_);
1516         return;
1517     }
1518     ClearConnectionIfRequired();
1519     EstablishAllApnsIfConnectable();
1520 }
1521 
SetPolicyDataOn(bool enable)1522 void CellularDataHandler::SetPolicyDataOn(bool enable)
1523 {
1524     if (dataSwitchSettings_ == nullptr) {
1525         TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings is null", slotId_);
1526         return;
1527     }
1528     bool policyDataOn = dataSwitchSettings_->IsPolicyDataOn();
1529     if (policyDataOn != enable) {
1530         dataSwitchSettings_->SetPolicyDataOn(enable);
1531         if (enable) {
1532             EstablishAllApnsIfConnectable();
1533         } else {
1534             ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1535         }
1536     }
1537 }
1538 
IsRestrictedMode() const1539 bool CellularDataHandler::IsRestrictedMode() const
1540 {
1541     int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
1542     CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
1543     bool support = (networkType == (int32_t)RadioTech::RADIO_TECHNOLOGY_GSM);
1544     bool inCall = (lastCallState_ != TelCallStatus::CALL_STATUS_IDLE &&
1545                    lastCallState_ != TelCallStatus::CALL_STATUS_DISCONNECTED);
1546     TELEPHONY_LOGD("Slot%{public}d: radio technology is gsm only:%{public}d and call is busy:%{public}d", slotId_,
1547         support, inCall);
1548     return inCall && support;
1549 }
1550 
GetDisConnectionReason()1551 DisConnectionReason CellularDataHandler::GetDisConnectionReason()
1552 {
1553     return disconnectionReason_;
1554 }
1555 
SetDataPermitted(int32_t slotId,bool dataPermitted)1556 void CellularDataHandler::SetDataPermitted(int32_t slotId, bool dataPermitted)
1557 {
1558     TELEPHONY_LOGI("Slot%{public}d: dataPermitted is %{public}d.", slotId, dataPermitted);
1559     int32_t maxSimCount = CoreManagerInner::GetInstance().GetMaxSimCount();
1560     if (maxSimCount <= 1) {
1561         TELEPHONY_LOGE("Slot%{public}d: maxSimCount is: %{public}d", slotId_, maxSimCount);
1562         return;
1563     }
1564     bool hasSimCard = false;
1565     CoreManagerInner::GetInstance().HasSimCard(slotId, hasSimCard);
1566     if (!hasSimCard && !IsVSimSlotId(slotId)) {
1567         TELEPHONY_LOGE("Slot%{public}d: no sim :%{public}d", slotId_, slotId);
1568         return;
1569     }
1570     CoreManagerInner::GetInstance().SetDataPermitted(
1571         slotId, CellularDataEventCode::MSG_SET_DATA_PERMITTED, dataPermitted, shared_from_this());
1572 }
1573 
SetDataPermittedResponse(const AppExecFwk::InnerEvent::Pointer & event)1574 void CellularDataHandler::SetDataPermittedResponse(const AppExecFwk::InnerEvent::Pointer &event)
1575 {
1576     if (event == nullptr) {
1577         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1578         return;
1579     }
1580     std::shared_ptr<TelRilResponseInfo<int32_t>> rilInfo = event->GetSharedObject<TelRilResponseInfo<int32_t>>();
1581     if (rilInfo == nullptr) {
1582         TELEPHONY_LOGE("Slot%{public}d: RadioResponseInfo is null", slotId_);
1583         return;
1584     }
1585     if (rilInfo->errorNo != 0) {
1586         TELEPHONY_LOGE("Slot%{public}d: SetDataPermitted error", slotId_);
1587     }
1588 }
1589 
GetEsmFlagFromOpCfg()1590 bool CellularDataHandler::GetEsmFlagFromOpCfg()
1591 {
1592     int32_t esmFlagFromOpCfg = ESM_FLAG_INVALID;
1593     OperatorConfig configsForEsmFlag;
1594     CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForEsmFlag);
1595     if (configsForEsmFlag.intValue.find(KEY_PLMN_ESM_FLAG_INT) != configsForEsmFlag.intValue.end()) {
1596         esmFlagFromOpCfg = configsForEsmFlag.intValue[KEY_PLMN_ESM_FLAG_INT];
1597     }
1598     if (esmFlagFromOpCfg < 0 || esmFlagFromOpCfg > 1) {
1599         TELEPHONY_LOGE("esmFlag value is invalid");
1600     }
1601     return (esmFlagFromOpCfg != 0);
1602 }
1603 
SetInitApnWithNullDp()1604 void CellularDataHandler::SetInitApnWithNullDp()
1605 {
1606     DataProfile dataProfile;
1607     dataProfile.profileId = 0;
1608     dataProfile.apn = "";
1609     dataProfile.protocol = "";
1610     dataProfile.verType = 0;
1611     dataProfile.userName = "";
1612     dataProfile.password = "";
1613     dataProfile.roamingProtocol = "";
1614     CoreManagerInner::GetInstance().SetInitApnInfo(
1615         slotId_, CellularDataEventCode::MSG_SET_RIL_ATTACH_APN, dataProfile, shared_from_this());
1616     return;
1617 }
1618 
SetRilAttachApn()1619 void CellularDataHandler::SetRilAttachApn()
1620 {
1621     sptr<ApnItem> attachApn = apnManager_->GetRilAttachApn();
1622     if (attachApn == nullptr) {
1623         TELEPHONY_LOGE("Slot%{public}d: attachApn is null", slotId_);
1624         return;
1625     }
1626     if (!GetEsmFlagFromOpCfg()) {
1627         SetInitApnWithNullDp();
1628         return;
1629     }
1630     DataProfile dataProfile;
1631     dataProfile.profileId = attachApn->attr_.profileId_;
1632     dataProfile.apn = attachApn->attr_.apn_;
1633     dataProfile.protocol = attachApn->attr_.protocol_;
1634     dataProfile.verType = attachApn->attr_.authType_;
1635     dataProfile.userName = attachApn->attr_.user_;
1636     dataProfile.password = attachApn->attr_.password_;
1637     dataProfile.roamingProtocol = attachApn->attr_.roamingProtocol_;
1638     TELEPHONY_LOGI("DataProfile profileId = %{public}d", dataProfile.profileId);
1639     CoreManagerInner::GetInstance().SetInitApnInfo(
1640         slotId_, CellularDataEventCode::MSG_SET_RIL_ATTACH_APN, dataProfile, shared_from_this());
1641 }
1642 
SetRilAttachApnResponse(const AppExecFwk::InnerEvent::Pointer & event)1643 void CellularDataHandler::SetRilAttachApnResponse(const AppExecFwk::InnerEvent::Pointer &event)
1644 {
1645     if (event == nullptr) {
1646         TELEPHONY_LOGE("Slot%{public}d: event is null", slotId_);
1647         return;
1648     }
1649     std::shared_ptr<TelRilResponseInfo<int32_t>> rilInfo = event->GetSharedObject<TelRilResponseInfo<int32_t>>();
1650     if (rilInfo == nullptr) {
1651         TELEPHONY_LOGE("Slot%{public}d: RadioResponseInfo is null", slotId_);
1652         return;
1653     }
1654     if (rilInfo->errorNo != 0) {
1655         TELEPHONY_LOGE("Slot%{public}d: SetRilAttachApn error", slotId_);
1656     }
1657 }
1658 
HasAnyHigherPriorityConnection(const sptr<ApnHolder> & apnHolder)1659 bool CellularDataHandler::HasAnyHigherPriorityConnection(const sptr<ApnHolder> &apnHolder)
1660 {
1661     if (apnManager_ == nullptr) {
1662         TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
1663         return false;
1664     }
1665     std::vector<sptr<ApnHolder>> sortApnHolders = apnManager_->GetSortApnHolder();
1666     if (sortApnHolders.empty()) {
1667         TELEPHONY_LOGE("Slot%{public}d: SortApnHolder is null", slotId_);
1668         return false;
1669     }
1670     for (const sptr<ApnHolder> &sortApnHolder : sortApnHolders) {
1671         if (sortApnHolder->GetPriority() > apnHolder->GetPriority()) {
1672             if (sortApnHolder->IsDataCallEnabled() &&
1673                 (sortApnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTED ||
1674                     sortApnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_CONNECTING ||
1675                     sortApnHolder->GetApnState() == ApnProfileState::PROFILE_STATE_DISCONNECTING)) {
1676                 CellularDataHiSysEvent::WriteDataActivateFaultEvent(slotId_, SWITCH_ON,
1677                     CellularDataErrorCode::DATA_ERROR_HAS_HIGHER_PRIORITY_CONNECTION,
1678                     "There is higher priority connection");
1679                 return true;
1680             }
1681         }
1682     }
1683     return false;
1684 }
1685 
HasInternetCapability(const int32_t cid) const1686 bool CellularDataHandler::HasInternetCapability(const int32_t cid) const
1687 {
1688     if (connectionManager_ == nullptr) {
1689         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1690         return false;
1691     }
1692     std::shared_ptr<CellularDataStateMachine> activeStateMachine = connectionManager_->GetActiveConnectionByCid(cid);
1693     if (activeStateMachine == nullptr) {
1694         TELEPHONY_LOGE("Slot%{public}d: get activeStateMachine by cid fail", slotId_);
1695         return false;
1696     }
1697     uint64_t netCapability = activeStateMachine->GetCapability();
1698     if (netCapability == NetCap::NET_CAPABILITY_INTERNET) {
1699         return true;
1700     }
1701     return false;
1702 }
1703 
ChangeConnectionForDsds(bool enable)1704 bool CellularDataHandler::ChangeConnectionForDsds(bool enable)
1705 {
1706     if (dataSwitchSettings_ == nullptr) {
1707         TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
1708         return false;
1709     }
1710     if (enable) {
1711         dataSwitchSettings_->SetInternalDataOn(true);
1712         EstablishAllApnsIfConnectable();
1713     } else {
1714         dataSwitchSettings_->SetInternalDataOn(false);
1715         ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1716     }
1717     return true;
1718 }
1719 
GetConfigurationFor5G()1720 void CellularDataHandler::GetConfigurationFor5G()
1721 {
1722     // get 5G configurations
1723     unMeteredAllNsaConfig_ = ParseOperatorConfig(u"allmeterednas");
1724     unMeteredNrNsaMmwaveConfig_ = ParseOperatorConfig(u"meterednrnsammware");
1725     unMeteredNrNsaSub6Config_ = ParseOperatorConfig(u"meteredNrnsasub6");
1726     unMeteredAllNrsaConfig_ = ParseOperatorConfig(u"meteredallnrsa");
1727     unMeteredNrsaMmwaveConfig_ = ParseOperatorConfig(u"meterednrsammware");
1728     unMeteredNrsaSub6Config_ = ParseOperatorConfig(u"meterednrsasub6");
1729     unMeteredRoamingConfig_ = ParseOperatorConfig(u"meteredroaming");
1730     GetDefaultConfiguration();
1731 }
1732 
ParseOperatorConfig(const std::u16string & configName)1733 bool CellularDataHandler::ParseOperatorConfig(const std::u16string &configName)
1734 {
1735     OperatorConfig configsFor5G;
1736     CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsFor5G);
1737     if (configsFor5G.configValue.count(configName) > 0) {
1738         std::string flag = Str16ToStr8(configsFor5G.configValue[configName]);
1739         TELEPHONY_LOGI("Slot%{public}d: parse operator 5G config: %{public}s", slotId_, flag.c_str());
1740         if (flag == "true") {
1741             return true;
1742         }
1743     }
1744     return false;
1745 }
1746 
GetSinglePdpEnabledFromOpCfg()1747 void CellularDataHandler::GetSinglePdpEnabledFromOpCfg()
1748 {
1749     OperatorConfig configsForSinglePdp;
1750     CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForSinglePdp);
1751     if (configsForSinglePdp.boolValue.find(KEY_SINGLE_PDP_ENABLED_BOOL) != configsForSinglePdp.boolValue.end()) {
1752         multipleConnectionsEnabled_ = !configsForSinglePdp.boolValue[KEY_SINGLE_PDP_ENABLED_BOOL];
1753     }
1754     return;
1755 }
1756 
IsSingleConnectionEnabled(int32_t radioTech)1757 bool CellularDataHandler::IsSingleConnectionEnabled(int32_t radioTech)
1758 {
1759     std::vector<int32_t> singlePdpRadio;
1760     OperatorConfig configsForSinglePdpRadioType;
1761     CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForSinglePdpRadioType);
1762     if (configsForSinglePdpRadioType.intArrayValue.count(KEY_SINGLE_PDP_RADIO_TYPE_INT_ARRAY) >0) {
1763         singlePdpRadio = configsForSinglePdpRadioType.intArrayValue[KEY_SINGLE_PDP_RADIO_TYPE_INT_ARRAY];
1764     }
1765     if (singlePdpRadio.empty()) {
1766         TELEPHONY_LOGI("single pdp radio type array is empty");
1767     }
1768     if (std::find(singlePdpRadio.begin(), singlePdpRadio.end(), radioTech) != singlePdpRadio.end()) {
1769         TELEPHONY_LOGI("radio type array is matched single pdp type");
1770         multipleConnectionsEnabled_ = false;
1771         return !multipleConnectionsEnabled_;
1772     }
1773     GetSinglePdpEnabledFromOpCfg();
1774     return !multipleConnectionsEnabled_;
1775 }
1776 
GetDefaultDataRoamingConfig()1777 void CellularDataHandler::GetDefaultDataRoamingConfig()
1778 {
1779     defaultDataRoamingEnable_ = false;
1780     OperatorConfig configsForDataRoaming;
1781     CoreManagerInner::GetInstance().GetOperatorConfigs(slotId_, configsForDataRoaming);
1782     if (configsForDataRoaming.boolValue.find(KEY_DEFAULT_DATA_ROAMING_BOOL) != configsForDataRoaming.boolValue.end()) {
1783         defaultDataRoamingEnable_ = configsForDataRoaming.boolValue[KEY_DEFAULT_DATA_ROAMING_BOOL];
1784         TELEPHONY_LOGI("Slot%{public}d: OperatorConfig defaultDataRoamingEnable_ = %{public}d", slotId_,
1785             defaultDataRoamingEnable_);
1786     } else {
1787         std::string defaultDataRoaming = DEFAULT_DATA_ROAMING + std::to_string(slotId_);
1788         int32_t dataRoaming = static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED);
1789         dataRoaming = GetIntParameter(defaultDataRoaming.c_str(), dataRoaming);
1790         defaultDataRoamingEnable_ =
1791             (dataRoaming == static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED));
1792         TELEPHONY_LOGI(
1793             "Slot%{public}d: defaultDataRoamingEnable_ from prop is %{public}d", slotId_, defaultDataRoamingEnable_);
1794     }
1795     if (dataSwitchSettings_ == nullptr) {
1796         TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null", slotId_);
1797         return;
1798     }
1799     bool dataRoamingEnabled = false;
1800     int32_t ret = dataSwitchSettings_->QueryUserDataRoamingStatus(dataRoamingEnabled);
1801     if (ret != TELEPHONY_ERR_SUCCESS && defaultDataRoamingEnable_ != dataSwitchSettings_->IsUserDataRoamingOn()) {
1802         dataSwitchSettings_->UpdateUserDataRoamingOn(defaultDataRoamingEnable_);
1803         if (apnManager_ == nullptr) {
1804             TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
1805             return;
1806         }
1807         bool roamingState = false;
1808         if (CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0) {
1809             roamingState = true;
1810         }
1811         if (roamingState) {
1812             ApnProfileState apnState = apnManager_->GetOverallApnState();
1813             if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
1814                 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
1815                 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
1816             }
1817             EstablishAllApnsIfConnectable();
1818         } else {
1819             TELEPHONY_LOGI("Slot%{public}d: Not roaming(%{public}d), not doing anything", slotId_, roamingState);
1820         }
1821     }
1822 }
1823 
GetDefaultConfiguration()1824 void CellularDataHandler::GetDefaultConfiguration()
1825 {
1826     if (connectionManager_ == nullptr) {
1827         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1828         return;
1829     }
1830     connectionManager_->GetDefaultBandWidthsConfig();
1831     connectionManager_->GetDefaultTcpBufferConfig();
1832     GetDefaultUpLinkThresholdsConfig();
1833     GetDefaultDownLinkThresholdsConfig();
1834     defaultMobileMtuConfig_ = CellularDataUtils::GetDefaultMobileMtuConfig();
1835     TELEPHONY_LOGI("Slot%{public}d: defaultMobileMtuConfig_ = %{public}d", slotId_, defaultMobileMtuConfig_);
1836     defaultPreferApn_ = CellularDataUtils::GetDefaultPreferApnConfig();
1837     TELEPHONY_LOGI("Slot%{public}d: defaultPreferApn_ is %{public}d", slotId_, defaultPreferApn_);
1838     multipleConnectionsEnabled_ = CellularDataUtils::GetDefaultMultipleConnectionsConfig();
1839     GetSinglePdpEnabledFromOpCfg();
1840     GetDefaultDataRoamingConfig();
1841     TELEPHONY_LOGI("Slot%{public}d: multipleConnectionsEnabled_ = %{public}d, defaultDataRoamingEnable_ = %{public}d",
1842         slotId_, multipleConnectionsEnabled_, defaultDataRoamingEnable_);
1843 }
1844 
HandleRadioNrStateChanged(const AppExecFwk::InnerEvent::Pointer & event)1845 void CellularDataHandler::HandleRadioNrStateChanged(const AppExecFwk::InnerEvent::Pointer &event)
1846 {
1847     if (connectionManager_ == nullptr) {
1848         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1849         return;
1850     }
1851     TELEPHONY_LOGI("Slot%{public}d: receive event", slotId_);
1852     std::vector<std::shared_ptr<CellularDataStateMachine>> stateMachines =
1853         connectionManager_->GetAllConnectionMachine();
1854     for (const std::shared_ptr<CellularDataStateMachine> &cellularDataStateMachine : stateMachines) {
1855         InnerEvent::Pointer eventCode = InnerEvent::Get(RadioEvent::RADIO_NR_STATE_CHANGED);
1856         cellularDataStateMachine->SendEvent(eventCode);
1857     }
1858 }
1859 
HandleRadioNrFrequencyChanged(const AppExecFwk::InnerEvent::Pointer & event)1860 void CellularDataHandler::HandleRadioNrFrequencyChanged(const AppExecFwk::InnerEvent::Pointer &event)
1861 {
1862     if (connectionManager_ == nullptr) {
1863         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
1864         return;
1865     }
1866     TELEPHONY_LOGI("Slot%{public}d: receive event", slotId_);
1867     std::vector<std::shared_ptr<CellularDataStateMachine>> stateMachines =
1868         connectionManager_->GetAllConnectionMachine();
1869     for (const std::shared_ptr<CellularDataStateMachine> &cellularDataStateMachine : stateMachines) {
1870         InnerEvent::Pointer eventCode = InnerEvent::Get(RadioEvent::RADIO_NR_FREQUENCY_CHANGED);
1871         cellularDataStateMachine->SendEvent(eventCode);
1872     }
1873 }
1874 
GetDefaultUpLinkThresholdsConfig()1875 void CellularDataHandler::GetDefaultUpLinkThresholdsConfig()
1876 {
1877     upLinkThresholds_.clear();
1878     char upLinkConfig[UP_DOWN_LINK_SIZE] = { 0 };
1879     GetParameter(CONFIG_UPLINK_THRESHOLDS, CAPACITY_THRESHOLDS_FOR_UPLINK, upLinkConfig, UP_DOWN_LINK_SIZE);
1880     TELEPHONY_LOGI("Slot%{public}d: upLinkThresholds = %{public}s", slotId_, upLinkConfig);
1881     upLinkThresholds_ = CellularDataUtils::Split(upLinkConfig, ",");
1882 }
1883 
GetDefaultDownLinkThresholdsConfig()1884 void CellularDataHandler::GetDefaultDownLinkThresholdsConfig()
1885 {
1886     downLinkThresholds_.clear();
1887     char downLinkConfig[UP_DOWN_LINK_SIZE] = { 0 };
1888     GetParameter(CONFIG_DOWNLINK_THRESHOLDS, CAPACITY_THRESHOLDS_FOR_DOWNLINK, downLinkConfig, UP_DOWN_LINK_SIZE);
1889     TELEPHONY_LOGI("Slot%{public}d: downLinkThresholds_ = %{public}s", slotId_, downLinkConfig);
1890     downLinkThresholds_ = CellularDataUtils::Split(downLinkConfig, ",");
1891 }
1892 
SetRilLinkBandwidths()1893 void CellularDataHandler::SetRilLinkBandwidths()
1894 {
1895     LinkBandwidthRule linkBandwidth;
1896     CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, linkBandwidth.rat);
1897     linkBandwidth.delayMs = DELAY_SET_RIL_BANDWIDTH_MS;
1898     linkBandwidth.delayUplinkKbps = DELAY_SET_RIL_UP_DOWN_BANDWIDTH_MS;
1899     linkBandwidth.delayDownlinkKbps = DELAY_SET_RIL_UP_DOWN_BANDWIDTH_MS;
1900     for (std::string upLinkThreshold : upLinkThresholds_) {
1901         linkBandwidth.maximumUplinkKbps.push_back(atoi(upLinkThreshold.c_str()));
1902     }
1903     for (std::string downLinkThreshold : downLinkThresholds_) {
1904         linkBandwidth.maximumDownlinkKbps.push_back(atoi(downLinkThreshold.c_str()));
1905     }
1906     CoreManagerInner::GetInstance().SetLinkBandwidthReportingRule(
1907         slotId_, CellularDataEventCode::MSG_SET_RIL_BANDWIDTH, linkBandwidth, shared_from_this());
1908 }
1909 
HandleDBSettingEnableChanged(const AppExecFwk::InnerEvent::Pointer & event)1910 void CellularDataHandler::HandleDBSettingEnableChanged(const AppExecFwk::InnerEvent::Pointer &event)
1911 {
1912     if (dataSwitchSettings_ == nullptr) {
1913         TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ is null.", slotId_);
1914         return;
1915     }
1916     bool dataEnabled = true;
1917     dataSwitchSettings_->QueryUserDataStatus(dataEnabled);
1918     CoreManagerInner &coreInner = CoreManagerInner::GetInstance();
1919     const int32_t defSlotId = coreInner.GetDefaultCellularDataSlotId();
1920     if (dataEnabled && defSlotId == slotId_) {
1921         EstablishAllApnsIfConnectable();
1922     } else {
1923         ClearAllConnections(DisConnectionReason::REASON_CLEAR_CONNECTION);
1924     }
1925 }
1926 
HandleDBSettingRoamingChanged(const AppExecFwk::InnerEvent::Pointer & event)1927 void CellularDataHandler::HandleDBSettingRoamingChanged(const AppExecFwk::InnerEvent::Pointer &event)
1928 {
1929     if (event == nullptr) {
1930         return;
1931     }
1932     if (dataSwitchSettings_ == nullptr || apnManager_ == nullptr) {
1933         TELEPHONY_LOGE("Slot%{public}d: dataSwitchSettings_ or apnManager_ is null", slotId_);
1934         return;
1935     }
1936     int64_t value = event->GetParam();
1937     bool dataRoamingEnabled = false;
1938     dataSwitchSettings_->QueryUserDataRoamingStatus(dataRoamingEnabled);
1939     if (dataRoamingEnabled != value) {
1940         dataSwitchSettings_->SetUserDataRoamingOn(value);
1941         bool roamingState = false;
1942         if (CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0) {
1943             roamingState = true;
1944         }
1945         if (roamingState) {
1946             ApnProfileState apnState = apnManager_->GetOverallApnState();
1947             if (apnState == ApnProfileState::PROFILE_STATE_CONNECTING ||
1948                 apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
1949                 ClearAllConnections(DisConnectionReason::REASON_RETRY_CONNECTION);
1950             }
1951             EstablishAllApnsIfConnectable();
1952         } else {
1953             TELEPHONY_LOGI("Slot%{public}d: Not roaming(%{public}d), not doing anything", slotId_, roamingState);
1954         }
1955     } else {
1956         TELEPHONY_LOGI("Slot%{public}d: The roaming switch status has not changed", slotId_);
1957     }
1958 }
1959 
UnRegisterDataSettingObserver()1960 void CellularDataHandler::UnRegisterDataSettingObserver()
1961 {
1962     if (settingObserver_ == nullptr || roamingObserver_ == nullptr || incallObserver_ == nullptr ||
1963         cellularDataRdbObserver_ == nullptr) {
1964         TELEPHONY_LOGE("Slot%{public}d: settingObserver_ or roamingObserver_ or incallObserver_ or "
1965                        "cellularDataRdbObserver_ is null", slotId_);
1966         return;
1967     }
1968     std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
1969     if (settingHelper == nullptr) {
1970         TELEPHONY_LOGE("Slot%{public}d: settingHelper is null", slotId_);
1971         return;
1972     }
1973     Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
1974     settingHelper->UnRegisterSettingsObserver(dataEnableUri, settingObserver_);
1975 
1976     int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
1977     if (simId <= INVALID_SIM_ID) {
1978         TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
1979         return;
1980     }
1981     Uri dataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
1982     settingHelper->UnRegisterSettingsObserver(dataRoamingUri, roamingObserver_);
1983     Uri dataIncallUri(CELLULAR_DATA_SETTING_DATA_INCALL_URI);
1984     settingHelper->UnRegisterSettingsObserver(dataIncallUri, incallObserver_);
1985 
1986     std::shared_ptr<CellularDataRdbHelper> cellularDataRdbHelper = CellularDataRdbHelper::GetInstance();
1987     if (cellularDataRdbHelper == nullptr) {
1988         TELEPHONY_LOGE("Slot%{public}d: cellularDataRdbHelper is null", slotId_);
1989         return;
1990     }
1991     cellularDataRdbHelper->UnRegisterObserver(cellularDataRdbObserver_);
1992 }
1993 
RegisterDataSettingObserver()1994 void CellularDataHandler::RegisterDataSettingObserver()
1995 {
1996     if (settingObserver_ == nullptr || roamingObserver_ == nullptr || incallObserver_ == nullptr ||
1997         cellularDataRdbObserver_ == nullptr) {
1998         TELEPHONY_LOGE("Slot%{public}d: settingObserver_ or roamingObserver_ or incallObserver_ or "
1999                        "cellularDataRdbObserver_ is null", slotId_);
2000         return;
2001     }
2002     std::shared_ptr<CellularDataSettingsRdbHelper> settingHelper = CellularDataSettingsRdbHelper::GetInstance();
2003     if (settingHelper == nullptr) {
2004         TELEPHONY_LOGE("Slot%{public}d: settingHelper is null", slotId_);
2005         return;
2006     }
2007     Uri dataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
2008     settingHelper->RegisterSettingsObserver(dataEnableUri, settingObserver_);
2009 
2010     int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
2011     if (simId <= INVALID_SIM_ID) {
2012         TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
2013         return;
2014     }
2015     Uri dataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
2016     settingHelper->RegisterSettingsObserver(dataRoamingUri, roamingObserver_);
2017     Uri dataIncallUri(CELLULAR_DATA_SETTING_DATA_INCALL_URI);
2018     settingHelper->RegisterSettingsObserver(dataIncallUri, incallObserver_);
2019 
2020     std::shared_ptr<CellularDataRdbHelper> cellularDataRdbHelper = CellularDataRdbHelper::GetInstance();
2021     if (cellularDataRdbHelper == nullptr) {
2022         TELEPHONY_LOGE("Slot%{public}d: cellularDataRdbHelper is null", slotId_);
2023         return;
2024     }
2025     cellularDataRdbHelper->RegisterObserver(cellularDataRdbObserver_);
2026 }
2027 
OnRilAdapterHostDied(const AppExecFwk::InnerEvent::Pointer & event)2028 void CellularDataHandler::OnRilAdapterHostDied(const AppExecFwk::InnerEvent::Pointer &event)
2029 {
2030     if (connectionManager_ == nullptr) {
2031         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
2032         return;
2033     }
2034     TELEPHONY_LOGI("Slot%{public}d: receive event", slotId_);
2035     std::vector<std::shared_ptr<CellularDataStateMachine>> stateMachines =
2036         connectionManager_->GetAllConnectionMachine();
2037     for (const std::shared_ptr<CellularDataStateMachine> &cellularDataStateMachine : stateMachines) {
2038         InnerEvent::Pointer eventCode = InnerEvent::Get(CellularDataEventCode::MSG_SM_RIL_ADAPTER_HOST_DIED);
2039         cellularDataStateMachine->SendEvent(eventCode);
2040     }
2041 }
2042 
GetDataConnApnAttr(ApnItem::Attribute & apnAttr) const2043 void CellularDataHandler::GetDataConnApnAttr(ApnItem::Attribute &apnAttr) const
2044 {
2045     if (apnManager_ == nullptr) {
2046         TELEPHONY_LOGE("Slot%{public}d: GetDataConnApnAttr:apnManager is null", slotId_);
2047         return;
2048     }
2049     for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
2050         if (apnHolder == nullptr) {
2051             TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
2052             continue;
2053         }
2054         if (apnHolder->IsDataCallEnabled()) {
2055             sptr<ApnItem> apnItem = apnHolder->GetCurrentApn();
2056             if (apnItem == nullptr) {
2057                 continue;
2058             }
2059             apnAttr = apnItem->attr_;
2060             return;
2061         }
2062     }
2063 }
2064 
GetDataConnIpType() const2065 std::string CellularDataHandler::GetDataConnIpType() const
2066 {
2067     if (apnManager_ == nullptr) {
2068         TELEPHONY_LOGE("Slot%{public}d: GetDataConnApnAttr:apnManager is null", slotId_);
2069         return "";
2070     }
2071     for (const sptr<ApnHolder> &apnHolder : apnManager_->GetAllApnHolder()) {
2072         if (apnHolder == nullptr) {
2073             TELEPHONY_LOGE("Slot%{public}d: apnHolder is null", slotId_);
2074             continue;
2075         }
2076         if (apnHolder->IsDataCallEnabled()) {
2077             auto stateMachine = apnHolder->GetCellularDataStateMachine();
2078             if (stateMachine == nullptr) {
2079                 TELEPHONY_LOGE("Slot%{public}d: stateMachine is null", slotId_);
2080                 continue;
2081             }
2082             return stateMachine->GetIpType();
2083         }
2084     }
2085     return "";
2086 }
2087 
GetDataRecoveryState()2088 int32_t CellularDataHandler::GetDataRecoveryState()
2089 {
2090     if (connectionManager_ == nullptr) {
2091         TELEPHONY_LOGE("Slot%{public}d: connectionManager is null", slotId_);
2092         return -1;
2093     }
2094     return connectionManager_->GetDataRecoveryState();
2095 }
2096 
HandleFactoryReset(const InnerEvent::Pointer & event)2097 void CellularDataHandler::HandleFactoryReset(const InnerEvent::Pointer &event)
2098 {
2099     TELEPHONY_LOGI("Slot%{public}d: factory reset", slotId_);
2100     SetCellularDataEnable(true);
2101     SetCellularDataRoamingEnabled(defaultDataRoamingEnable_);
2102     if (apnManager_ == nullptr) {
2103         TELEPHONY_LOGE("Slot%{public}d: apnManager_ is null", slotId_);
2104         return;
2105     }
2106     apnManager_->ResetApns(slotId_);
2107 }
2108 
IsNeedDoRecovery(bool needDoRecovery) const2109 void CellularDataHandler::IsNeedDoRecovery(bool needDoRecovery) const
2110 {
2111     if (connectionManager_ == nullptr) {
2112         TELEPHONY_LOGE("Slot%{public}d: in IsNeedDoRecovery connectionManager_ is null", slotId_);
2113         return;
2114     }
2115     connectionManager_->IsNeedDoRecovery(needDoRecovery);
2116 }
2117 
OnCleanAllDataConnectionsDone(const AppExecFwk::InnerEvent::Pointer & event)2118 void CellularDataHandler::OnCleanAllDataConnectionsDone(const AppExecFwk::InnerEvent::Pointer &event)
2119 {
2120     TELEPHONY_LOGI("Slot%{public}d: receive OnCleanAllDataConnectionsDone event", slotId_);
2121 }
2122 
IsVSimSlotId(int32_t slotId)2123 bool CellularDataHandler::IsVSimSlotId(int32_t slotId)
2124 {
2125     if (TELEPHONY_EXT_WRAPPER.getVSimSlotId_) {
2126         int vSimSlotId = INVALID_SLOT_ID;
2127         TELEPHONY_EXT_WRAPPER.getVSimSlotId_(vSimSlotId);
2128         return vSimSlotId == slotId;
2129     }
2130     return false;
2131 }
2132 
CheckForCompatibleDataConnection(sptr<ApnHolder> & apnHolder)2133 std::shared_ptr<CellularDataStateMachine> CellularDataHandler::CheckForCompatibleDataConnection(
2134     sptr<ApnHolder> &apnHolder)
2135 {
2136     std::shared_ptr<CellularDataStateMachine> potentialDc = nullptr;
2137     if (apnHolder == nullptr || apnManager_ == nullptr) {
2138         TELEPHONY_LOGE("Slot%{public}d: CheckForCompatibleDataConnection failed, apnHolder or apnManager_null",
2139             slotId_);
2140         return potentialDc;
2141     }
2142     std::vector<sptr<ApnItem>> dunApnList;
2143     if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DUN) {
2144         apnManager_->FetchDunApns(dunApnList, slotId_);
2145     }
2146     if (dunApnList.size() == 0) {
2147         return potentialDc;
2148     }
2149     if (connectionManager_ == nullptr) {
2150         return potentialDc;
2151     }
2152     auto allDCs = connectionManager_->GetAllConnectionMachine();
2153     bool isRoaming = false;
2154     int32_t result = IsCellularDataRoamingEnabled(isRoaming);
2155     if (result != TELEPHONY_ERR_SUCCESS) {
2156         isRoaming = false;
2157     }
2158     for(const auto& curDc : allDCs) {
2159         sptr<ApnItem> apnItem = curDc->GetApnItem();
2160         for(const auto& dunItem : dunApnList) {
2161             if (!apnHolder->IsCompatibleApnItem(apnItem, dunItem, isRoaming)) {
2162                 continue;
2163             }
2164             if (curDc->IsActiveState()) {
2165                 return curDc;
2166             } else if (curDc->IsActivatingState()) {
2167                 potentialDc = curDc;
2168             } else if (curDc->IsDisconnectingState()) {
2169                 if (potentialDc == nullptr) {
2170                     potentialDc = curDc;
2171                 }
2172             }
2173         }
2174     }
2175     return potentialDc;
2176 }
2177 
IsGsm()2178 bool CellularDataHandler::IsGsm()
2179 {
2180     bool isGsm = false;
2181     CoreManagerInner::GetInstance().IsGsm(slotId_, isGsm);
2182     return isGsm;
2183 }
2184 
IsCdma()2185 bool CellularDataHandler::IsCdma()
2186 {
2187     bool isCdma = false;
2188     CoreManagerInner::GetInstance().IsCdma(slotId_, isCdma);
2189     return isCdma;
2190 }
2191 } // namespace Telephony
2192 } // namespace OHOS
2193