diff --git a/common/include/constants/distributed_camera_constants.h b/common/include/constants/distributed_camera_constants.h
index ca57b9f6e0bbc2a126acf27c7ea151f7dfa37d6b..6ecdd4c9d8972e3982becd8e6592fc36c476f0d9 100644
--- a/common/include/constants/distributed_camera_constants.h
+++ b/common/include/constants/distributed_camera_constants.h
@@ -83,6 +83,15 @@ const uint32_t DCAMERA_MAX_RECV_DATA_LEN = 104857600;
 const uint16_t DCAMERA_MAX_RECV_EXT_LEN = 65535;
 const uint32_t DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID = 4803;
 const uint32_t DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID = 4804;
+const std::string SESSION_HEAD = "ohos.dhardware.dcamera_";
+const std::string DEVICE_ID_0 = "device/0";
+const std::string DEVICE_ID_1 = "device/1";
+const std::string SENDER_SESSION_NAME_CONTROL = "_control_sender";
+const std::string SENDER_SESSION_NAME_DATA_SNAPSHOT = "_dataSnapshot_sender";
+const std::string SENDER_SESSION_NAME_DATA_CONTINUE = "_dataContinue_sender";
+const std::string RECEIVER_SESSION_NAME_CONTROL = "_control_receiver";
+const std::string RECEIVER_SESSION_NAME_DATA_SNAPSHOT = "_dataSnapshot_receiver";
+const std::string RECEIVER_SESSION_NAME_DATA_CONTINUE = "_dataContinue_receiver";
 const std::string DCAMERA_PKG_NAME = "ohos.dhardware.dcamera";
 const std::string SNAP_SHOT_SESSION_FLAG = "dataSnapshot";
 const std::string CONTINUE_SESSION_FLAG = "dataContinue";
@@ -161,6 +170,7 @@ const std::string SINK_PHOTO = "_SinkPhoto.jpg";
 const std::string AFTER_ENCODE = "SinkAfterEncode.h265";
 const std::string BEFORE_DECODE = "SourceBeforeDecode.h265";
 const std::string CAMERA_HICOLLIE = "CameraHicollie";
+const std::string SEPARATE_SINK_VERSION = "2.0";
 } // namespace DistributedHardware
 } // namespace OHOS
 #endif // OHOS_DISTRIBUTED_CAMERA_CONSTANTS_H
\ No newline at end of file
diff --git a/common/include/utils/dcamera_utils_tools.h b/common/include/utils/dcamera_utils_tools.h
index 5c61fb2f059a16f56bd61ca539af55b78a1e5304..46b72c709c5e281663cb9d9d31886aef6abd079a 100644
--- a/common/include/utils/dcamera_utils_tools.h
+++ b/common/include/utils/dcamera_utils_tools.h
@@ -30,6 +30,8 @@
 namespace OHOS {
 namespace DistributedHardware {
 const std::string BASE_64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static bool g_isSoftbusConnectSource = false;
+static bool g_isSoftbusConnectSink = false;
 
 int32_t GetLocalDeviceNetworkId(std::string& networkId);
 int64_t GetNowTimeStampMs();
diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
index 44d67ec1cbc0325613af70f4f0f932422b89fc87..e053ae9d847a48f55b28fb1cc45835d4a5c9e62b 100644
--- a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
+++ b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
@@ -57,7 +57,7 @@ public:
     void OnStateChanged(std::shared_ptr<DCameraEvent>& event);
     void OnMetadataResult(std::vector<std::shared_ptr<DCameraSettings>>& settings);
 
-    void OnSessionState(int32_t state);
+    void OnSessionState(int32_t state, std::string networkId);
     void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail);
     void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers);
 
@@ -83,6 +83,8 @@ private:
     bool CheckPermission();
     void ProcessFrameTrigger(const AppExecFwk::InnerEvent::Pointer &event);
     void ProcessPostAuthorization(const AppExecFwk::InnerEvent::Pointer &event);
+    int32_t CreateCtrlSession();
+    int32_t CheckSensitive();
 
     bool isInit_;
     int32_t sessionState_;
diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.h b/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.h
index 18c8f33acc59f2197351421026d709f24f7fab1e..55ebaa626d111fc79ecc9e363ff7f388ac6caabc 100644
--- a/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.h
+++ b/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -27,7 +27,7 @@ public:
     explicit DCameraSinkControllerChannelListener(std::shared_ptr<DCameraSinkController>& controller);
     ~DCameraSinkControllerChannelListener() override = default;
 
-    void OnSessionState(int32_t state) override;
+    void OnSessionState(int32_t state, std::string networkId) override;
     void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail) override;
     void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers) override;
 
diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_output_channel_listener.h b/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_output_channel_listener.h
index c390a4578608edcf6337657054f1239641229531..48f2ced9d2cea85e87716b86c97ee5862d525291 100644
--- a/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_output_channel_listener.h
+++ b/services/cameraservice/sinkservice/include/distributedcameramgr/listener/dcamera_sink_output_channel_listener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -27,7 +27,7 @@ public:
     DCameraSinkOutputChannelListener(DCStreamType type, std::shared_ptr<DCameraSinkOutput>& output);
     ~DCameraSinkOutputChannelListener() override = default;
 
-    void OnSessionState(int32_t state) override;
+    void OnSessionState(int32_t state, std::string networkId) override;
     void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail) override;
     void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers) override;
 
diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
index 7b258cc97446e59e0ba91341cfd8c51b4debaa8a..faa303483aa97e32e8fc259f4ae764d838a222a1 100644
--- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
+++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
@@ -203,6 +203,7 @@ int32_t DCameraSinkController::GetCameraInfo(std::shared_ptr<DCameraInfo>& camIn
 int32_t DCameraSinkController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& openInfo)
 {
     DHLOGI("DCameraSinkController OpenChannel Start, dhId: %{public}s", GetAnonyString(dhId_).c_str());
+    g_isSoftbusConnectSink = false;
     if (!CheckPermission()) {
         DHLOGE("DCameraSinkController OpenChannel fail, CheckPermission fail");
         return DCAMERA_WRONG_STATE;
@@ -212,25 +213,11 @@ int32_t DCameraSinkController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& ope
         return DCAMERA_WRONG_STATE;
     }
     srcDevId_ = openInfo->sourceDevId_;
-    int32_t ret = sinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_QUERY_RESOURCE, PAGE_SUBTYPE,
-        srcDevId_, isSensitive_, isSameAccount_);
-    CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "Query resource failed, ret: %{public}d", ret);
-    DHLOGI("OpenChannel isSensitive: %{public}d, isSameAccout: %{public}d", isSensitive_, isSameAccount_);
-    if (isSensitive_ && !isSameAccount_) {
-        DHLOGE("Privacy resource must be logged in with the same account.");
-        return DCAMERA_BAD_VALUE;
-    }
-
-    if (isCheckSecLevel_) {
-        std::string sinkDevId;
-        ret = GetLocalDeviceNetworkId(sinkDevId);
-        CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "GetLocalDeviceNetworkId failed, ret: %{public}d", ret);
-        if (isSensitive_ && !CheckDeviceSecurityLevel(srcDevId_, sinkDevId)) {
-            DHLOGE("Check device security level failed!");
-            return DCAMERA_BAD_VALUE;
-        }
+    int32_t ret = CheckSensitive();
+    if (ret != DCAMERA_OK) {
+        DHLOGE("check sensitive error, ret %{public}d", ret);
+        return ret;
     }
-    DCameraLowLatency::GetInstance().EnableLowLatency();
     std::vector<DCameraIndex> indexs;
     indexs.push_back(DCameraIndex(srcDevId_, dhId_));
     auto controller = std::shared_ptr<DCameraSinkController>(shared_from_this());
@@ -267,29 +254,30 @@ int32_t DCameraSinkController::CloseChannel()
 {
     DHLOGI("DCameraSinkController CloseChannel Start, dhId: %{public}s", GetAnonyString(dhId_).c_str());
     std::lock_guard<std::mutex> autoLock(channelLock_);
-    DCameraLowLatency::GetInstance().DisableLowLatency();
-    DCameraSinkServiceIpc::GetInstance().DeleteSourceRemoteCamSrv(srcDevId_);
-    srcDevId_.clear();
-    if (channel_ == nullptr) {
-        return DCAMERA_BAD_VALUE;
-    }
-    int32_t ret = channel_->ReleaseSession();
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSinkController release channel failed, dhId: %{public}s, ret: %{public}d",
-               GetAnonyString(dhId_).c_str(), ret);
-    }
+    if (!g_isSoftbusConnectSink) {
+        DCameraSinkServiceIpc::GetInstance().DeleteSourceRemoteCamSrv(srcDevId_);
+        if (channel_ == nullptr) {
+            return DCAMERA_BAD_VALUE;
+        }
+        int32_t ret = channel_->ReleaseSession();
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSinkController release channel failed, dhId: %{public}s, ret: %{public}d",
+                GetAnonyString(dhId_).c_str(), ret);
+        }
 
-    ret = output_->CloseChannel();
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSinkController CloseChannel failed, dhId: %{public}s, ret: %{public}d",
-               GetAnonyString(dhId_).c_str(), ret);
+        ret = output_->CloseChannel();
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSinkController CloseChannel failed, dhId: %{public}s, ret: %{public}d",
+                GetAnonyString(dhId_).c_str(), ret);
+        }
     }
+    srcDevId_.clear();
     sessionState_ = DCAMERA_CHANNEL_STATE_DISCONNECTED;
     if (isPageStatus_.load()) {
         bool isSensitive = false;
         bool isSameAccout = false;
-        ret = sinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, PAGE_SUBTYPE, srcDevId_,
-            isSensitive, isSameAccout);
+        int32_t ret = sinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, PAGE_SUBTYPE,
+            srcDevId_, isSensitive, isSameAccout);
         if (ret != DCAMERA_OK) {
             DHLOGE("close page failed, ret: %{public}d", ret);
         }
@@ -326,10 +314,49 @@ int32_t DCameraSinkController::Init(std::vector<DCameraIndex>& indexs)
         std::make_shared<DCameraSinkController::DCameraSinkContrEventHandler>(runner, shared_from_this());
     isInit_ = true;
     initCallback_ = std::make_shared<DeviceInitCallback>();
+    g_isSoftbusConnectSink = true;
+    ret = CreateCtrlSession();
+    if (ret != DCAMERA_OK) {
+        DHLOGE("CreateCtrlSessiion init failed, dhId: %{public}s, ret: %{public}d", GetAnonyString(dhId_).c_str(), ret);
+        return ret;
+    }
+    std::shared_ptr<DCameraChannelInfo> info = std::make_shared<DCameraChannelInfo>();
+    info->sourceDevId_ = "";
+    DCameraChannelDetail continueChInfo(CONTINUE_SESSION_FLAG, CONTINUOUS_FRAME);
+    DCameraChannelDetail snapShotChInfo(SNAP_SHOT_SESSION_FLAG, SNAPSHOT_FRAME);
+    info->detail_.push_back(continueChInfo);
+    info->detail_.push_back(snapShotChInfo);
+    ret = ChannelNeg(info);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("ChannelNeg init failed, dhId: %{public}s, ret: %{public}d", GetAnonyString(dhId_).c_str(), ret);
+        return ret;
+    }
     DHLOGI("DCameraSinkController Init %{public}s success", GetAnonyString(dhId_).c_str());
     return DCAMERA_OK;
 }
 
+int32_t DCameraSinkController::CreateCtrlSession()
+{
+    DHLOGI("DCameraSinkController CreateCtrlSessiion Start, dhId: %{public}s", GetAnonyString(dhId_).c_str());
+    if (sessionState_ != DCAMERA_CHANNEL_STATE_DISCONNECTED) {
+        DHLOGE("wrong state, dhId: %{public}s, sessionState: %{public}d", GetAnonyString(dhId_).c_str(), sessionState_);
+        return DCAMERA_WRONG_STATE;
+    }
+    DCameraLowLatency::GetInstance().EnableLowLatency();
+    std::vector<DCameraIndex> indexs;
+    indexs.push_back(DCameraIndex("", dhId_));
+    auto controller = std::shared_ptr<DCameraSinkController>(shared_from_this());
+    std::shared_ptr<ICameraChannelListener> listener =
+        std::make_shared<DCameraSinkControllerChannelListener>(controller);
+    int32_t ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("channel create session failed, dhId: %{public}s, ret: %{public}d", GetAnonyString(dhId_).c_str(), ret);
+        return ret;
+    }
+    DHLOGI("DCameraSinkController CreateCtrlSessiion %{public}s success", GetAnonyString(dhId_).c_str());
+    return DCAMERA_OK;
+}
+
 int32_t DCameraSinkController::UnInit()
 {
     DHLOGI("DCameraSinkController UnInit dhId: %{public}s", GetAnonyString(dhId_).c_str());
@@ -346,6 +373,24 @@ int32_t DCameraSinkController::UnInit()
             GetAnonyString(dhId_).c_str(), ret);
     }
 
+    DCameraLowLatency::GetInstance().DisableLowLatency();
+    if (g_isSoftbusConnectSink) {
+        if (channel_ != nullptr) {
+            ret = channel_->ReleaseSession();
+            if (ret != DCAMERA_OK) {
+                DHLOGE("DCameraSinkController release channel failed, dhId: %{public}s, ret: %{public}d",
+                    GetAnonyString(dhId_).c_str(), ret);
+            }
+        }
+        if (output_ != nullptr) {
+            ret = output_->CloseChannel();
+            if (ret != DCAMERA_OK) {
+                DHLOGE("DCameraSinkController output CloseChannel failed, dhId: %{public}s, ret: %{public}d",
+                    GetAnonyString(dhId_).c_str(), ret);
+            }
+        }
+    }
+
     if (output_ != nullptr) {
         ret = output_->UnInit();
         if (ret != DCAMERA_OK) {
@@ -458,7 +503,7 @@ void DCameraSinkController::OnMetadataResult(std::vector<std::shared_ptr<DCamera
     DHLOGI("DCameraSinkController::OnMetadataResult dhId: %{public}s success", GetAnonyString(dhId_).c_str());
 }
 
-void DCameraSinkController::OnSessionState(int32_t state)
+void DCameraSinkController::OnSessionState(int32_t state, std::string networkId)
 {
     DHLOGI("DCameraSinkController::OnSessionState dhId: %{public}s, state: %{public}d",
         GetAnonyString(dhId_).c_str(), state);
@@ -467,9 +512,21 @@ void DCameraSinkController::OnSessionState(int32_t state)
         case DCAMERA_CHANNEL_STATE_CONNECTING:
             DHLOGI("channel is connecting");
             break;
-        case DCAMERA_CHANNEL_STATE_CONNECTED:
+        case DCAMERA_CHANNEL_STATE_CONNECTED: {
             DHLOGI("channel is connected");
+            if (!g_isSoftbusConnectSink) {
+                break;
+            }
+            srcDevId_ = networkId;
+            int32_t ret = CheckSensitive();
+            if (ret != DCAMERA_OK) {
+                DHLOGE("Check sensitive error. ret %{public}d.", ret);
+                return;
+            }
+            ret = PullUpPage();
+            CHECK_AND_RETURN_LOG(ret != DCAMERA_OK, "PullUpPage failed");
             break;
+        }
         case DCAMERA_CHANNEL_STATE_DISCONNECTED:
             DHLOGI("channel is disconnected");
             std::thread([this]() {
@@ -495,6 +552,33 @@ void DCameraSinkController::OnSessionState(int32_t state)
     }
 }
 
+int32_t DCameraSinkController::CheckSensitive()
+{
+    if (sinkCallback_ == nullptr) {
+        DHLOGE("check sensitive callback is nullptr.");
+        return DCAMERA_BAD_VALUE;
+    }
+    int32_t ret = sinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_QUERY_RESOURCE, PAGE_SUBTYPE,
+        srcDevId_, isSensitive_, isSameAccount_);
+    CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "Query resource failed, ret: %{public}d", ret);
+    DHLOGI("OpenChannel isSensitive: %{public}d, isSameAccout: %{public}d", isSensitive_, isSameAccount_);
+    if (isSensitive_ && !isSameAccount_) {
+        DHLOGE("Privacy resource must be logged in with the same account.");
+        return DCAMERA_BAD_VALUE;
+    }
+
+    if (isCheckSecLevel_) {
+        std::string sinkDevId;
+        ret = GetLocalDeviceNetworkId(sinkDevId);
+        CHECK_AND_RETURN_RET_LOG(ret != DCAMERA_OK, ret, "GetLocalDeviceNetworkId failed, ret: %{public}d", ret);
+        if (isSensitive_ && !CheckDeviceSecurityLevel(srcDevId_, sinkDevId)) {
+            DHLOGE("Check device security level failed!");
+            return DCAMERA_BAD_VALUE;
+        }
+    }
+    return DCAMERA_OK;
+}
+
 void DCameraSinkController::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
 {
     DHLOGI("DCameraSinkController::OnSessionError dhId: %{public}s, eventType: %{public}d, eventReason: %{public}d,"
@@ -585,7 +669,7 @@ int32_t DCameraSinkController::HandleReceivedData(std::shared_ptr<DataBuffer>& d
     cJSON_Delete(rootValue);
     if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_CAPTURE) == 0)) {
         DCameraCaptureInfoCmd captureInfoCmd;
-        int ret = captureInfoCmd.Unmarshal(jsonStr);
+        int32_t ret = captureInfoCmd.Unmarshal(jsonStr);
         if (ret != DCAMERA_OK) {
             DHLOGE("Capture Info Unmarshal failed, dhId: %{public}s ret: %{public}d",
                 GetAnonyString(dhId_).c_str(), ret);
@@ -595,13 +679,17 @@ int32_t DCameraSinkController::HandleReceivedData(std::shared_ptr<DataBuffer>& d
         return StartCapture(captureInfoCmd.value_, sceneMode_);
     } else if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_UPDATE_METADATA) == 0)) {
         DCameraMetadataSettingCmd metadataSettingCmd;
-        int ret = metadataSettingCmd.Unmarshal(jsonStr);
+        int32_t ret = metadataSettingCmd.Unmarshal(jsonStr);
         if (ret != DCAMERA_OK) {
             DHLOGE("Metadata Setting Unmarshal failed, dhId: %{public}s ret: %{public}d",
                    GetAnonyString(dhId_).c_str(), ret);
             return ret;
         }
         return UpdateSettings(metadataSettingCmd.value_);
+    } else if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_STOP_CAPTURE) == 0)) {
+        return StopCapture();
+    } else if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_CLOSE_CHANNEL) == 0)) {
+        return CloseChannel();
     }
     return DCAMERA_BAD_VALUE;
 }
diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.cpp
index 4203ca5321148eb86d0bd66534d15b3619fc58be..30fd3d73c4f3c68430724c6ea638371d16d1415c 100644
--- a/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.cpp
+++ b/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_controller_channel_listener.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -24,14 +24,14 @@ DCameraSinkControllerChannelListener::DCameraSinkControllerChannelListener(
 {
 }
 
-void DCameraSinkControllerChannelListener::OnSessionState(int32_t state)
+void DCameraSinkControllerChannelListener::OnSessionState(int32_t state, std::string networkId)
 {
     std::shared_ptr<DCameraSinkController> controller = controller_.lock();
     if (controller == nullptr) {
         DHLOGE("DCameraSinkControllerChannelListener::OnSessionState controller is null");
         return;
     }
-    controller->OnSessionState(state);
+    controller->OnSessionState(state, networkId);
 }
 
 void DCameraSinkControllerChannelListener::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_output_channel_listener.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_output_channel_listener.cpp
index d2649c20b078a72e813b0ba29b358f77f2de95b9..0ada4dc05cb7964667323784153712fb8e83bc41 100644
--- a/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_output_channel_listener.cpp
+++ b/services/cameraservice/sinkservice/src/distributedcameramgr/listener/dcamera_sink_output_channel_listener.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -24,7 +24,7 @@ DCameraSinkOutputChannelListener::DCameraSinkOutputChannelListener(
 {
 }
 
-void DCameraSinkOutputChannelListener::OnSessionState(int32_t state)
+void DCameraSinkOutputChannelListener::OnSessionState(int32_t state, std::string networkId)
 {
     std::shared_ptr<DCameraSinkOutput> output = output_.lock();
     if (output == nullptr) {
diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp
index 16845901303d03472f65a6a198badd0f3b268bd1..480aa65dbf6698b7f5d2e87ad034e845db4381d8 100644
--- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp
+++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_controller_test.cpp
@@ -312,14 +312,14 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_008, TestSize.L
  */
 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.Level1)
 {
-    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTING);
+    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTING, "");
 
     DCameraInfoCmd cmd;
     cmd.value_ = std::make_shared<DCameraInfo>();
     int32_t ret = controller_->GetCameraInfo(cmd.value_);
     EXPECT_EQ(DCAMERA_OK, ret);
     int32_t state = -1;
-    controller_->OnSessionState(state);
+    controller_->OnSessionState(state, "");
 
     int32_t eventType = 1;
     int32_t eventReason = 0;
@@ -336,7 +336,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_009, TestSize.L
  */
 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.Level1)
 {
-    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
+    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED, "");
 
     DCameraInfoCmd cmd;
     cmd.value_ = std::make_shared<DCameraInfo>();
@@ -364,7 +364,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_010, TestSize.L
  */
 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_011, TestSize.Level1)
 {
-    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED);
+    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED, "");
     std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS));
 
     DCameraInfoCmd cmd;
@@ -397,7 +397,7 @@ HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_012, TestSize.L
  */
 HWTEST_F(DCameraSinkControllerTest, dcamera_sink_controller_test_013, TestSize.Level1)
 {
-    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
+    controller_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED, "");
 
     DCameraInfoCmd cmd;
     cmd.value_ = std::make_shared<DCameraInfo>();
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h
index 03d0120cdaee00c9f68218013b1ac9a369d8f8ed..e5c4aca0e46433d30396fa2baf3d78e6b9d2ab73 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller.h
@@ -49,7 +49,7 @@ public:
     int32_t ResumeDistributedHardware(const std::string &networkId) override;
     int32_t StopDistributedHardware(const std::string &networkId) override;
 
-    void OnSessionState(int32_t state);
+    void OnSessionState(int32_t state, std::string networkId);
     void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail);
     void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers);
 
@@ -57,6 +57,7 @@ private:
     void HandleMetaDataResult(std::string& jsonStr);
     void PostChannelDisconnectedEvent();
     int32_t PublishEnableLatencyMsg(const std::string& devId);
+    void HandleReceivedData(std::shared_ptr<DataBuffer> &dataBuffer);
     class DCameraHdiRecipient : public IRemoteObject::DeathRecipient {
     public:
         void OnRemoteDied(const wptr<IRemoteObject> &remote) override;
@@ -79,6 +80,7 @@ private:
     const std::string SESSION_FLAG = "control";
 
     static constexpr uint8_t CHANNEL_REL_SECONDS = 5;
+    const size_t DATABUFF_MAX_SIZE = 100 * 1024 * 1024;
     std::atomic<bool> isChannelConnected_ = false;
     std::mutex channelMtx_;
     std::condition_variable channelCond_;
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.h
index bf865e14338b0489f06c139cd916a3aa1e0b896f..4df7e85ccc104963b93279fdaa37c5a15850fe37 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -27,7 +27,7 @@ class DCameraSourceControllerChannelListener : public ICameraChannelListener {
 public:
     explicit DCameraSourceControllerChannelListener(std::shared_ptr<DCameraSourceController>& controller);
     ~DCameraSourceControllerChannelListener() override;
-    void OnSessionState(int32_t state) override;
+    void OnSessionState(int32_t state, std::string networkId) override;
     void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail) override;
     void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers) override;
 
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.h
index 5c74d24f77eae0700b03ae131f2b7b9f54b49461..8d4e79d60d54596c9a5b89cf8bf5d6e05128554d 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -29,7 +29,7 @@ class DCameraSourceInputChannelListener : public ICameraChannelListener {
 public:
     DCameraSourceInputChannelListener(std::shared_ptr<DCameraSourceInput>& Input, DCStreamType streamType);
     ~DCameraSourceInputChannelListener() override;
-    void OnSessionState(int32_t state) override;
+    void OnSessionState(int32_t state, std::string networkId) override;
     void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail) override;
     void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers) override;
 
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
index 0562d1290496e6db8e019fc58ff002ddf5cc17c0..a6392d7feaec12a04f5546f07d1a4045020ad2e4 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
@@ -101,6 +101,9 @@ int32_t DCameraSourceDev::RegisterDistributedHardware(const std::string& devId,
     DHLOGI("DCameraSourceDev PostTask RegisterDistributedHardware devId %{public}s dhId %{public}s",
         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
     version_ = param.sinkVersion;
+    if (version_ >= SEPARATE_SINK_VERSION) {
+        g_isSoftbusConnectSource = true;
+    }
     DCameraIndex index(devId, dhId);
     actualDevInfo_.insert(index);
 
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
index 65c6ee49e3cd86f4dff598d88001d785cddcafa3..b833d6a6382036227a5e25a212b5021ebc63c3f3 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
@@ -119,60 +119,93 @@ int32_t DCameraSourceController::StopCapture()
     std::string devId = indexs_.begin()->devId_;
     DHLOGI("StopCapture devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
         GetAnonyString(dhId).c_str());
-    sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
-    if (camSinkSrv == nullptr) {
-        DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
-        return DCAMERA_BAD_OPERATE;
-    }
-    int32_t ret = camSinkSrv->StopCapture(dhId);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("StopCapture failed: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
-            GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
-        return DCAMERA_BAD_OPERATE;
+    if (!g_isSoftbusConnectSource) {
+        sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
+        if (camSinkSrv == nullptr) {
+            DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
+            return DCAMERA_BAD_OPERATE;
+        }
+        int32_t ret = camSinkSrv->StopCapture(dhId);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("StopCapture failed: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+            return DCAMERA_BAD_OPERATE;
+        }
+    } else {
+        cJSON *rootValue = cJSON_CreateObject();
+        if (rootValue == nullptr) {
+            return DCAMERA_BAD_VALUE;
+        }
+        cJSON_AddStringToObject(rootValue, "Command", DCAMERA_PROTOCOL_CMD_STOP_CAPTURE.c_str());
+        char *data = cJSON_Print(rootValue);
+        if (data == nullptr) {
+            cJSON_Delete(rootValue);
+            return DCAMERA_BAD_VALUE;
+        }
+        std::string jsonStr = std::string(data);
+        cJSON_Delete(rootValue);
+        cJSON_free(data);
+        std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
+        int32_t ret = memcpy_s(buffer->Data(), buffer->Capacity(),
+            reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())), jsonStr.length());
+        if (ret != EOK) {
+            DHLOGE("StopCapture memcpy_s failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+            return ret;
+        }
+        CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "channel_ is null.");
+        ret = channel_->SendData(buffer);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("StopCapture SendData failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+            return ret;
+        }
     }
     DHLOGI("StopCapture devId: %{public}s, dhId: %{public}s success", GetAnonyString(devId).c_str(),
-        GetAnonyString(dhId).c_str());
+            GetAnonyString(dhId).c_str());
     return DCAMERA_OK;
 }
 
 int32_t DCameraSourceController::ChannelNeg(std::shared_ptr<DCameraChannelInfo>& info)
 {
-    if (indexs_.size() > DCAMERA_MAX_NUM) {
-        DHLOGE("ChannelNeg not support operate %{public}zu camera", indexs_.size());
-        return DCAMERA_BAD_OPERATE;
-    }
+    if (!g_isSoftbusConnectSource) {
+        if (indexs_.size() > DCAMERA_MAX_NUM) {
+            DHLOGE("ChannelNeg not support operate %{public}zu camera", indexs_.size());
+            return DCAMERA_BAD_OPERATE;
+        }
 
-    std::string dhId = indexs_.begin()->dhId_;
-    std::string devId = indexs_.begin()->devId_;
-    DHLOGI("ChannelNeg devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
-        GetAnonyString(dhId).c_str());
-    sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
-    if (camSinkSrv == nullptr) {
-        DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
-        return DCAMERA_BAD_OPERATE;
-    }
-    DCameraChannelInfoCmd cmd;
-    cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
-    cmd.dhId_ = dhId;
-    cmd.command_ = DCAMERA_PROTOCOL_CMD_CHAN_NEG;
-    cmd.value_ = info;
-    std::string jsonStr;
-    int32_t ret = cmd.Marshal(jsonStr);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Marshal failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
-            GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
-        return ret;
-    }
-    DHLOGD("devId: %{public}s, dhId: %{public}s channelNegCommand: %{public}s",
-        GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), cmd.command_.c_str());
-    ret = camSinkSrv->ChannelNeg(dhId, jsonStr);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("ChannelNeg rpc failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+        std::string dhId = indexs_.begin()->dhId_;
+        std::string devId = indexs_.begin()->devId_;
+        DHLOGI("ChannelNeg devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
+            GetAnonyString(dhId).c_str());
+        sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
+        if (camSinkSrv == nullptr) {
+            DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
+            return DCAMERA_BAD_OPERATE;
+        }
+        DCameraChannelInfoCmd cmd;
+        cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
+        cmd.dhId_ = dhId;
+        cmd.command_ = DCAMERA_PROTOCOL_CMD_CHAN_NEG;
+        cmd.value_ = info;
+        std::string jsonStr;
+        int32_t ret = cmd.Marshal(jsonStr);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("Marshal failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+            return ret;
+        }
+        DHLOGD("devId: %{public}s, dhId: %{public}s channelNegCommand: %{public}s",
+            GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str(), cmd.command_.c_str());
+        ret = camSinkSrv->ChannelNeg(dhId, jsonStr);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("ChannelNeg rpc failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+            return ret;
+        }
+        DHLOGD("DCameraSourceController ChannelNeg devId: %{public}s, dhId: %{public}s success",
             GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
-        return ret;
     }
-    DHLOGD("DCameraSourceController ChannelNeg devId: %{public}s, dhId: %{public}s success",
-        GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
     return DCAMERA_OK;
 }
 
@@ -253,34 +286,36 @@ int32_t DCameraSourceController::UpdateSettings(std::vector<std::shared_ptr<DCam
 
 int32_t DCameraSourceController::GetCameraInfo(std::shared_ptr<DCameraInfo>& camInfo)
 {
-    if (indexs_.size() > DCAMERA_MAX_NUM) {
-        DHLOGE("GetCameraInfo not support operate %{public}zu camera", indexs_.size());
-        return DCAMERA_BAD_OPERATE;
-    }
+    if (!g_isSoftbusConnectSource) {
+        if (indexs_.size() > DCAMERA_MAX_NUM) {
+            DHLOGE("GetCameraInfo not support operate %{public}zu camera", indexs_.size());
+            return DCAMERA_BAD_OPERATE;
+        }
 
-    std::string dhId = indexs_.begin()->dhId_;
-    std::string devId = indexs_.begin()->devId_;
-    DHLOGI("GetCameraInfo devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
-        GetAnonyString(dhId).c_str());
-    sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
-    if (camSinkSrv == nullptr) {
-        DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
-        return DCAMERA_BAD_OPERATE;
-    }
-    std::string camInfoJson;
-    int32_t ret = camSinkSrv->GetCameraInfo(dhId, camInfoJson);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("GetCameraInfo failed: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
-            GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
-        return ret;
-    }
-    DCameraInfoCmd cmd;
-    ret = cmd.Unmarshal(camInfoJson);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraInfoCmd Unmarshal failed: %{public}d", ret);
-        return ret;
+        std::string dhId = indexs_.begin()->dhId_;
+        std::string devId = indexs_.begin()->devId_;
+        DHLOGI("GetCameraInfo devId: %{public}s, dhId: %{public}s", GetAnonyString(devId).c_str(),
+            GetAnonyString(dhId).c_str());
+        sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
+        if (camSinkSrv == nullptr) {
+            DHLOGE("can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
+            return DCAMERA_BAD_OPERATE;
+        }
+        std::string camInfoJson;
+        int32_t ret = camSinkSrv->GetCameraInfo(dhId, camInfoJson);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("GetCameraInfo failed: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+            return ret;
+        }
+        DCameraInfoCmd cmd;
+        ret = cmd.Unmarshal(camInfoJson);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraInfoCmd Unmarshal failed: %{public}d", ret);
+            return ret;
+        }
+        camInfo = cmd.value_;
     }
-    camInfo = cmd.value_;
     return DCAMERA_OK;
 }
 
@@ -294,34 +329,36 @@ int32_t DCameraSourceController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& o
     std::string devId = indexs_.begin()->devId_;
     DHLOGI("DCameraSourceController OpenChannel Start, devId: %{public}s, dhId: %{public}s",
         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
-    sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
-    if (camSinkSrv == nullptr) {
-        DHLOGE("DCameraSourceController can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
-        return DCAMERA_BAD_OPERATE;
-    }
-    std::string jsonStr;
-    DCameraOpenInfoCmd cmd;
-    cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
-    cmd.dhId_ = dhId;
-    cmd.command_ = DCAMERA_PROTOCOL_CMD_OPEN_CHANNEL;
-    cmd.value_ = openInfo;
-    int32_t ret = cmd.Marshal(jsonStr);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceController Marshal OpenInfo failed %{public}d", ret);
-        return ret;
-    }
-    ret = camSinkSrv->OpenChannel(dhId, jsonStr);
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceController SA OpenChannel failed %{public}d", ret);
-        return ret;
+    if (!g_isSoftbusConnectSource) {
+        sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
+        if (camSinkSrv == nullptr) {
+            DHLOGE("DCameraSourceController can not get service, devId: %{public}s", GetAnonyString(devId).c_str());
+            return DCAMERA_BAD_OPERATE;
+        }
+        std::string jsonStr;
+        DCameraOpenInfoCmd cmd;
+        cmd.type_ = DCAMERA_PROTOCOL_TYPE_MESSAGE;
+        cmd.dhId_ = dhId;
+        cmd.command_ = DCAMERA_PROTOCOL_CMD_OPEN_CHANNEL;
+        cmd.value_ = openInfo;
+        int32_t ret = cmd.Marshal(jsonStr);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSourceController Marshal OpenInfo failed %{public}d", ret);
+            return ret;
+        }
+        ret = camSinkSrv->OpenChannel(dhId, jsonStr);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSourceController SA OpenChannel failed %{public}d", ret);
+            return ret;
+        }
+        DHLOGD("DCameraSourceController OpenChannel devId: %{public}s, dhId: %{public}s success",
+            GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
     }
-    DHLOGD("DCameraSourceController OpenChannel devId: %{public}s, dhId: %{public}s success",
-        GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
 
     std::vector<DCameraIndex> indexs;
     indexs.push_back(DCameraIndex(devId, dhId));
-    CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "channel_ is null.");
-    ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener_);
+    CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "OpenChannel channel_ is null.");
+    int32_t ret = channel_->CreateSession(indexs, SESSION_FLAG, DCAMERA_SESSION_MODE_CTRL, listener_);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceController Bind Socket failed, ret: %{public}d", ret);
         PostChannelDisconnectedEvent();
@@ -342,6 +379,7 @@ int32_t DCameraSourceController::CloseChannel()
     std::string devId = indexs_.begin()->devId_;
     DHLOGI("DCameraSourceController CloseChannel Start, devId: %{public}s, dhId: %{public}s",
         GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
+    CHECK_AND_RETURN_RET_LOG(channel_ == nullptr, DCAMERA_BAD_VALUE, "CloseChannel channel_ is null.");
     int32_t ret = channel_->CloseSession();
     if (ret != DCAMERA_OK) {
         DHLOGE("CloseSession failed %{public}d", ret);
@@ -353,13 +391,40 @@ int32_t DCameraSourceController::CloseChannel()
     if (ret != DCAMERA_OK) {
         DHLOGE("ReleaseSession failed %{public}d", ret);
     }
-    sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
-    if (camSinkSrv != nullptr) {
-        ret = camSinkSrv->CloseChannel(dhId);
+    if (!g_isSoftbusConnectSource) {
+        sptr<IDistributedCameraSink> camSinkSrv = DCameraSourceServiceIpc::GetInstance().GetSinkRemoteCamSrv(devId);
+        if (camSinkSrv != nullptr) {
+            ret = camSinkSrv->CloseChannel(dhId);
+            if (ret != DCAMERA_OK) {
+                DHLOGE("DCameraSourceController SA CloseChannel failed %{public}d", ret);
+            }
+            DCameraSourceServiceIpc::GetInstance().DeleteSinkRemoteCamSrv(devId);
+        }
+    } else {
+        cJSON *rootValue = cJSON_CreateObject();
+        if (rootValue == nullptr) {
+            return DCAMERA_BAD_VALUE;
+        }
+        cJSON_AddStringToObject(rootValue, "Command", DCAMERA_PROTOCOL_CMD_CLOSE_CHANNEL.c_str());
+        char *data = cJSON_Print(rootValue);
+        if (data == nullptr) {
+            cJSON_Delete(rootValue);
+            return DCAMERA_BAD_VALUE;
+        }
+        std::string jsonStr = std::string(data);
+        cJSON_Delete(rootValue);
+        cJSON_free(data);
+        std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(jsonStr.length() + 1);
+        ret = memcpy_s(buffer->Data(), buffer->Capacity(),
+            reinterpret_cast<uint8_t *>(const_cast<char *>(jsonStr.c_str())), jsonStr.length());
+        if (ret != EOK) {
+            DHLOGE("CloseChannel memcpy_s failed ret: %{public}d", ret);
+        }
+        ret = channel_->SendData(buffer);
         if (ret != DCAMERA_OK) {
-            DHLOGE("DCameraSourceController SA CloseChannel failed %{public}d", ret);
+            DHLOGE("StopCapture SendData failed %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str());
         }
-        DCameraSourceServiceIpc::GetInstance().DeleteSinkRemoteCamSrv(devId);
     }
     return ret;
 }
@@ -405,7 +470,7 @@ int32_t DCameraSourceController::UnInit()
     return DCAMERA_OK;
 }
 
-void DCameraSourceController::OnSessionState(int32_t state)
+void DCameraSourceController::OnSessionState(int32_t state, std::string networkId)
 {
     DHLOGI("DCameraSourceController OnSessionState state %{public}d", state);
     channelState_ = state;
@@ -446,13 +511,20 @@ void DCameraSourceController::OnSessionError(int32_t eventType, int32_t eventRea
 
 void DCameraSourceController::OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers)
 {
-    if (buffers.empty()) {
-        DHLOGI("DCameraSourceController OnDataReceived empty, devId: %{public}s, dhId: %{public}s",
-            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
-        return;
+    for (auto& buffer : buffers) {
+        if (buffer->Size() <= 0 || buffer->Size() > DATABUFF_MAX_SIZE) {
+            DHLOGI("buffer is invalid");
+            return;
+        }
+        HandleReceivedData(buffer);
     }
-    std::shared_ptr<DataBuffer> buffer = *(buffers.begin());
-    std::string jsonStr(reinterpret_cast<char *>(buffer->Data()));
+}
+
+void DCameraSourceController::HandleReceivedData(std::shared_ptr<DataBuffer>& dataBuffer)
+{
+    DHLOGI("DCameraSourceController::HandleReceivedData dhId: %{public}s", GetAnonyString(dhId_).c_str());
+    uint8_t *data = dataBuffer->Data();
+    std::string jsonStr(reinterpret_cast<const char *>(data), dataBuffer->Capacity());
     cJSON *rootValue = cJSON_Parse(jsonStr.c_str());
     if (rootValue == nullptr) {
         return;
@@ -460,14 +532,23 @@ void DCameraSourceController::OnDataReceived(std::vector<std::shared_ptr<DataBuf
     cJSON *comvalue = cJSON_GetObjectItemCaseSensitive(rootValue, "Command");
     if (comvalue == nullptr || !cJSON_IsString(comvalue) || (comvalue->valuestring == nullptr)) {
         cJSON_Delete(rootValue);
+        DHLOGE("parse command failed");
         return;
     }
     std::string command = std::string(comvalue->valuestring);
-    if (command == DCAMERA_PROTOCOL_CMD_METADATA_RESULT) {
+    cJSON_Delete(rootValue);
+    if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_METADATA_RESULT) == 0)) {
         HandleMetaDataResult(jsonStr);
+    } else if ((!command.empty()) && (command.compare(DCAMERA_PROTOCOL_CMD_STATE_NOTIFY) == 0)) {
+        DCameraEventCmd cmd;
+        int32_t ret = cmd.Unmarshal(jsonStr);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSourceController Unmarshal failed, ret: %{public}d, devId: %{public}s, "
+                "dhId: %{public}s", ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+            return;
+        }
+        DCameraNotify(cmd.value_);
     }
-    cJSON_Delete(rootValue);
-    return;
 }
 
 void DCameraSourceController::HandleMetaDataResult(std::string& jsonStr)
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.cpp
index 289c6024e65db82c68e5524e2f41506b6c73ffce..635038668956547d29840810712d8d63e116eac8 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller_channel_listener.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -31,7 +31,7 @@ DCameraSourceControllerChannelListener::~DCameraSourceControllerChannelListener(
 {
 }
 
-void DCameraSourceControllerChannelListener::OnSessionState(int32_t state)
+void DCameraSourceControllerChannelListener::OnSessionState(int32_t state, std::string networkId)
 {
     std::shared_ptr<DCameraSourceController> controller = controller_.lock();
     if (controller == nullptr) {
@@ -39,7 +39,7 @@ void DCameraSourceControllerChannelListener::OnSessionState(int32_t state)
         return;
     }
 
-    controller->OnSessionState(state);
+    controller->OnSessionState(state, networkId);
 }
 
 void DCameraSourceControllerChannelListener::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.cpp
index 1dfe66ef711facdf48ddf30ec891f1cb643e2137..037289df13d6a49c2563ca876c7f8bd1804f6314 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input_channel_listener.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -31,7 +31,7 @@ DCameraSourceInputChannelListener::~DCameraSourceInputChannelListener()
 {
 }
 
-void DCameraSourceInputChannelListener::OnSessionState(int32_t state)
+void DCameraSourceInputChannelListener::OnSessionState(int32_t state, std::string networkId)
 {
     std::shared_ptr<DCameraSourceInput> input = input_.lock();
     if (input == nullptr) {
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
index f289abf00242eb602975418f200a4021ca72435a..e511c5806356a3654565e4eaabdde425c0861112 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
@@ -306,7 +306,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_010, TestSi
     std::shared_ptr<ICameraChannelListener> listener =
         std::make_shared<DCameraSourceControllerChannelListener>(controller_);
     int32_t state = 0;
-    listener->OnSessionState(state);
+    listener->OnSessionState(state, "");
     int32_t eventType = 1;
     int32_t eventReason = 1;
     std::string detail = "OnSessionErrorTest";
@@ -503,7 +503,7 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_019, TestSi
     std::shared_ptr<ICameraChannelListener> listener_ =
         std::make_shared<DCameraSourceControllerChannelListener>(controller);
     int32_t state = 0;
-    listener_->OnSessionState(state);
+    listener_->OnSessionState(state, "");
     int32_t eventType = 1;
     int32_t eventReason = 1;
     std::string detail = "OnSessionErrorTest";
diff --git a/services/channel/include/dcamera_channel_sink_impl.h b/services/channel/include/dcamera_channel_sink_impl.h
index 638d13ec0a053e23f552b6c41c31701a773a5f4c..441dab065f7f9e7a33310ab14753df7e0177078a 100644
--- a/services/channel/include/dcamera_channel_sink_impl.h
+++ b/services/channel/include/dcamera_channel_sink_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -38,7 +38,6 @@ private:
     std::shared_ptr<DCameraSoftbusSession> softbusSession_;
     std::string mySessionName_;
     DCameraSessionMode mode_ = DCAMERA_SESSION_MODE_CTRL;
-    const std::string SESSION_HEAD = "ohos.dhardware.dcamera_";
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/channel/include/dcamera_channel_source_impl.h b/services/channel/include/dcamera_channel_source_impl.h
index 1d394ed7b9e83bd2a28325d18a28a3d1ca1c695a..4b545a50e1ada927afdad3afab96f8c1d9dac772 100644
--- a/services/channel/include/dcamera_channel_source_impl.h
+++ b/services/channel/include/dcamera_channel_source_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -38,7 +38,6 @@ private:
     std::vector<std::shared_ptr<DCameraSoftbusSession>> softbusSessions_;
     std::string mySessionName_;
     DCameraSessionMode mode_ = DCAMERA_SESSION_MODE_CTRL;
-    const std::string SESSION_HEAD = "ohos.dhardware.dcamera_";
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/channel/include/dcamera_softbus_adapter.h b/services/channel/include/dcamera_softbus_adapter.h
index 90b6818664052fd87509b0965bac895d6ad95cfe..7ba632a54ed2fe58b3008742faf3815dfc26ddeb 100644
--- a/services/channel/include/dcamera_softbus_adapter.h
+++ b/services/channel/include/dcamera_softbus_adapter.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -80,6 +80,7 @@ private:
     int32_t DCameraSoftbusSourceGetSession(int32_t socket, std::shared_ptr<DCameraSoftbusSession>& session);
     int32_t DCameraSoftbusSinkGetSession(int32_t socket, std::shared_ptr<DCameraSoftbusSession>& session);
     int32_t DCameraSoftbusGetSessionById(int32_t socket, std::shared_ptr<DCameraSoftbusSession>& session);
+    std::string FindSessNameByPeerSessName(const std::string peerSessionName);
 
 private:
     std::mutex optLock_;
diff --git a/services/channel/include/dcamera_softbus_session.h b/services/channel/include/dcamera_softbus_session.h
index 429b9f7066e15926ae0f7a27e845e28249e349a9..35f42ca01a34b3df5538eb6105359ba557b4594d 100644
--- a/services/channel/include/dcamera_softbus_session.h
+++ b/services/channel/include/dcamera_softbus_session.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -37,7 +37,7 @@ public:
         std::string peerSessionName, std::shared_ptr<ICameraChannelListener> listener, DCameraSessionMode mode);
     ~DCameraSoftbusSession();
     int32_t CloseSession();
-    int32_t OnSessionOpened(int32_t socket);
+    int32_t OnSessionOpened(int32_t socket, std::string networkId);
     int32_t OnSessionClose(int32_t sessionId);
     int32_t OnDataReceived(std::shared_ptr<DataBuffer>& buffer);
     int32_t SendData(DCameraSessionMode mode, std::shared_ptr<DataBuffer>& buffer);
diff --git a/services/channel/include/icamera_channel_listener.h b/services/channel/include/icamera_channel_listener.h
index 3fc269c8a2107afd02d314d9738b5648ffd55707..d0bba8bdbbd7f71965b413e855b5f95086389bf2 100644
--- a/services/channel/include/icamera_channel_listener.h
+++ b/services/channel/include/icamera_channel_listener.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -34,7 +34,7 @@ class ICameraChannelListener {
 public:
     virtual ~ICameraChannelListener() = default;
 
-    virtual void OnSessionState(int32_t state) = 0;
+    virtual void OnSessionState(int32_t state, std::string networkId) = 0;
     virtual void OnSessionError(int32_t eventType, int32_t eventReason, std::string detail) = 0;
     virtual void OnDataReceived(std::vector<std::shared_ptr<DataBuffer>>& buffers) = 0;
 };
diff --git a/services/channel/src/dcamera_channel_sink_impl.cpp b/services/channel/src/dcamera_channel_sink_impl.cpp
index f90338ce9a2646f04485f623fbf7d72d740b8f04..068df26e13b7bd0294b727aa3c65a66114b54ae4 100644
--- a/services/channel/src/dcamera_channel_sink_impl.cpp
+++ b/services/channel/src/dcamera_channel_sink_impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -16,6 +16,7 @@
 #include "dcamera_channel_sink_impl.h"
 
 #include "dcamera_softbus_adapter.h"
+#include "dcamera_utils_tools.h"
 
 #include "anonymous_string.h"
 #include "distributed_camera_constants.h"
@@ -61,7 +62,11 @@ int32_t DCameraChannelSinkImpl::CreateSession(std::vector<DCameraIndex>& camInde
     }
     camIndexs_.assign(camIndexs.begin(), camIndexs.end());
     listener_ = listener;
-    mySessionName_ = SESSION_HEAD + camIndexs[0].dhId_ + std::string("_") + sessionFlag;
+    if (!g_isSoftbusConnectSink) {
+        mySessionName_ = SESSION_HEAD + camIndexs[0].dhId_ + std::string("_") + sessionFlag;
+    } else {
+        mySessionName_ = SESSION_HEAD + camIndexs[0].dhId_ + std::string("_") + sessionFlag + "_sender";
+    }
     mode_ = sessionMode;
     std::string myDevId;
     DCameraSoftbusAdapter::GetInstance().GetLocalNetworkId(myDevId);
diff --git a/services/channel/src/dcamera_channel_source_impl.cpp b/services/channel/src/dcamera_channel_source_impl.cpp
index 0a3eec3889969d40a0ebd59df05225f70d9dd166..2b0b5096a90a50e659a1f9a543f9f8cdbe5fd19e 100644
--- a/services/channel/src/dcamera_channel_source_impl.cpp
+++ b/services/channel/src/dcamera_channel_source_impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -86,7 +86,7 @@ int32_t DCameraChannelSourceImpl::CreateSession(std::vector<DCameraIndex>& camIn
         int32_t sourceSocket = DCameraSoftbusAdapter::GetInstance().GetSourceSocketId();
         std::shared_ptr<DCameraSoftbusSession> softbusSess = std::make_shared<DCameraSoftbusSession>(myDevId,
             mySessionName_, peerDevId, peerSessionName, listener, sessionMode);
-        softbusSess->OnSessionOpened(sourceSocket);
+        softbusSess->OnSessionOpened(sourceSocket, myDevId);
         DCameraSoftbusAdapter::GetInstance().RecordSourceSocketSession(sourceSocket, softbusSess);
         softbusSessions_.push_back(softbusSess);
         DCameraSoftbusAdapter::GetInstance().sourceSessions_[peerDevId + peerSessionName] = softbusSess;
diff --git a/services/channel/src/dcamera_softbus_adapter.cpp b/services/channel/src/dcamera_softbus_adapter.cpp
index 59d499d79f47e9c37b59d42df1bae9f01fd56b73..5d7a008d282ac4bed55cb0542dec75229fd67b80 100644
--- a/services/channel/src/dcamera_softbus_adapter.cpp
+++ b/services/channel/src/dcamera_softbus_adapter.cpp
@@ -36,6 +36,20 @@ static QosTV g_qosInfo[] = {
     { .qos = QOS_TYPE_MIN_LATENCY, .value = DCAMERA_QOS_TYPE_MIN_LATENCY}
 };
 static uint32_t g_QosTV_Param_Index = static_cast<uint32_t>(sizeof(g_qosInfo) / sizeof(QosTV));
+const static std::pair<std::string, std::string> LOCAL_TO_PEER_SESS_NAME_MAP[] = {
+    {SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_0 + RECEIVER_SESSION_NAME_CONTROL,
+     SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_0 + SENDER_SESSION_NAME_CONTROL},
+    {SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_0 + RECEIVER_SESSION_NAME_DATA_SNAPSHOT,
+     SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_0 + SENDER_SESSION_NAME_DATA_SNAPSHOT},
+    {SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_0 + RECEIVER_SESSION_NAME_DATA_CONTINUE,
+     SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_0 + SENDER_SESSION_NAME_DATA_CONTINUE},
+    {SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_1 + RECEIVER_SESSION_NAME_CONTROL,
+     SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_1 + SENDER_SESSION_NAME_CONTROL},
+    {SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_1 + RECEIVER_SESSION_NAME_DATA_SNAPSHOT,
+     SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_1 + SENDER_SESSION_NAME_DATA_SNAPSHOT},
+    {SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_1 + RECEIVER_SESSION_NAME_DATA_CONTINUE,
+     SESSION_HEAD + CAMERA_ID_PREFIX + DEVICE_ID_1 + SENDER_SESSION_NAME_DATA_CONTINUE},
+};
 }
 IMPLEMENT_SINGLE_INSTANCE(DCameraSoftbusAdapter);
 
@@ -141,13 +155,22 @@ int32_t DCameraSoftbusAdapter::CreatSoftBusSinkSocketServer(std::string mySessio
         }
         mySessionNameSet_.insert(mySessionName);
     }
-    SocketInfo serverSocketInfo = {
-        .name =  const_cast<char*>(mySessionName.c_str()),
-        .peerName = const_cast<char*>(peerSessionName.c_str()),
-        .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
-        .pkgName = const_cast<char*>(PKG_NAME.c_str()),
-        .dataType = sessionModeAndDataTypeMap_[sessionMode],
-    };
+    SocketInfo serverSocketInfo;
+    if (!g_isSoftbusConnectSink) {
+        serverSocketInfo = {
+            .name =  const_cast<char*>(mySessionName.c_str()),
+            .peerName = const_cast<char*>(peerSessionName.c_str()),
+            .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
+            .pkgName = const_cast<char*>(PKG_NAME.c_str()),
+            .dataType = sessionModeAndDataTypeMap_[sessionMode],
+        };
+    } else {
+        serverSocketInfo = {
+            .name =  const_cast<char*>(mySessionName.c_str()),
+            .pkgName = const_cast<char*>(PKG_NAME.c_str()),
+            .dataType = sessionModeAndDataTypeMap_[sessionMode],
+        };
+    }
     int socketId = Socket(serverSocketInfo);
     if (socketId < 0) {
         DHLOGE("create socket server error, socket is invalid");
@@ -159,7 +182,7 @@ int32_t DCameraSoftbusAdapter::CreatSoftBusSinkSocketServer(std::string mySessio
         Shutdown(socketId);
         return DCAMERA_BAD_VALUE;
     }
-    {
+    if (!g_isSoftbusConnectSink) {
         std::lock_guard<std::mutex> autoLock(mySessionNamePeerDevIdLock_);
         std::string peerDevIdMySessionName = peerDevId + std::string("_") + mySessionName;
         peerDevIdMySessionNameMap_[peerDevIdMySessionName] = mySessionName;
@@ -174,14 +197,27 @@ int32_t DCameraSoftbusAdapter::CreateSoftBusSourceSocketClient(std::string myDev
 {
     DHLOGI("create socket client start, myDevId: %{public}s, peerSessionName: %{public}s",
         GetAnonyString(myDevId).c_str(), GetAnonyString(peerSessionName).c_str());
-    std::string myDevIdPeerSessionName = myDevId + std::string("_") + peerSessionName;
-    SocketInfo clientSocketInfo = {
-        .name = const_cast<char*>(myDevIdPeerSessionName.c_str()),
-        .peerName = const_cast<char*>(peerSessionName.c_str()),
-        .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
-        .pkgName = const_cast<char*>(PKG_NAME.c_str()),
-        .dataType = sessionModeAndDataTypeMap_[sessionMode],
-    };
+    SocketInfo clientSocketInfo;
+    if (!g_isSoftbusConnectSink) {
+        std::string myDevIdPeerSessionName = myDevId + std::string("_") + peerSessionName;
+        clientSocketInfo = {
+            .name = const_cast<char*>(myDevIdPeerSessionName.c_str()),
+            .peerName = const_cast<char*>(peerSessionName.c_str()),
+            .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
+            .pkgName = const_cast<char*>(PKG_NAME.c_str()),
+            .dataType = sessionModeAndDataTypeMap_[sessionMode],
+        };
+    } else {
+        std::string srcSessionName = peerSessionName + "_receiver";
+        peerSessionName = peerSessionName + "_sender";
+        clientSocketInfo = {
+            .name = const_cast<char*>(srcSessionName.c_str()),
+            .peerName = const_cast<char*>(peerSessionName.c_str()),
+            .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
+            .pkgName = const_cast<char*>(PKG_NAME.c_str()),
+            .dataType = sessionModeAndDataTypeMap_[sessionMode],
+        };
+    }
     int socketId = Socket(clientSocketInfo);
     if (socketId < 0) {
         DHLOGE("create socket client error, socket is invalid");
@@ -323,7 +359,7 @@ int32_t DCameraSoftbusAdapter::SourceOnBind(int32_t socket, PeerSocketInfo info)
         DHLOGE("source bind socket can not find socket %{public}d", socket);
         return DCAMERA_NOT_FOUND;
     }
-    ret = session->OnSessionOpened(socket);
+    ret = session->OnSessionOpened(socket, info.networkId);
     if (ret != DCAMERA_OK) {
         DHLOGE("source bind socket failed, ret: %{public}d socket: %{public}d", ret, socket);
     } else {
@@ -495,12 +531,22 @@ int32_t DCameraSoftbusAdapter::DCameraSoftbusSinkGetSession(int32_t socket,
     return DCAMERA_OK;
 }
 
+std::string DCameraSoftbusAdapter::FindSessNameByPeerSessName(const std::string peerSessionName)
+{
+    auto foundItem = std::find_if(std::begin(LOCAL_TO_PEER_SESS_NAME_MAP), std::end(LOCAL_TO_PEER_SESS_NAME_MAP),
+        [&](const auto& item) { return item.first == peerSessionName; });
+    if (foundItem != std::end(LOCAL_TO_PEER_SESS_NAME_MAP)) {
+        return foundItem->second;
+    }
+    return "";
+}
+
 int32_t DCameraSoftbusAdapter::DCameraSoftBusGetSessionByPeerSocket(int32_t socket,
     std::shared_ptr<DCameraSoftbusSession> &session, PeerSocketInfo info)
 {
     DHLOGI("find session by peer socket start, socket %{public}d", socket);
     std::string mySessionName = "";
-    {
+    if (!g_isSoftbusConnectSink) {
         std::lock_guard<std::mutex> autoLock(mySessionNamePeerDevIdLock_);
         auto sessionNameIter = peerDevIdMySessionNameMap_.find(info.name);
         if (sessionNameIter == peerDevIdMySessionNameMap_.end()) {
@@ -508,6 +554,12 @@ int32_t DCameraSoftbusAdapter::DCameraSoftBusGetSessionByPeerSocket(int32_t sock
             return DCAMERA_NOT_FOUND;
         }
         mySessionName = sessionNameIter->second;
+    } else {
+        mySessionName = FindSessNameByPeerSessName(info.name);
+    }
+    if (mySessionName.empty()) {
+        DHLOGE("find mySessionName is empty");
+        return DCAMERA_BAD_VALUE;
     }
     auto iter = sinkSessions_.find(std::string(mySessionName));
     if (iter == sinkSessions_.end()) {
@@ -534,7 +586,7 @@ int32_t DCameraSoftbusAdapter::SinkOnBind(int32_t socket, PeerSocketInfo info)
         DHLOGE("sink bind socket error, can not find socket %{public}d", socket);
         return DCAMERA_NOT_FOUND;
     }
-    ret = session->OnSessionOpened(socket);
+    ret = session->OnSessionOpened(socket, info.networkId);
     if (ret != DCAMERA_OK) {
         DHLOGE("sink bind socket error, not find socket %{public}d", socket);
     } else {
diff --git a/services/channel/src/dcamera_softbus_session.cpp b/services/channel/src/dcamera_softbus_session.cpp
index 5b492f84367fd2c4b937465e5cc84411cf3ac0a7..5051b6a3da982c3a7dd250d49ad62b4ce8f9a199 100644
--- a/services/channel/src/dcamera_softbus_session.cpp
+++ b/services/channel/src/dcamera_softbus_session.cpp
@@ -82,13 +82,13 @@ int32_t DCameraSoftbusSession::CloseSession()
     return DCAMERA_OK;
 }
 
-int32_t DCameraSoftbusSession::OnSessionOpened(int32_t socket)
+int32_t DCameraSoftbusSession::OnSessionOpened(int32_t socket, std::string networkId)
 {
     DHLOGI("open current session start, socket: %{public}d", socket);
     sessionId_ = socket;
     state_ = DCAMERA_SOFTBUS_STATE_OPENED;
     CHECK_AND_RETURN_RET_LOG(listener_ == nullptr, DCAMERA_BAD_VALUE, "listener_ is null.");
-    listener_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
+    listener_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED, networkId);
     DHLOGI("open current session end, socket: %{public}d", socket);
     return DCAMERA_OK;
 }
@@ -100,7 +100,7 @@ int32_t DCameraSoftbusSession::OnSessionClose(int32_t sessionId)
     sessionId_ = -1;
     state_ = DCAMERA_SOFTBUS_STATE_CLOSED;
     CHECK_AND_RETURN_RET_LOG(listener_ == nullptr, DCAMERA_BAD_VALUE, "listener_ is null.");
-    listener_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED);
+    listener_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED, "");
     return DCAMERA_OK;
 }
 
diff --git a/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp b/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp
index c603d8e81227f55a156b05f74c913e290482cf4b..6437f793c4eef44ff9b9b180b78fb9c5e6dd5762 100644
--- a/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_channel_sink_impl_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -259,7 +259,7 @@ HWTEST_F(DCameraChannelSinkImplTest, dcamera_channel_sink_impl_test_010, TestSiz
     int32_t eventType = 1;
     int32_t eventReason = 1;
     std::string detail = "test010";
-    listener_->OnSessionState(state);
+    listener_->OnSessionState(state, "");
     listener_->OnSessionError(eventType, eventReason, detail);
     size_t capacity = 1;
     std::shared_ptr<DataBuffer> dataBuffer = std::make_shared<DataBuffer>(capacity);
diff --git a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
index 89165202eae6fb9f4bc740a0e3a1fcc529968dc0..e5404c891b23be070a3fc6a6913911a41b9e69ce 100644
--- a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -114,7 +114,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_002, TestSize.L
     std::string sessionName = "dcamera_softbus_session_test_002";
     std::string pkgName = "ohos.dhardware.dcamera";
     std::string networkId = "abcdefg123";
-    int32_t ret = softbusSession_->OnSessionOpened(sessionId);
+    int32_t ret = softbusSession_->OnSessionOpened(sessionId, "");
     EXPECT_EQ(DCAMERA_OK, ret);
 }