diff --git a/services/include/cellular_data_handler.h b/services/include/cellular_data_handler.h
index 2f82e1ac0dce3fa82527e5eabcdb4543ee3e7fc5..fa94b5fe22423a88440da707c96eb3be19a822b6 100644
--- a/services/include/cellular_data_handler.h
+++ b/services/include/cellular_data_handler.h
@@ -156,6 +156,7 @@ private:
     void SetNetRequest(NetRequest &request, const std::unique_ptr<NetRequest> &netRequest);
     void SendEstablishDataConnectionEvent(int32_t id);
     bool IsSimStateReadyOrLoaded();
+    void UpdateCellularDataConnectState(const std::string &apnType);
 
 private:
     sptr<ApnManager> apnManager_;
diff --git a/services/src/cellular_data_handler.cpp b/services/src/cellular_data_handler.cpp
index bc732ad4b952732159f0b614025c504c7f79d05f..9a3c7f2e170122d83cc7e7abd255173b6ffd3616 100644
--- a/services/src/cellular_data_handler.cpp
+++ b/services/src/cellular_data_handler.cpp
@@ -262,14 +262,6 @@ void CellularDataHandler::ClearAllConnections(DisConnectionReason reason)
         TELEPHONY_LOGE("Slot%{public}d: apnManager is null", slotId_);
         return;
     }
-    ApnProfileState currentState = apnManager_->GetOverallApnState();
-    if (currentState == ApnProfileState::PROFILE_STATE_CONNECTED ||
-        currentState == ApnProfileState::PROFILE_STATE_CONNECTING) {
-        int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
-        CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
-        StateNotification::GetInstance().UpdateCellularDataConnectState(
-            slotId_, PROFILE_STATE_DISCONNECTING, networkType);
-    }
     for (const sptr<ApnHolder> &apn : apnManager_->GetAllApnHolder()) {
         ClearConnection(apn, reason);
     }
@@ -763,11 +755,7 @@ bool CellularDataHandler::EstablishDataConnection(sptr<ApnHolder> &apnHolder, in
     apnHolder->SetCellularDataStateMachine(cellularDataStateMachine);
     bool roamingState = CoreManagerInner::GetInstance().GetPsRoamingState(slotId_) > 0;
     bool userDataRoaming = dataSwitchSettings_->IsUserDataRoamingOn();
-    if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
-        apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
-        ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
-        StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, radioTech);
-    }
+    UpdateCellularDataConnectState(apnHolder->GetApnType());
     std::unique_ptr<DataConnectionParams> object = std::make_unique<DataConnectionParams>(
         apnHolder, apnItem->attr_.profileId_, radioTech, roamingState, userDataRoaming, true);
     TELEPHONY_LOGI("Slot%{public}d: MSG_SM_CONNECT profileId:%{public}d type:%{public}s networkType:%{public}d",
@@ -824,14 +812,7 @@ void CellularDataHandler::EstablishDataConnectionComplete(const InnerEvent::Poin
             InnerEvent::Pointer incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_CONNECTED);
             incallDataStateMachine_->SendEvent(incallEvent);
         }
-        int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
-        CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
-        if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
-            apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
-            ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
-            StateNotification::GetInstance().UpdateCellularDataConnectState(
-                slotId_, apnState, networkType);
-        }
+        UpdateCellularDataConnectState(apnHolder->GetApnType());
     }
 }
 
@@ -846,26 +827,27 @@ void CellularDataHandler::DisconnectDataComplete(const InnerEvent::Pointer &even
         TELEPHONY_LOGE("Slot%{public}d: event or apnManager or connectionManager_ is null", slotId_);
         return;
     }
-    std::unique_ptr<DataDisconnectParams> object = event->GetUniqueObject<DataDisconnectParams>();
-    if (object == nullptr) {
-        TELEPHONY_LOGE("Slot%{public}d: object is null", slotId_);
+    auto netInfo = event->GetSharedObject<SetupDataCallResultInfo>();
+    if (netInfo == nullptr) {
+        TELEPHONY_LOGE("Slot%{public}d: netInfo is null", slotId_);
         return;
     }
-    int32_t apnId = apnManager_->FindApnIdByApnName(object->GetApnType());
+    int32_t apnId = netInfo->flag;
     sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(apnId);
     if (apnHolder == nullptr) {
         TELEPHONY_LOGE("Slot%{public}d: apnHolder is null, apnId is %{public}d", slotId_, apnId);
         return;
     }
-    DisConnectionReason reason = object->GetReason();
+    DisConnectionReason reason = static_cast<DisConnectionReason>(netInfo->reason);
     apnHolder->SetApnState(PROFILE_STATE_IDLE);
-    int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
-    CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
-    if (apnHolder->GetApnType() == DATA_CONTEXT_ROLE_DEFAULT ||
-        apnHolder->GetApnType() == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
-        ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
-        StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, networkType);
+    auto stateMachine = connectionManager_->GetActiveConnectionByCid(netInfo->cid);
+    if (stateMachine == nullptr) {
+        TELEPHONY_LOGE("stateMachine is null");
+        return;
     }
+    stateMachine->UpdateNetworkInfo(*netInfo);
+    connectionManager_->RemoveActiveConnectionByCid(stateMachine->GetCid());
+    UpdateCellularDataConnectState(apnHolder->GetApnType());
     UpdatePhysicalConnectionState(connectionManager_->isNoActiveConnection());
     if (apnHolder->IsDataCallEnabled()) {
         if (apnHolder->GetApnState() == PROFILE_STATE_IDLE || apnHolder->GetApnState() == PROFILE_STATE_FAILED) {
@@ -879,8 +861,7 @@ void CellularDataHandler::DisconnectDataComplete(const InnerEvent::Pointer &even
         connectionManager_->StopStallDetectionTimer();
         connectionManager_->EndNetStatistics();
         if (incallDataStateMachine_ != nullptr) {
-            InnerEvent::Pointer incallEvent =
-                InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_DISCONNECTED);
+            auto incallEvent = InnerEvent::Get(CellularDataEventCode::MSG_SM_INCALL_DATA_DATA_DISCONNECTED);
             incallDataStateMachine_->SendEvent(incallEvent);
         }
     }
@@ -1100,6 +1081,16 @@ bool CellularDataHandler::IsSimStateReadyOrLoaded()
     return (simState == SimState::SIM_STATE_READY || simState == SimState::SIM_STATE_LOADED);
 }
 
+void CellularDataHandler::UpdateCellularDataConnectState(const std::string &apnType)
+{
+    int32_t networkType = static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_INVALID);
+    CoreManagerInner::GetInstance().GetPsRadioTech(slotId_, networkType);
+    if (apnType == DATA_CONTEXT_ROLE_DEFAULT || apnType == DATA_CONTEXT_ROLE_INTERNAL_DEFAULT) {
+        ApnProfileState apnState = apnManager_->GetOverallDefaultApnState();
+        StateNotification::GetInstance().UpdateCellularDataConnectState(slotId_, apnState, networkType);
+    }
+}
+
 void CellularDataHandler::HandleSettingSwitchChanged(const InnerEvent::Pointer &event)
 {
     if (event == nullptr) {
@@ -2239,27 +2230,27 @@ void CellularDataHandler::HandleUpdateNetInfo(const AppExecFwk::InnerEvent::Poin
         return;
     }
 
-    std::shared_ptr<SetupDataCallResultInfo> info = event->GetSharedObject<SetupDataCallResultInfo>();
-    if (info == nullptr) {
+    std::shared_ptr<SetupDataCallResultInfo> netInfo = event->GetSharedObject<SetupDataCallResultInfo>();
+    if (netInfo == nullptr) {
         TELEPHONY_LOGE("info is null");
         return;
     }
 
-    sptr<ApnHolder> apnHolder = apnManager_->GetApnHolder(apnManager_->FindApnNameByApnId(info->flag));
+    sptr<ApnHolder> apnHolder = apnManager_->FindApnHolderById(netInfo->flag);
     if (apnHolder == nullptr) {
-        TELEPHONY_LOGE("Slot%{public}d: flag:%{public}d complete apnHolder is null", slotId_, info->flag);
+        TELEPHONY_LOGE("Slot%{public}d: flag:%{public}d complete apnHolder is null", slotId_, netInfo->flag);
         return;
     }
     if (apnHolder->GetApnState() != PROFILE_STATE_CONNECTING && apnHolder->GetApnState() != PROFILE_STATE_CONNECTED) {
         TELEPHONY_LOGE("Slot%{public}d: apnHolder is not connecting or connected", slotId_);
         return;
     }
-    std::shared_ptr<CellularDataStateMachine> stateMachine = connectionManager_->GetActiveConnectionByCid(info->cid);
+    auto stateMachine = connectionManager_->GetActiveConnectionByCid(netInfo->cid);
     if (stateMachine == nullptr) {
         TELEPHONY_LOGE("stateMachine is null");
         return;
     }
-    stateMachine->UpdateNetworkInfo(*info);
+    stateMachine->UpdateNetworkInfo(*netInfo);
 }
 
 bool CellularDataHandler::IsGsm()
diff --git a/services/src/state_machine/inactive.cpp b/services/src/state_machine/inactive.cpp
index 58f472a44b1db207e5a2b940b551f22299abf3af..248721502e296902ea646576e6547db3082de91f 100644
--- a/services/src/state_machine/inactive.cpp
+++ b/services/src/state_machine/inactive.cpp
@@ -34,21 +34,21 @@ void Inactive::StateBegin()
     isActive_ = true;
     if (deActiveApnTypeId_ != ERROR_APN_ID) {
         // set net manager connection false
-        CellularDataNetAgent &netAgent = CellularDataNetAgent::GetInstance();
-        int32_t supplierId = netAgent.GetSupplierId(stateMachine->GetSlotId(), stateMachine->GetCapability());
         if (stateMachine->netSupplierInfo_ != nullptr) {
             stateMachine->netSupplierInfo_->isAvailable_ = false;
-            netAgent.UpdateNetSupplierInfo(supplierId, stateMachine->netSupplierInfo_);
         }
         // send MSG_DISCONNECT_DATA_COMPLETE to CellularDataHandler
-        std::string apnType = ApnManager::FindApnNameByApnId(deActiveApnTypeId_);
-        std::unique_ptr<DataDisconnectParams> object = std::make_unique<DataDisconnectParams>(apnType, reason_);
-        if (object == nullptr) {
+        auto netInfo = std::make_shared<SetupDataCallResultInfo>();
+        if (netInfo == nullptr) {
             TELEPHONY_LOGE("Create data disconnect params failed");
             return;
         }
+        netInfo->cid = stateMachine->cid_;
+        netInfo->flag = deActiveApnTypeId_;
+        netInfo->reason = static_cast<int32_t>(reason_);
+        netInfo->active = 0;
         AppExecFwk::InnerEvent::Pointer event =
-            AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DISCONNECT_DATA_COMPLETE, object);
+            AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DISCONNECT_DATA_COMPLETE, netInfo);
         if (event == nullptr) {
             TELEPHONY_LOGE("Create event failed");
             return;
@@ -60,9 +60,6 @@ void Inactive::StateBegin()
         reason_ = DisConnectionReason::REASON_RETRY_CONNECTION;
     }
     stateMachine->SetCurrentState(sptr<State>(this));
-    if (stateMachine->cdConnectionManager_ != nullptr) {
-        stateMachine->cdConnectionManager_->RemoveActiveConnectionByCid(stateMachine->GetCid());
-    }
 }
 
 void Inactive::StateEnd()