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