diff --git a/common/include/daudio_errorcode.h b/common/include/daudio_errorcode.h
index 1f8fdb59a87d41c68ceb6913509c1b4712772c53..f7ad78745747154e5860371ac78e3d3f7687837f 100644
--- a/common/include/daudio_errorcode.h
+++ b/common/include/daudio_errorcode.h
@@ -69,6 +69,7 @@ enum DAudioErrorCode {
     ERR_DH_AUDIO_HDI_CALL_FAILED = -44000,
     ERR_DH_AUDIO_HDI_INVALID_PARAM = -44001,
     ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED = -44002,
+    ERR_DH_AUDIO_ACCESS_PERMISSION_CHECK_FAIL = -44003,
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/common/include/daudio_ipc_interface_code.h b/common/include/daudio_ipc_interface_code.h
index 93cee7c86fb04d8ae7ab24b29d8d8d78bfdc7aa5..a18c0683f1ed76a4d4ec572c97dbc6f6363a1d84 100644
--- a/common/include/daudio_ipc_interface_code.h
+++ b/common/include/daudio_ipc_interface_code.h
@@ -37,6 +37,9 @@ enum class IDAudioSinkInterfaceCode : uint32_t {
     SUBSCRIBE_LOCAL_HARDWARE = 2,
     UNSUBSCRIBE_LOCAL_HARDWARE = 3,
     DAUDIO_NOTIFY = 4,
+    PAUSE_DISTRIBUTED_HARDWARE = 5,
+    RESUME_DISTRIBUTED_HARDWARE = 6,
+    STOP_DISTRIBUTED_HARDWARE = 7,
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/BUILD.gn b/interfaces/inner_kits/native_cpp/audio_sink/BUILD.gn
index 0e55bae2fff081d60ffd300675818601187054c4..9db8e3630ce7f153c980f9b6180f0dc9a82ab9aa 100755
--- a/interfaces/inner_kits/native_cpp/audio_sink/BUILD.gn
+++ b/interfaces/inner_kits/native_cpp/audio_sink/BUILD.gn
@@ -1,4 +1,4 @@
-# Copyright (c) 2022 Huawei Device Co., Ltd.
+# Copyright (c) 2022-2023 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
@@ -39,6 +39,8 @@ ohos_shared_library("distributed_audio_sink_sdk") {
 
   sources = [
     "src/daudio_sink_handler.cpp",
+    "src/daudio_sink_ipc_callback.cpp",
+    "src/daudio_sink_ipc_callback_stub.cpp",
     "src/daudio_sink_load_callback.cpp",
     "src/daudio_sink_proxy.cpp",
   ]
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_handler.h b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_handler.h
index 890a60d49e41e8d111a7101cb900d0e122312ed5..af92873c8105d546b0e0a35ab3e0ea933edeb3e0 100644
--- a/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_handler.h
+++ b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_handler.h
@@ -17,6 +17,7 @@
 #define OHOS_DAUDIO_SINK_HANDLER_H
 
 #include "idistributed_hardware_sink.h"
+#include "daudio_sink_ipc_callback.h"
 #include "single_instance.h"
 
 #include "idaudio_sink.h"
@@ -50,6 +51,7 @@ private:
     std::condition_variable sinkProxyConVar_;
     sptr<IDAudioSink> dAudioSinkProxy_ = nullptr;
     sptr<DAudioSinkSvrRecipient> sinkSvrRecipient_ = nullptr;
+    sptr<DAudioSinkIpcCallback> dAudioSinkIpcCallback_ = nullptr;
 };
 
 #ifdef __cplusplus
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback.h b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..da6bdc96a8e7ad38ff7754290c75d9ca002961eb
--- /dev/null
+++ b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DAUDIO_SINK_IPC_CALLBACK_H
+#define OHOS_DAUDIO_SINK_IPC_CALLBACK_H
+
+#include <vector>
+#include <mutex>
+
+#include "daudio_sink_ipc_callback_stub.h"
+#include "idistributed_hardware_sink.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class DAudioSinkIpcCallback : public DAudioSinkIpcCallbackStub {
+public:
+    DAudioSinkIpcCallback() = default;
+    ~DAudioSinkIpcCallback() override = default;
+
+    int32_t OnNotifyResourceInfo(const ResourceEventType &type, const std::string &subType,
+        const std::string &networkId, bool &isSensitive, bool &isSameAccout) override;
+    void PushPrivacyResCallback(const std::shared_ptr<PrivacyResourcesListener> &listener);
+
+private:
+    std::mutex privacyResMtx_;
+    std::vector<std::shared_ptr<PrivacyResourcesListener>> privacyResCallback_;
+};
+} // DistributedHardware
+} // OHOS
+#endif // OHOS_DAUDIO_SINK_IPC_CALLBACK_H
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback_stub.h b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback_stub.h
new file mode 100644
index 0000000000000000000000000000000000000000..a983385104a34d048175e6d3fec9fb4690782d3e
--- /dev/null
+++ b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback_stub.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DAUDIO_SINK_IPC_CALLBACK_STUB_H
+#define OHOS_DAUDIO_SINK_IPC_CALLBACK_STUB_H
+
+#include <map>
+
+#include "idaudio_sink_ipc_callback.h"
+#include "iremote_stub.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class DAudioSinkIpcCallbackStub : public IRemoteStub<IDAudioSinkIpcCallback> {
+public:
+    DAudioSinkIpcCallbackStub();
+    virtual ~DAudioSinkIpcCallbackStub() = default;
+    int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+
+private:
+    int32_t OnNotifyResourceInfoInner(MessageParcel &data, MessageParcel &reply, MessageOption &option);
+
+    using DAudioSinkCallbackFunc = int32_t (DAudioSinkIpcCallbackStub::*)(MessageParcel &data, MessageParcel &reply,
+        MessageOption &option);
+    std::map<int32_t, DAudioSinkCallbackFunc> memberFuncMap_;
+};
+} // DistributedHardware
+} // OHOS
+#endif // OHOS_DAUDIO_SINK_IPC_CALLBACK_STUB_H
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_proxy.h b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_proxy.h
index 5734ddba01c476fb74b996be25161400f5fc5414..027c76cf4fe31c040d54ec3bfe5040d30db04f2b 100644
--- a/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_proxy.h
+++ b/interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_proxy.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2023 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
@@ -28,12 +28,15 @@ public:
     explicit DAudioSinkProxy(const sptr<IRemoteObject> impl) : IRemoteProxy<IDAudioSink>(impl) {}
     ~DAudioSinkProxy() = default;
 
-    int32_t InitSink(const std::string &params) override;
+    int32_t InitSink(const std::string &params, const sptr<IDAudioSinkIpcCallback> &sinkCallback) override;
     int32_t ReleaseSink() override;
     int32_t SubscribeLocalHardware(const std::string &dhId, const std::string &param) override;
     int32_t UnsubscribeLocalHardware(const std::string &dhId) override;
     void DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
         const std::string &eventContent) override;
+    int32_t PauseDistributedHardware(const std::string &networkId) override;
+    int32_t ResumeDistributedHardware(const std::string &networkId) override;
+    int32_t StopDistributedHardware(const std::string &networkId) override;
 
 private:
     static inline BrokerDelegator<DAudioSinkProxy> delegator_;
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink.h b/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink.h
index ba07a29283dd120f81149add2cd432c172f81609..b6021b22bc31811fc00ab2b3e50b825e5ee7109d 100644
--- a/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink.h
+++ b/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink.h
@@ -16,6 +16,7 @@
 #ifndef OHOS_IDAUDIO_SINK_H
 #define OHOS_IDAUDIO_SINK_H
 
+#include "idaudio_sink_ipc_callback.h"
 #include "iremote_broker.h"
 
 namespace OHOS {
@@ -25,12 +26,15 @@ public:
     DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.distributedaudiosink");
 
     ~IDAudioSink() override = default;
-    virtual int32_t InitSink(const std::string &params) = 0;
+    virtual int32_t InitSink(const std::string &params, const sptr<IDAudioSinkIpcCallback> &sinkCallback) = 0;
     virtual int32_t ReleaseSink() = 0;
     virtual int32_t SubscribeLocalHardware(const std::string &dhId, const std::string &param) = 0;
     virtual int32_t UnsubscribeLocalHardware(const std::string &dhId) = 0;
     virtual void DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
         const std::string &eventContent) = 0;
+    virtual int32_t PauseDistributedHardware(const std::string &networkId) = 0;
+    virtual int32_t ResumeDistributedHardware(const std::string &networkId) = 0;
+    virtual int32_t StopDistributedHardware(const std::string &networkId) = 0;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink_ipc_callback.h b/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink_ipc_callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..15974dfad3a53706a191e488be05d987243876da
--- /dev/null
+++ b/interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink_ipc_callback.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_IDAUDIO_SINK_IPC_CALLBACK_H
+#define OHOS_IDAUDIO_SINK_IPC_CALLBACK_H
+
+#include "iremote_broker.h"
+#include "idistributed_hardware_sink.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class IDAudioSinkIpcCallback : public OHOS::IRemoteBroker {
+public:
+    DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.distributedaudiosinkipccallback");
+    enum {
+        NOTIFY_RESOURCEINFO = 0,
+    };
+
+    ~IDAudioSinkIpcCallback() override {}
+    virtual int32_t OnNotifyResourceInfo(const ResourceEventType &type, const std::string &subType,
+        const std::string &networkId, bool &isSensitive, bool &isSameAccout) = 0;
+};
+} // DistributedHardware
+} // OHOS
+#endif // OHOS_IDAUDIO_SINK_IPC_CALLBACK_H
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_handler.cpp b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_handler.cpp
index 5b758d603544d2129fd762399597aa8e2763f8b5..c34559ff7f6cedb13f36447ab76bd3881377c444 100644
--- a/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_handler.cpp
+++ b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_handler.cpp
@@ -35,6 +35,9 @@ IMPLEMENT_SINGLE_INSTANCE(DAudioSinkHandler);
 DAudioSinkHandler::DAudioSinkHandler()
 {
     DHLOGD("DAudio sink handler constructed.");
+    if (!dAudioSinkIpcCallback_) {
+        dAudioSinkIpcCallback_ = new DAudioSinkIpcCallback();
+    }
 }
 
 DAudioSinkHandler::~DAudioSinkHandler()
@@ -148,7 +151,7 @@ void DAudioSinkHandler::FinishStartSA(const std::string &param, const sptr<IRemo
             ERR_DH_AUDIO_SA_PROXY_NOT_INIT, "daudio sink get proxy failed.");
         return;
     }
-    dAudioSinkProxy_->InitSink(param);
+    dAudioSinkProxy_->InitSink(param, dAudioSinkIpcCallback_);
     sinkProxyConVar_.notify_one();
     DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_INIT, "daudio sink sa load success.");
 }
@@ -158,30 +161,54 @@ void DAudioSinkHandler::DAudioSinkSvrRecipient::OnRemoteDied(const wptr<IRemoteO
     DAudioSinkHandler::GetInstance().OnRemoteSinkSvrDied(remote);
 }
 
+IDistributedHardwareSink *GetSinkHardwareHandler()
+{
+    DHLOGD("Get sink hardware handler.");
+    return &DAudioSinkHandler::GetInstance();
+}
+
 int32_t DAudioSinkHandler::RegisterPrivacyResources(std::shared_ptr<PrivacyResourcesListener> listener)
 {
+    DHLOGI("RegisterPrivacyResources start.");
+    if (dAudioSinkIpcCallback_ == nullptr) {
+        DHLOGE("Daudio sink ipc callback is nullptr.");
+        return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
+    }
+    dAudioSinkIpcCallback_->PushPrivacyResCallback(listener);
     return DH_SUCCESS;
 }
 
 int32_t DAudioSinkHandler::PauseDistributedHardware(const std::string &networkId)
 {
-    return DH_SUCCESS;
+    DHLOGI("pause distributed hardware.");
+    std::lock_guard<std::mutex> lock(sinkProxyMutex_);
+    if (dAudioSinkProxy_ == nullptr) {
+        DHLOGE("daudio sink proxy not init.");
+        return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
+    }
+    return dAudioSinkProxy_->PauseDistributedHardware(networkId);
 }
 
 int32_t DAudioSinkHandler::ResumeDistributedHardware(const std::string &networkId)
 {
-    return DH_SUCCESS;
+    DHLOGI("resume distributed hardware.");
+    std::lock_guard<std::mutex> lock(sinkProxyMutex_);
+    if (dAudioSinkProxy_ == nullptr) {
+        DHLOGE("daudio sink proxy not init.");
+        return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
+    }
+    return dAudioSinkProxy_->ResumeDistributedHardware(networkId);
 }
 
 int32_t DAudioSinkHandler::StopDistributedHardware(const std::string &networkId)
 {
-    return DH_SUCCESS;
-}
-
-IDistributedHardwareSink *GetSinkHardwareHandler()
-{
-    DHLOGD("Get sink hardware handler.");
-    return &DAudioSinkHandler::GetInstance();
+    DHLOGI("stop distributed hardware.");
+    std::lock_guard<std::mutex> lock(sinkProxyMutex_);
+    if (dAudioSinkProxy_ == nullptr) {
+        DHLOGE("daudio sink proxy not init.");
+        return ERR_DH_AUDIO_SA_PROXY_NOT_INIT;
+    }
+    return dAudioSinkProxy_->StopDistributedHardware(networkId);
 }
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback.cpp b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aaf78e2fc1bb93d71b9c2c13c9ec65329369e37d
--- /dev/null
+++ b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback.cpp
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "daudio_sink_ipc_callback.h"
+
+#include "daudio_constants.h"
+#include "daudio_errorcode.h"
+#include "daudio_log.h"
+#include "daudio_util.h"
+
+#undef DH_LOG_TAG
+#define DH_LOG_TAG "DAudioSinkIpcCallback"
+
+namespace OHOS {
+namespace DistributedHardware {
+int32_t DAudioSinkIpcCallback::OnNotifyResourceInfo(const ResourceEventType &type, const std::string &subType,
+    const std::string &networkId, bool &isSensitive, bool &isSameAccout)
+{
+    DHLOGI("On notify the resource info, subType: %s, networkId: %s, isSensitive: %d, isSameAccout: %d",
+        subType.c_str(), networkId.c_str(), isSensitive, isSameAccout);
+
+    int32_t ret = DH_SUCCESS;
+    std::lock_guard<std::mutex> resourceLck(privacyResMtx_);
+    auto iter = privacyResCallback_.begin();
+    if (iter != privacyResCallback_.end()) {
+        ret = (*iter)->OnPrivaceResourceMessage(type, subType, networkId, isSensitive, isSameAccout);
+    }
+    return ret;
+}
+
+void DAudioSinkIpcCallback::PushPrivacyResCallback(const std::shared_ptr<PrivacyResourcesListener> &callback)
+{
+    DHLOGD("Push resource info callback");
+    std::lock_guard<std::mutex> resourceLck(privacyResMtx_);
+    privacyResCallback_.push_back(callback);
+}
+} // DistributedHardware
+} // OHOS
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback_stub.cpp b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback_stub.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49e244a618e8b93c788a22b21d87539438df6a11
--- /dev/null
+++ b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback_stub.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "daudio_sink_ipc_callback_stub.h"
+
+#include "daudio_errorcode.h"
+#include "daudio_log.h"
+
+#undef DH_LOG_TAG
+#define DH_LOG_TAG "DAudioSinkIpcCallbackStub"
+
+namespace OHOS {
+namespace DistributedHardware {
+DAudioSinkIpcCallbackStub::DAudioSinkIpcCallbackStub()
+{
+    memberFuncMap_[NOTIFY_RESOURCEINFO] = &DAudioSinkIpcCallbackStub::OnNotifyResourceInfoInner;
+}
+
+int32_t DAudioSinkIpcCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
+    MessageOption &option)
+{
+    DHLOGI("On remote request, code: %u", code);
+    std::u16string desc = DAudioSinkIpcCallbackStub::GetDescriptor();
+    std::u16string remoteDesc = data.ReadInterfaceToken();
+    if (desc != remoteDesc) {
+        DHLOGE("RemoteDesc is invalid.");
+        return ERR_DH_AUDIO_SA_INVALID_INTERFACE_TOKEN;
+    }
+
+    std::map<int32_t, DAudioSinkCallbackFunc>::iterator iter = memberFuncMap_.find(code);
+    if (iter == memberFuncMap_.end()) {
+        DHLOGE("Invalid request code.");
+        return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
+    }
+    DAudioSinkCallbackFunc &func = iter->second;
+    return (this->*func)(data, reply, option);
+}
+
+int32_t DAudioSinkIpcCallbackStub::OnNotifyResourceInfoInner(MessageParcel &data, MessageParcel &reply,
+    MessageOption &option)
+{
+    ResourceEventType type = static_cast<ResourceEventType>(data.ReadInt32());
+    std::string subType = data.ReadString();
+    std::string networkId = data.ReadString();
+    bool isSensitive = data.ReadBool();
+    bool isSameAccout = data.ReadBool();
+    return OnNotifyResourceInfo(type, subType, networkId, isSensitive, isSameAccout);
+}
+} // DistributedHardware
+} // OHOS
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_proxy.cpp b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_proxy.cpp
index d33e6e390598bacd141188a626cec84bd0949741..b150ebd76acce00d3afada9823fac46d7a6ce3cd 100644
--- a/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_proxy.cpp
+++ b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_proxy.cpp
@@ -25,7 +25,7 @@
 
 namespace OHOS {
 namespace DistributedHardware {
-int32_t DAudioSinkProxy::InitSink(const std::string &params)
+int32_t DAudioSinkProxy::InitSink(const std::string &params, const sptr<IDAudioSinkIpcCallback> &sinkCallback)
 {
     MessageParcel data;
     MessageParcel reply;
@@ -34,7 +34,7 @@ int32_t DAudioSinkProxy::InitSink(const std::string &params)
         return ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED;
     }
 
-    if (!data.WriteString(params)) {
+    if (!data.WriteString(params) || !data.WriteRemoteObject(sinkCallback->AsObject())) {
         return ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED;
     }
 
@@ -118,5 +118,59 @@ void DAudioSinkProxy::DAudioNotify(const std::string &devId, const std::string &
 
     Remote()->SendRequest(static_cast<uint32_t>(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY), data, reply, option);
 }
+
+int32_t DAudioSinkProxy::PauseDistributedHardware(const std::string &networkId)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        return ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED;
+    }
+
+    if (!data.WriteString(networkId)) {
+        return ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED;
+    }
+
+    Remote()->SendRequest(static_cast<uint32_t>(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE),
+        data, reply, option);
+    return reply.ReadInt32();
+}
+
+int32_t DAudioSinkProxy::ResumeDistributedHardware(const std::string &networkId)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        return ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED;
+    }
+
+    if (!data.WriteString(networkId)) {
+        return ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED;
+    }
+
+    Remote()->SendRequest(static_cast<uint32_t>(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE),
+        data, reply, option);
+    return reply.ReadInt32();
+}
+
+int32_t DAudioSinkProxy::StopDistributedHardware(const std::string &networkId)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        return ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED;
+    }
+
+    if (!data.WriteString(networkId)) {
+        return ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED;
+    }
+
+    Remote()->SendRequest(static_cast<uint32_t>(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE),
+        data, reply, option);
+    return reply.ReadInt32();
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/inner_kits/native_cpp/test/fuzztest/sinkproxyinitsink_fuzzer/sinkproxyinitsink_fuzzer.cpp b/interfaces/inner_kits/native_cpp/test/fuzztest/sinkproxyinitsink_fuzzer/sinkproxyinitsink_fuzzer.cpp
index b3d6e2d0eb9433278873a71099fc6d6c6c3d1b2e..465eeb8031fca606d6075b034af4249814b3b1d3 100644
--- a/interfaces/inner_kits/native_cpp/test/fuzztest/sinkproxyinitsink_fuzzer/sinkproxyinitsink_fuzzer.cpp
+++ b/interfaces/inner_kits/native_cpp/test/fuzztest/sinkproxyinitsink_fuzzer/sinkproxyinitsink_fuzzer.cpp
@@ -20,6 +20,7 @@
 
 #include "daudio_constants.h"
 #include "daudio_sink_proxy.h"
+#include "daudio_sink_ipc_callback.h"
 #include "if_system_ability_manager.h"
 #include "iservice_registry.h"
 
@@ -40,8 +41,8 @@ void SinkProxyInitSinkFuzzTest(const uint8_t* data, size_t size)
         return;
     }
     std::shared_ptr<DAudioSinkProxy> dAudioProxy = std::make_shared<DAudioSinkProxy>(remoteObject);
-
-    dAudioProxy->InitSink(params);
+    sptr<DAudioSinkIpcCallback> dAudioSinkIpcCallback = new DAudioSinkIpcCallback();
+    dAudioProxy->InitSink(params, dAudioSinkIpcCallback);
 }
 }
 }
diff --git a/interfaces/inner_kits/native_cpp/test/unittest/audiosinktest/src/daudio_sink_proxy_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/audiosinktest/src/daudio_sink_proxy_test.cpp
index 3422d8514f9f78fc93432477d44e5209b7be6092..e9e0370a4bb8d0af74cd43ae39242057b8dd85cc 100644
--- a/interfaces/inner_kits/native_cpp/test/unittest/audiosinktest/src/daudio_sink_proxy_test.cpp
+++ b/interfaces/inner_kits/native_cpp/test/unittest/audiosinktest/src/daudio_sink_proxy_test.cpp
@@ -20,6 +20,7 @@
 #include "daudio_constants.h"
 #include "if_system_ability_manager.h"
 #include "iservice_registry.h"
+#include "daudio_sink_ipc_callback.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -92,7 +93,8 @@ HWTEST_F(DAudioSinkProxyTest, SubscribeLocalHardware_002, TestSize.Level1)
 HWTEST_F(DAudioSinkProxyTest, InitSink_001, TestSize.Level1)
 {
     const std::string params = "params";
-    int32_t ret = dAudioProxy->InitSink(params);
+    auto dAudioSinkIpcCallback = new DAudioSinkIpcCallback();
+    int32_t ret = dAudioProxy->InitSink(params, dAudioSinkIpcCallback);
     EXPECT_EQ(DH_SUCCESS, ret);
     ret = dAudioProxy->ReleaseSink();
     EXPECT_EQ(DH_SUCCESS, ret);
diff --git a/services/audioclient/micclient/include/dmic_client.h b/services/audioclient/micclient/include/dmic_client.h
index 40ba06d14547b544dde000543e953403e79ecd99..c453410bf22025f55fd6213916bfda9ad54374c0 100644
--- a/services/audioclient/micclient/include/dmic_client.h
+++ b/services/audioclient/micclient/include/dmic_client.h
@@ -64,6 +64,8 @@ public:
     int32_t SendMessage(uint32_t type, std::string content, std::string dstDevId) override;
 
     void OnReadData(size_t length) override;
+    int32_t PauseCapture();
+    int32_t ResumeCapture();
 private:
     void CaptureThreadRunning();
 
@@ -89,6 +91,7 @@ private:
     std::shared_ptr<IAudioDataTransport> micTrans_ = nullptr;
     int64_t lastCaptureStartTime_ = 0;
     int64_t lastTransStartTime_ = 0;
+    std::atomic<bool> isPauseStatus_ = false;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/services/audioclient/micclient/src/dmic_client.cpp b/services/audioclient/micclient/src/dmic_client.cpp
index 1fb712774ecd856cf582d9158bddba96adb080ab..24b8c9f12c6fd743b86be67ab8f573ccb5006e60 100644
--- a/services/audioclient/micclient/src/dmic_client.cpp
+++ b/services/audioclient/micclient/src/dmic_client.cpp
@@ -179,8 +179,9 @@ int32_t DMicClient::SendMessage(uint32_t type, std::string content, std::string
 {
     DHLOGI("Send message to remote.");
     if (type != static_cast<uint32_t>(NOTIFY_OPEN_MIC_RESULT) &&
-        type != static_cast<uint32_t>(NOTIFY_CLOSE_MIC_RESULT)) {
-        DHLOGE("event type is not NOTIFY_OPEN_MIC or NOTIFY_CLOSE_MIC. type: %u", type);
+        type != static_cast<uint32_t>(NOTIFY_CLOSE_MIC_RESULT) &&
+        type != static_cast<uint32_t>(CLOSE_MIC)) {
+        DHLOGE("event type is not NOTIFY_OPEN_MIC or NOTIFY_CLOSE_MIC or CLOSE_MIC. type: %u", type);
         return ERR_DH_AUDIO_NULLPTR;
     }
     if (micTrans_ == nullptr) {
@@ -280,6 +281,9 @@ void DMicClient::AudioFwkCaptureData()
         DHLOGE("Bytes read failed.");
         return;
     }
+    if (isPauseStatus_.load()) {
+        memset_s(audioData->Data(), audioData->Size(), 0, audioData->Size());
+    }
 #ifdef DUMP_DMICCLIENT_FILE
     if (DaudioSinkHidumper::GetInstance().QueryDumpDataFlag()) {
         SaveFile(MIC_CLIENT_FILENAME, const_cast<uint8_t*>(audioData->Data()), audioData->Size());
@@ -391,5 +395,19 @@ void DMicClient::SetAttrs(const std::string &devId, const std::shared_ptr<IAudio
 {
     DHLOGE("Set attrs, not support yet.");
 }
+
+int32_t DMicClient::PauseCapture()
+{
+    DHLOGI("Pause capture.");
+    isPauseStatus_.store(true);
+    return DH_SUCCESS;
+}
+
+int32_t DMicClient::ResumeCapture()
+{
+    DHLOGI("Resume capture.");
+    isPauseStatus_.store(false);
+    return DH_SUCCESS;
+}
 } // DistributedHardware
 } // OHOS
diff --git a/services/audiomanager/managersink/include/daudio_sink_dev.h b/services/audiomanager/managersink/include/daudio_sink_dev.h
index da343918266bb887cd82b1b555ffd35250e3bb3d..3d64da3d97c4f5a0416f0ebe7d4be4c7391d1318 100644
--- a/services/audiomanager/managersink/include/daudio_sink_dev.h
+++ b/services/audiomanager/managersink/include/daudio_sink_dev.h
@@ -32,6 +32,7 @@
 #include "ispk_client.h"
 #include "i_av_engine_provider.h"
 #include "i_av_receiver_engine_callback.h"
+#include "idaudio_sink_ipc_callback.h"
 
 using json = nlohmann::json;
 
@@ -45,13 +46,16 @@ enum class ChannelState {
 
 class DAudioSinkDev : public IAudioEventCallback, public std::enable_shared_from_this<DAudioSinkDev> {
 public:
-    explicit DAudioSinkDev(const std::string &networkId);
+    explicit DAudioSinkDev(const std::string &networkId, const sptr<IDAudioSinkIpcCallback> &sinkCallback);
     ~DAudioSinkDev() override;
 
     int32_t AwakeAudioDev();
     void SleepAudioDev();
     void NotifyEvent(const AudioEvent &audioEvent) override;
     int32_t InitAVTransEngines(const ChannelState channelState, IAVEngineProvider *providerPtr);
+    int32_t PauseDistributedHardware(const std::string &networkId);
+    int32_t ResumeDistributedHardware(const std::string &networkId);
+    int32_t StopDistributedHardware(const std::string &networkId);
 
 private:
     int32_t TaskOpenDSpeaker(const std::string &args);
@@ -83,14 +87,14 @@ private:
     std::string devId_;
     std::string spkDhId_;
     std::string micDhId_;
-    std::shared_ptr<ISpkClient> speakerClient_ = nullptr;
     std::mutex spkClientMutex_;
     std::map<int32_t, std::shared_ptr<ISpkClient>> spkClientMap_;
-    std::shared_ptr<IMicClient> micClient_ = nullptr;
     std::mutex micClientMutex_;
-    std::map<int32_t, std::shared_ptr<IMicClient>> micClientMap_;
+    std::map<int32_t, std::shared_ptr<DMicClient>> micClientMap_;
     std::shared_ptr<DAudioSinkDevCtrlMgr> audioCtrlMgr_ = nullptr;
     static constexpr size_t WAIT_HANDLER_IDLE_TIME_US = 10000;
+    sptr<IDAudioSinkIpcCallback> ipcSinkCallback_ = nullptr;
+    std::atomic<bool> isPageStatus_ = false;
 
     std::atomic<bool> isSpkInUse_ = false;
     std::atomic<bool> isMicInUse_ = false;
diff --git a/services/audiomanager/managersink/include/daudio_sink_manager.h b/services/audiomanager/managersink/include/daudio_sink_manager.h
index 4c898f0a3c99780c22e232cc8a29f494c5025ab6..e9892a6d107fa015228184ff556774cea121a16a 100644
--- a/services/audiomanager/managersink/include/daudio_sink_manager.h
+++ b/services/audiomanager/managersink/include/daudio_sink_manager.h
@@ -23,6 +23,7 @@
 
 #include "daudio_sink_dev.h"
 #include "idaudio_source.h"
+#include "idaudio_sink_ipc_callback.h"
 #include "i_av_engine_provider_callback.h"
 
 namespace OHOS {
@@ -38,7 +39,7 @@ public:
 class DAudioSinkManager {
 DECLARE_SINGLE_INSTANCE_BASE(DAudioSinkManager);
 public:
-    int32_t Init();
+    int32_t Init(const sptr<IDAudioSinkIpcCallback> &sinkCallback);
     int32_t UnInit();
     int32_t HandleDAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
         const std::string &eventContent);
@@ -49,6 +50,9 @@ public:
     void ClearAudioDev(const std::string &devId);
     int32_t CreateAudioDevice(const std::string &devId);
     void SetChannelState(const std::string &content);
+    int32_t PauseDistributedHardware(const std::string &networkId);
+    int32_t ResumeDistributedHardware(const std::string &networkId);
+    int32_t StopDistributedHardware(const std::string &networkId);
 
 private:
     DAudioSinkManager();
@@ -73,6 +77,7 @@ private:
     IAVEngineProvider *rcvProviderPtr_ = nullptr;
     void *pSHandler_ = nullptr;
     void *pRHandler_ = nullptr;
+    sptr<IDAudioSinkIpcCallback> ipcSinkCallback_ = nullptr;
 };
 } // DistributedHardware
 } // OHOS
diff --git a/services/audiomanager/managersink/src/daudio_sink_dev.cpp b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
index 94433e1a1e3e3c432949f737d211ce4122a8efe2..9ce07833697c0739558fed0a037b2f945e98c30c 100644
--- a/services/audiomanager/managersink/src/daudio_sink_dev.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_dev.cpp
@@ -31,7 +31,8 @@
 
 namespace OHOS {
 namespace DistributedHardware {
-DAudioSinkDev::DAudioSinkDev(const std::string &devId) : devId_(devId)
+DAudioSinkDev::DAudioSinkDev(const std::string &devId, const sptr<IDAudioSinkIpcCallback> &sinkCallback)
+    : devId_(devId), ipcSinkCallback_(sinkCallback)
 {
     DHLOGD("Distributed audio sink device constructed, devId: %s.", GetAnonyString(devId).c_str());
 }
@@ -69,6 +70,7 @@ void DAudioSinkDev::SleepAudioDev()
 int32_t DAudioSinkDev::InitAVTransEngines(const ChannelState channelState, IAVEngineProvider *providerPtr)
 {
     DHLOGI("Init InitAVTransEngines");
+
     if (channelState == ChannelState::UNKNOWN || providerPtr == nullptr) {
         DHLOGE("The channel type is invalid.");
         return ERR_DH_AUDIO_FAILED;
@@ -262,12 +264,13 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args)
         DHLOGE("Get audio param from json failed, error code %d.", ret);
         return ret;
     }
+    micDhId_ = std::string(jParam[KEY_DH_ID]);
     int32_t dhId = ConvertString2Int(std::string(jParam[KEY_DH_ID]));
     if (dhId == -1) {
         DHLOGE("Parse dhId error.");
         return ERR_DH_AUDIO_NULLPTR;
     }
-    std::shared_ptr<IMicClient> micClient = nullptr;
+    std::shared_ptr<DMicClient> micClient = nullptr;
     {
         std::lock_guard<std::mutex> devLck(micClientMutex_);
         micClient = micClientMap_[dhId];
@@ -286,6 +289,12 @@ int32_t DAudioSinkDev::TaskOpenDMic(const std::string &args)
         DHLOGE("Start capture failed, ret: %d.", ret);
         return ERR_DH_AUDIO_FAILED;
     }
+    std::string subType = "mic";
+    bool isSensitive = false;
+    bool isSameAccount = false;
+    ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_PULL_UP_PAGE, subType, devId_,
+        isSensitive, isSameAccount);
+    isPageStatus_.store(true);
     NotifySourceDev(NOTIFY_OPEN_MIC_RESULT, jParam[KEY_DH_ID], ret);
     DHLOGI("Open mic device task end, notify source ret %d.", ret);
     isMicInUse_.store(true);
@@ -301,7 +310,7 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args)
         return ERR_DH_AUDIO_FAILED;
     }
     std::lock_guard<std::mutex> devLck(micClientMutex_);
-    std::shared_ptr<IMicClient> micClient = micClientMap_[dhId];
+    std::shared_ptr<DMicClient> micClient = micClientMap_[dhId];
     if (micClient == nullptr) {
         DHLOGE("Mic client is null or already closed.");
         return DH_SUCCESS;
@@ -316,6 +325,14 @@ int32_t DAudioSinkDev::TaskCloseDMic(const std::string &args)
         DHLOGE("Release mic client failed, ret: %d.", ret);
     }
     micClientMap_.erase(dhId);
+    if (isPageStatus_.load()) {
+        std::string subType = "mic";
+        bool isSensitive = false;
+        bool isSameAccount = false;
+        ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, subType, devId_,
+            isSensitive, isSameAccount);
+    }
+    isPageStatus_.store(false);
     DHLOGI("Close mic device task excute success.");
     return DH_SUCCESS;
 }
@@ -512,7 +529,7 @@ void DAudioSinkDev::NotifySourceDev(const AudioEventType type, const std::string
     if (speakerClient != nullptr) {
         speakerClient->SendMessage(static_cast<uint32_t>(type), jEvent.dump(), devId_);
     }
-    std::shared_ptr<IMicClient> micClient = nullptr;
+    std::shared_ptr<DMicClient> micClient = nullptr;
     {
         std::lock_guard<std::mutex> devLck(micClientMutex_);
         micClient = micClientMap_[dhIdInt];
@@ -892,5 +909,53 @@ int32_t DAudioSinkDev::SinkEventHandler::GetEventParam(const AppExecFwk::InnerEv
     eventParam = paramObj->content;
     return DH_SUCCESS;
 }
+
+int32_t DAudioSinkDev::PauseDistributedHardware(const std::string &networkId)
+{
+    DHLOGI("DAudioSinkDev PauseDistributedHardware.");
+    int32_t dhId = ConvertString2Int(micDhId_);
+    std::shared_ptr<DMicClient> micClient = nullptr;
+    {
+        std::lock_guard<std::mutex> devLck(micClientMutex_);
+        micClient = micClientMap_[dhId];
+    }
+    if (micClient == nullptr) {
+        DHLOGE("Mic client should be init by dev.");
+        return ERR_DH_AUDIO_NULLPTR;
+    }
+    int32_t ret = micClient->PauseCapture();
+    if (ret != DH_SUCCESS) {
+        DHLOGE("Pause mic client failed, ret: %d.", ret);
+    }
+    return ret;
+}
+
+int32_t DAudioSinkDev::ResumeDistributedHardware(const std::string &networkId)
+{
+    DHLOGI("DAudioSinkDev ResumeDistributedHardware.");
+    int32_t dhId = ConvertString2Int(micDhId_);
+    std::shared_ptr<DMicClient> micClient = nullptr;
+    {
+        std::lock_guard<std::mutex> devLck(micClientMutex_);
+        micClient = micClientMap_[dhId];
+    }
+    if (micClient == nullptr) {
+        DHLOGE("Mic client should be init by dev.");
+        return ERR_DH_AUDIO_NULLPTR;
+    }
+    int32_t ret = micClient->ResumeCapture();
+    if (ret != DH_SUCCESS) {
+        DHLOGE("Resume mic client failed, ret: %d.", ret);
+    }
+    return ret;
+}
+
+int32_t DAudioSinkDev::StopDistributedHardware(const std::string &networkId)
+{
+    DHLOGI("DAudioSinkDev StopDistributedHardware.");
+    isPageStatus_.store(false);
+    NotifySourceDev(CLOSE_MIC, micDhId_, DH_SUCCESS);
+    return DH_SUCCESS;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/audiomanager/managersink/src/daudio_sink_manager.cpp b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
index 781bca305c95f27fd0874634e6206426147575a6..7de419e6d02e9904621a115eb82753b60493ade9 100644
--- a/services/audiomanager/managersink/src/daudio_sink_manager.cpp
+++ b/services/audiomanager/managersink/src/daudio_sink_manager.cpp
@@ -59,9 +59,10 @@ DAudioSinkManager::~DAudioSinkManager()
     DHLOGD("Distributed audio sink manager deconstructed.");
 }
 
-int32_t DAudioSinkManager::Init()
+int32_t DAudioSinkManager::Init(const sptr<IDAudioSinkIpcCallback> &sinkCallback)
 {
     DHLOGI("Init audio sink manager.");
+    ipcSinkCallback_ = sinkCallback;
     int32_t ret = GetLocalDeviceNetworkId(localNetworkId_);
     if (ret != DH_SUCCESS) {
         DHLOGE("Get local network id failed, ret: %d.", ret);
@@ -116,6 +117,7 @@ int32_t DAudioSinkManager::UnInit()
     if (devClearThread_.joinable()) {
         devClearThread_.join();
     }
+    ipcSinkCallback_ = nullptr;
     return DH_SUCCESS;
 }
 
@@ -170,7 +172,7 @@ int32_t DAudioSinkManager::CreateAudioDevice(const std::string &devId)
             DHLOGI("Audio sink dev in map. devId: %s.", GetAnonyString(devId).c_str());
             dev = audioDevMap_[devId];
         } else {
-            dev = std::make_shared<DAudioSinkDev>(devId);
+            dev = std::make_shared<DAudioSinkDev>(devId, ipcSinkCallback_);
             if (dev->AwakeAudioDev() != DH_SUCCESS) {
                 DHLOGE("Awake audio dev failed.");
                 return ERR_DH_AUDIO_FAILED;
@@ -371,5 +373,35 @@ int32_t EngineProviderListener::OnProviderEvent(const AVTransEvent &event)
     }
     return DH_SUCCESS;
 }
+
+int32_t DAudioSinkManager::PauseDistributedHardware(const std::string &networkId)
+{
+    std::lock_guard<std::mutex> lock(devMapMutex_);
+    if (audioDevMap_.find(networkId) != audioDevMap_.end()) {
+        DHLOGI("Audio sink dev in map. devId: %s.", GetAnonyString(networkId).c_str());
+        audioDevMap_[networkId]->PauseDistributedHardware(networkId);
+    }
+    return DH_SUCCESS;
+}
+
+int32_t DAudioSinkManager::ResumeDistributedHardware(const std::string &networkId)
+{
+    std::lock_guard<std::mutex> lock(devMapMutex_);
+    if (audioDevMap_.find(networkId) != audioDevMap_.end()) {
+        DHLOGI("Audio sink dev in map. devId: %s.", GetAnonyString(networkId).c_str());
+        audioDevMap_[networkId]->ResumeDistributedHardware(networkId);
+    }
+    return DH_SUCCESS;
+}
+
+int32_t DAudioSinkManager::StopDistributedHardware(const std::string &networkId)
+{
+    std::lock_guard<std::mutex> lock(devMapMutex_);
+    if (audioDevMap_.find(networkId) != audioDevMap_.end()) {
+        DHLOGI("Audio sink dev in map. devId: %s.", GetAnonyString(networkId).c_str());
+        audioDevMap_[networkId]->StopDistributedHardware(networkId);
+    }
+    return DH_SUCCESS;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/audiomanager/servicesink/BUILD.gn b/services/audiomanager/servicesink/BUILD.gn
index 2c6f68cf0fbac1aebce01eff2e91617935f83751..e6fd761a1c1859216599e39cb11cc39da1ba0a16 100755
--- a/services/audiomanager/servicesink/BUILD.gn
+++ b/services/audiomanager/servicesink/BUILD.gn
@@ -74,6 +74,7 @@ ohos_shared_library("distributed_audio_sink") {
     "${services_path}/audiomanager/managersink/src/daudio_sink_dev.cpp",
     "${services_path}/audiomanager/managersink/src/daudio_sink_manager.cpp",
     "src/daudio_sink_hidumper.cpp",
+    "src/daudio_sink_ipc_callback_proxy.cpp",
     "src/daudio_sink_service.cpp",
     "src/daudio_sink_stub.cpp",
   ]
@@ -81,6 +82,7 @@ ohos_shared_library("distributed_audio_sink") {
   deps = [
     "${audio_transport_path}/decodetransport:distributed_audio_decode_transport",
     "${audio_transport_path}/encodetransport:distributed_audio_encode_transport",
+    "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk",
     "${services_path}/common:distributed_audio_utils",
     "//third_party/cJSON:cjson",
   ]
diff --git a/services/audiomanager/servicesink/include/daudio_sink_ipc_callback_proxy.h b/services/audiomanager/servicesink/include/daudio_sink_ipc_callback_proxy.h
new file mode 100644
index 0000000000000000000000000000000000000000..01b0b17a111c011901b1779c801e87d38cd8af20
--- /dev/null
+++ b/services/audiomanager/servicesink/include/daudio_sink_ipc_callback_proxy.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_DAUDIO_SINK_IPC_CALLBACK_PROXY_H
+#define OHOS_DAUDIO_SINK_IPC_CALLBACK_PROXY_H
+
+#include "idaudio_sink_ipc_callback.h"
+#include "iremote_broker.h"
+#include "iremote_proxy.h"
+
+namespace OHOS {
+namespace DistributedHardware {
+class DAudioSinkIpcCallbackProxy : public IRemoteProxy<IDAudioSinkIpcCallback> {
+public:
+    explicit DAudioSinkIpcCallbackProxy(const sptr<IRemoteObject> impl) : IRemoteProxy<IDAudioSinkIpcCallback>(impl) {}
+
+    ~DAudioSinkIpcCallbackProxy() {}
+    int32_t OnNotifyResourceInfo(const ResourceEventType &type, const std::string &subType,
+        const std::string &networkId, bool &isSensitive, bool &isSameAccout) override;
+
+private:
+    static inline BrokerDelegator<DAudioSinkIpcCallbackProxy> delegator_;
+};
+} // DistributedHardware
+} // OHOS
+#endif // OHOS_DAUDIO_SINK_IPC_CALLBACK_PROXY_H
\ No newline at end of file
diff --git a/services/audiomanager/servicesink/include/daudio_sink_service.h b/services/audiomanager/servicesink/include/daudio_sink_service.h
index 633d39348231bf84dd212a5fa0387b7f866cbef2..c282ae567101580895bf1e4527ea377ab1993ffa 100644
--- a/services/audiomanager/servicesink/include/daudio_sink_service.h
+++ b/services/audiomanager/servicesink/include/daudio_sink_service.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2023 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,13 +31,16 @@ public:
     DAudioSinkService(int32_t saId, bool runOnCreate);
     ~DAudioSinkService() override = default;
 
-    int32_t InitSink(const std::string &params) override;
+    int32_t InitSink(const std::string &params, const sptr<IDAudioSinkIpcCallback> &sinkCallback) override;
     int32_t ReleaseSink() override;
     int32_t SubscribeLocalHardware(const std::string &dhId, const std::string &param) override;
     int32_t UnsubscribeLocalHardware(const std::string &dhId) override;
     void DAudioNotify(const std::string &devId, const std::string &dhId, const int32_t eventType,
         const std::string &eventContent) override;
     int Dump(int32_t fd, const std::vector<std::u16string>& args) override;
+    int32_t PauseDistributedHardware(const std::string &networkId) override;
+    int32_t ResumeDistributedHardware(const std::string &networkId) override;
+    int32_t StopDistributedHardware(const std::string &networkId) override;
 
 protected:
     void OnStart() override;
diff --git a/services/audiomanager/servicesink/include/daudio_sink_stub.h b/services/audiomanager/servicesink/include/daudio_sink_stub.h
index f9000041dcc0adef89cb1974a3cd5b8212002eeb..723811e6a7e200f582c886fd49e3d9209c11deeb 100644
--- a/services/audiomanager/servicesink/include/daudio_sink_stub.h
+++ b/services/audiomanager/servicesink/include/daudio_sink_stub.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2023 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,6 +37,10 @@ private:
     int32_t UnsubscribeLocalHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option);
     int32_t DAudioNotifyInner(MessageParcel &data, MessageParcel &reply, MessageOption &option);
     bool VerifyPermission();
+    int32_t PauseDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option);
+    int32_t ResumeDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option);
+    int32_t StopDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option);
+    bool HasAccessDHPermission();
 
     using DAudioSinkServiceFunc = int32_t (DAudioSinkStub::*)(MessageParcel &data, MessageParcel &reply,
         MessageOption &option);
diff --git a/services/audiomanager/servicesink/src/daudio_sink_ipc_callback_proxy.cpp b/services/audiomanager/servicesink/src/daudio_sink_ipc_callback_proxy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..28d78ae429c96a2eb0b78a849b0d0af398bda472
--- /dev/null
+++ b/services/audiomanager/servicesink/src/daudio_sink_ipc_callback_proxy.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2023 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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "daudio_sink_ipc_callback_proxy.h"
+
+#include "daudio_errorcode.h"
+
+#undef DH_LOG_TAG
+#define DH_LOG_TAG "DAudioSinkIpcCallbackProxy"
+
+namespace OHOS {
+namespace DistributedHardware {
+int32_t DAudioSinkIpcCallbackProxy::OnNotifyResourceInfo(const ResourceEventType &type, const std::string &subType,
+    const std::string &networkId, bool &isSensitive, bool &isSameAccout)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        return ERR_DH_AUDIO_SA_WRITE_INTERFACE_TOKEN_FAILED;
+    }
+
+    int32_t resType = static_cast<int32_t>(type);
+    if (!data.WriteInt32(resType) || !data.WriteString(subType) || !data.WriteString(networkId) ||
+        !data.WriteBool(isSensitive) || !data.WriteBool(isSameAccout)) {
+        return ERR_DH_AUDIO_SA_WRITE_PARAM_FAIED;
+    }
+
+    Remote()->SendRequest(NOTIFY_RESOURCEINFO, data, reply, option);
+    int32_t ret = reply.ReadInt32();
+    return ret;
+}
+} // namespace DistributedHardware
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/audiomanager/servicesink/src/daudio_sink_service.cpp b/services/audiomanager/servicesink/src/daudio_sink_service.cpp
index 624ebe1bfc5acf5acab1e8c0d2b226fb47e95655..8e504ec9ca5187e5f38d96cdffdd0f7389f7456d 100644
--- a/services/audiomanager/servicesink/src/daudio_sink_service.cpp
+++ b/services/audiomanager/servicesink/src/daudio_sink_service.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Copyright (c) 2022-2023 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
@@ -72,9 +72,9 @@ bool DAudioSinkService::Init()
     return true;
 }
 
-int32_t DAudioSinkService::InitSink(const std::string &params)
+int32_t DAudioSinkService::InitSink(const std::string &params, const sptr<IDAudioSinkIpcCallback> &sinkCallback)
 {
-    DAudioSinkManager::GetInstance().Init();
+    DAudioSinkManager::GetInstance().Init(sinkCallback);
     return DH_SUCCESS;
 }
 
@@ -139,5 +139,26 @@ int DAudioSinkService::Dump(int32_t fd, const std::vector<std::u16string> &args)
 
     return DH_SUCCESS;
 }
+
+int32_t DAudioSinkService::PauseDistributedHardware(const std::string &networkId)
+{
+    DHLOGI("PauseDistributedHardware networkId:%s.", GetAnonyString(networkId).c_str());
+    DAudioSinkManager::GetInstance().PauseDistributedHardware(networkId);
+    return DH_SUCCESS;
+}
+
+int32_t DAudioSinkService::ResumeDistributedHardware(const std::string &networkId)
+{
+    DHLOGI("ResumeDistributedHardware networkId:%s.", GetAnonyString(networkId).c_str());
+    DAudioSinkManager::GetInstance().ResumeDistributedHardware(networkId);
+    return DH_SUCCESS;
+}
+
+int32_t DAudioSinkService::StopDistributedHardware(const std::string &networkId)
+{
+    DHLOGI("StopDistributedHardware networkId:%s.", GetAnonyString(networkId).c_str());
+    DAudioSinkManager::GetInstance().StopDistributedHardware(networkId);
+    return DH_SUCCESS;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/audiomanager/servicesink/src/daudio_sink_stub.cpp b/services/audiomanager/servicesink/src/daudio_sink_stub.cpp
index 77d9b00fc9eebf79aa4f0a377da50824e1c351e0..af9123502afc351a3cf6bfd11292e43bad735b2c 100644
--- a/services/audiomanager/servicesink/src/daudio_sink_stub.cpp
+++ b/services/audiomanager/servicesink/src/daudio_sink_stub.cpp
@@ -23,6 +23,7 @@
 #include "daudio_errorcode.h"
 #include "daudio_ipc_interface_code.h"
 #include "daudio_log.h"
+#include "daudio_sink_ipc_callback_proxy.h"
 
 #undef DH_LOG_TAG
 #define DH_LOG_TAG "DAudioSinkStub"
@@ -42,6 +43,12 @@ DAudioSinkStub::DAudioSinkStub()
         &DAudioSinkStub::UnsubscribeLocalHardwareInner;
     memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY)] =
         &DAudioSinkStub::DAudioNotifyInner;
+    memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE)] =
+        &DAudioSinkStub::PauseDistributedHardwareInner;
+    memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE)] =
+        &DAudioSinkStub::ResumeDistributedHardwareInner;
+    memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE)] =
+        &DAudioSinkStub::StopDistributedHardwareInner;
 }
 
 DAudioSinkStub::~DAudioSinkStub()
@@ -85,7 +92,14 @@ int32_t DAudioSinkStub::InitSinkInner(MessageParcel &data, MessageParcel &reply,
         return ERR_DH_AUDIO_SA_PERMISSION_FAIED;
     }
     std::string param = data.ReadString();
-    int32_t ret = InitSink(param);
+    sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
+    if (remoteObject == nullptr) {
+        DHLOGE("Read ReadRemoteObject failed.");
+        return ERR_DH_AUDIO_NULLPTR;
+    }
+
+    sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
+    int32_t ret = InitSink(param, dAudioSinkIpcCallbackProxy);
     reply.WriteInt32(ret);
     return DH_SUCCESS;
 }
@@ -128,5 +142,49 @@ int32_t DAudioSinkStub::DAudioNotifyInner(MessageParcel &data, MessageParcel &re
     DAudioNotify(networkId, dhId, eventType, eventContent);
     return DH_SUCCESS;
 }
+
+int32_t DAudioSinkStub::PauseDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
+{
+    if (!HasAccessDHPermission()) {
+        DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
+        return ERR_DH_AUDIO_ACCESS_PERMISSION_CHECK_FAIL;
+    }
+    std::string networkId = data.ReadString();
+    int32_t ret = PauseDistributedHardware(networkId);
+    reply.WriteInt32(ret);
+    return DH_SUCCESS;
+}
+
+int32_t DAudioSinkStub::ResumeDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
+{
+    if (!HasAccessDHPermission()) {
+        DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
+        return ERR_DH_AUDIO_ACCESS_PERMISSION_CHECK_FAIL;
+    }
+    std::string networkId = data.ReadString();
+    int32_t ret = ResumeDistributedHardware(networkId);
+    reply.WriteInt32(ret);
+    return DH_SUCCESS;
+}
+
+int32_t DAudioSinkStub::StopDistributedHardwareInner(MessageParcel &data, MessageParcel &reply, MessageOption &option)
+{
+    if (!HasAccessDHPermission()) {
+        DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
+        return ERR_DH_AUDIO_ACCESS_PERMISSION_CHECK_FAIL;
+    }
+    std::string networkId = data.ReadString();
+    int32_t ret = StopDistributedHardware(networkId);
+    reply.WriteInt32(ret);
+    return DH_SUCCESS;
+}
+
+bool DAudioSinkStub::HasAccessDHPermission()
+{
+    Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
+    const std::string permissionName = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
+    int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken, permissionName);
+    return (result == Security::AccessToken::PERMISSION_GRANTED);
+}
 } // namespace DistributedHardware
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn
index a8a8ff45bbf3bbf633eaaea411c3e17e4a3aba0a..3fe80e029bcbe7130bf576364740eb430f915315 100644
--- a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn
+++ b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn
@@ -44,7 +44,10 @@ ohos_fuzztest("SinkServiceInitSinkFuzzTest") {
     "${services_path}/audiomanager/servicesink/include",
   ]
 
-  deps = [ "${services_path}/audiomanager/servicesink:distributed_audio_sink" ]
+  deps = [
+    "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk",
+    "${services_path}/audiomanager/servicesink:distributed_audio_sink",
+  ]
 
   defines = [
     "HI_LOG_ENABLE",
diff --git a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp
index c866e31709f81f29eb78c4b9539c092793365c26..5530f22b9676b53fbf5f8d4b141a95f56f11a171 100644
--- a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp
+++ b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp
@@ -19,6 +19,7 @@
 #include <cstdint>
 
 #include "daudio_sink_service.h"
+#include "daudio_sink_ipc_callback.h"
 #include "if_system_ability_manager.h"
 #include "iservice_registry.h"
 
@@ -35,8 +36,9 @@ void SinkServiceInitSinkFuzzTest(const uint8_t* data, size_t size)
     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
     
     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
+    sptr<DAudioSinkIpcCallback> dAudioSinkIpcCallback = new DAudioSinkIpcCallback();
 
-    dAudioSinkService->InitSink(params);
+    dAudioSinkService->InitSink(params, dAudioSinkIpcCallback);
 }
 }
 }
diff --git a/services/audiomanager/test/unittest/managersink/BUILD.gn b/services/audiomanager/test/unittest/managersink/BUILD.gn
index e68da596ddb70e1a9a4877fa2a348988e33053fa..042c318bc32e8742fd65b40273c720ead4508440 100644
--- a/services/audiomanager/test/unittest/managersink/BUILD.gn
+++ b/services/audiomanager/test/unittest/managersink/BUILD.gn
@@ -54,8 +54,11 @@ config("module_private_config") {
     "${audio_transport_path}/senderengine/include",
     "${common_path}/include",
     "${innerkits_path}/native_cpp/audio_source/include",
+    "${innerkits_path}/native_cpp/audio_sink/include",
     "${services_path}/audiomanager/managersink/include",
     "${services_path}/audiomanager/test/unittest/managersink/include",
+    "${services_path}/audiomanager/test/unittest/audiomanagertestutils/include",
+    "${services_path}/audiomanager/servicesink/include",
     "${services_path}/common/audiodata/include",
     "${services_path}/common/audioeventcallback",
     "${services_path}/common/audioparam",
@@ -71,6 +74,7 @@ ohos_unittest("DaudioSinkDevTest") {
   configs = [ ":module_private_config" ]
 
   deps = [
+    "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk",
     "${services_path}/audiomanager/servicesink:distributed_audio_sink",
     "//third_party/googletest:gmock",
     "//third_party/googletest:gtest_main",
@@ -81,6 +85,8 @@ ohos_unittest("DaudioSinkDevTest") {
     "audio_framework:audio_client",
     "audio_framework:audio_renderer",
     "c_utils:utils",
+    "device_manager:devicemanagersdk",
+    "device_security_level:dslm_sdk",
     "distributed_hardware_fwk:distributed_av_receiver",
     "distributed_hardware_fwk:distributed_av_sender",
     "drivers_interface_audio:libaudio_proxy_1.0",
@@ -103,6 +109,7 @@ ohos_unittest("DAudioSinkManagerTest") {
   configs = [ ":module_private_config" ]
 
   deps = [
+    "${innerkits_path}/native_cpp/audio_sink:distributed_audio_sink_sdk",
     "${services_path}/audiomanager/servicesink:distributed_audio_sink",
     "//third_party/googletest:gmock",
     "//third_party/googletest:gtest_main",
@@ -113,6 +120,8 @@ ohos_unittest("DAudioSinkManagerTest") {
     "audio_framework:audio_client",
     "audio_framework:audio_renderer",
     "c_utils:utils",
+    "device_manager:devicemanagersdk",
+    "device_security_level:dslm_sdk",
     "distributed_hardware_fwk:distributed_av_receiver",
     "distributed_hardware_fwk:distributed_av_sender",
     "drivers_interface_audio:libaudio_proxy_1.0",
diff --git a/services/audiomanager/test/unittest/managersink/include/daudio_sink_manager_test.h b/services/audiomanager/test/unittest/managersink/include/daudio_sink_manager_test.h
index 84489fe659e54f9d34be161027acc44a3e3e126c..0ef1663e49e28944c6eb2d190817e0698dfc08a1 100644
--- a/services/audiomanager/test/unittest/managersink/include/daudio_sink_manager_test.h
+++ b/services/audiomanager/test/unittest/managersink/include/daudio_sink_manager_test.h
@@ -32,6 +32,7 @@ public:
     void TearDown();
 
     DAudioSinkManager daudioSinkManager;
+    sptr<IRemoteObject> remoteObject_ = nullptr;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
index c15854ec0ab29f910d749d0c69a1c3de0354cf83..30dd9f959cc2a7f54c28ecc449ee8afa7dd5f8dc 100644
--- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
+++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_dev_test.cpp
@@ -18,6 +18,9 @@
 #include "audio_event.h"
 #include "daudio_constants.h"
 #include "daudio_errorcode.h"
+#include "if_system_ability_manager.h"
+#include "iservice_registry.h"
+#include "daudio_sink_ipc_callback_proxy.h"
 
 using namespace testing::ext;
 
@@ -30,7 +33,16 @@ void DAudioSinkDevTest::TearDownTestCase(void) {}
 void DAudioSinkDevTest::SetUp()
 {
     std::string networkId = "networkId";
-    sinkDev_ = std::make_shared<DAudioSinkDev>(networkId);
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return;
+    }
+    sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
+    if (remoteObject == nullptr) {
+        return;
+    }
+    sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject));
+    sinkDev_ = std::make_shared<DAudioSinkDev>(networkId, dAudioSinkIpcCallbackProxy);
 }
 
 void DAudioSinkDevTest::TearDown()
@@ -65,12 +77,12 @@ HWTEST_F(DAudioSinkDevTest, InitAVTransEngines_001, TestSize.Level1)
  */
 HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1)
 {
-    sinkDev_->speakerClient_ = nullptr;
     EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->TaskPlayStatusChange(""));
 
     std::string devId = "devid";
     int32_t dhId = 1;
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskPlayStatusChange("{\"dhId\":\"1\"}"));
 }
 
@@ -107,7 +119,6 @@ HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_002, TestSize.Level1)
 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_001, TestSize.Level1)
 {
     std::string args = "{\"dhId\":\"1\"}";
-    sinkDev_->speakerClient_ = nullptr;
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
 }
 
@@ -122,7 +133,8 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
     std::string args = "{\"dhId\":\"1\"}";
     std::string devId = "devId";
     int32_t dhId = 1;
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
 }
 
@@ -137,9 +149,9 @@ HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1)
     std::string devId = "devId";
     int32_t dhId = 1;
     std::string args = "{\"dhId\":\"1\"}";
-    sinkDev_->speakerClient_ = nullptr;
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender(args));
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender(args));
 }
 
@@ -190,7 +202,8 @@ HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1)
     std::string args = "{\"dhId\":\"123\"}";
     std::string devId;
     int32_t dhId = 1 << 27 | 1 << 0;
-    sinkDev_->micClient_ = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
+    auto micClient = std::make_shared<DMicClient>(devId, dhId, sinkDev_);
+    sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient));
     EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
 }
 
@@ -217,7 +230,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1)
     std::string args;
     std::string devId;
     int32_t dhId = 1;
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
 }
 
@@ -244,7 +258,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1)
     std::string args;
     std::string devId;
     int32_t dhId = 1;
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
 }
 
@@ -271,7 +286,8 @@ HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1)
     std::string args;
     std::string devId;
     int32_t dhId = 1;
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
 }
 
@@ -371,9 +387,9 @@ HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1)
     int32_t dhId = 1;
     AudioEvent event;
     event.content = "{\"dhId\":\"123\"}";
-    sinkDev_->speakerClient_ = nullptr;
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
-    sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    auto spkClient = std::make_shared<DSpeakerClient>(devId, dhId, sinkDev_);
+    sinkDev_->spkClientMap_.insert(std::make_pair(DEFAULT_RENDER_ID, spkClient));
     EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
 }
 } // DistributedHardware
diff --git a/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp b/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
index 4903da7619128858bcfed1f47a80324d477feb8b..712f30dc8cc6b99747dbcf62d18e71831209728e 100644
--- a/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
+++ b/services/audiomanager/test/unittest/managersink/src/daudio_sink_manager_test.cpp
@@ -17,6 +17,9 @@
 
 #include "audio_event.h"
 #include "daudio_errorcode.h"
+#include "if_system_ability_manager.h"
+#include "iservice_registry.h"
+#include "daudio_sink_ipc_callback_proxy.h"
 
 using namespace testing::ext;
 
@@ -26,7 +29,17 @@ void DAudioSinkManagerTest::SetUpTestCase(void) {}
 
 void DAudioSinkManagerTest::TearDownTestCase(void) {}
 
-void DAudioSinkManagerTest::SetUp() {}
+void DAudioSinkManagerTest::SetUp()
+{
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return;
+    }
+    remoteObject_ = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
+    if (remoteObject_ == nullptr) {
+        return;
+    }
+}
 
 void DAudioSinkManagerTest::TearDown() {}
 
@@ -38,7 +51,8 @@ void DAudioSinkManagerTest::TearDown() {}
  */
 HWTEST_F(DAudioSinkManagerTest, Init_001, TestSize.Level1)
 {
-    EXPECT_NE(DH_SUCCESS, daudioSinkManager.Init());
+    sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
+    EXPECT_NE(DH_SUCCESS, daudioSinkManager.Init(dAudioSinkIpcCallbackProxy));
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnInit());
 }
 
@@ -58,7 +72,8 @@ HWTEST_F(DAudioSinkManagerTest, CreateAudioDevice_001, TestSize.Level1)
     daudioSinkManager.channelState_ = ChannelState::MIC_CONTROL_OPENED;
     daudioSinkManager.LoadAVSenderEngineProvider();
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.CreateAudioDevice(devId));
-    auto dev = std::make_shared<DAudioSinkDev>(devId);
+    sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
+    auto dev = std::make_shared<DAudioSinkDev>(devId, dAudioSinkIpcCallbackProxy);
     daudioSinkManager.audioDevMap_.emplace(devId, dev);
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.CreateAudioDevice(devId));
     daudioSinkManager.channelState_ = ChannelState::MIC_CONTROL_OPENED;
@@ -97,5 +112,19 @@ HWTEST_F(DAudioSinkManagerTest, LoadAVSenderEngineProvider_001, TestSize.Level1)
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.LoadAVReceiverEngineProvider());
     EXPECT_EQ(DH_SUCCESS, daudioSinkManager.UnloadAVReceiverEngineProvider());
 }
+
+/**
+ * @tc.name: PauseDistributedHardware_001
+ * @tc.desc: Verify the PauseDistributedHardware function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioSinkManagerTest, PauseDistributedHardware_001, TestSize.Level1)
+{
+    std::string networkId = "networkId";
+    EXPECT_EQ(DH_SUCCESS, daudioSinkManager.PauseDistributedHardware(networkId));
+    EXPECT_EQ(DH_SUCCESS, daudioSinkManager.ResumeDistributedHardware(networkId));
+    EXPECT_EQ(DH_SUCCESS, daudioSinkManager.StopDistributedHardware(networkId));
+}
 } // DistributedHardware
 } // OHOS
diff --git a/services/audiomanager/test/unittest/servicesink/include/daudio_sink_service_test.h b/services/audiomanager/test/unittest/servicesink/include/daudio_sink_service_test.h
index 9d4193c27986b50380dc37a40f032ef1a8212e7c..973b0ddfb382b50b9dd6110b6e43915232a4f561 100644
--- a/services/audiomanager/test/unittest/servicesink/include/daudio_sink_service_test.h
+++ b/services/audiomanager/test/unittest/servicesink/include/daudio_sink_service_test.h
@@ -33,6 +33,7 @@ public:
     void SetUp();
     void TearDown();
     std::shared_ptr<DAudioSinkService> sinkSrv_ = nullptr;
+    sptr<IRemoteObject> remoteObject_ = nullptr;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/audiomanager/test/unittest/servicesink/src/daudio_sink_service_test.cpp b/services/audiomanager/test/unittest/servicesink/src/daudio_sink_service_test.cpp
index ff31b03ff8ef110e1b677e99c1b5dc59e2eea253..55dfa438053ad6c560b9271f4284a37cc5dc1252 100644
--- a/services/audiomanager/test/unittest/servicesink/src/daudio_sink_service_test.cpp
+++ b/services/audiomanager/test/unittest/servicesink/src/daudio_sink_service_test.cpp
@@ -16,7 +16,11 @@
 #include "daudio_sink_service_test.h"
 
 #include "audio_event.h"
+#include "daudio_constants.h"
 #include "daudio_errorcode.h"
+#include "if_system_ability_manager.h"
+#include "iservice_registry.h"
+#include "daudio_sink_ipc_callback_proxy.h"
 
 using namespace testing::ext;
 
@@ -30,6 +34,14 @@ void DAudioSinkServiceTest::SetUp()
 {
     uint32_t saId = 6666;
     bool runOnCreate = true;
+    sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
+    if (samgr == nullptr) {
+        return;
+    }
+    remoteObject_ = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
+    if (remoteObject_ == nullptr) {
+        return;
+    }
 
     sinkSrv_ = std::make_shared<DAudioSinkService>(saId, runOnCreate);
 }
@@ -64,7 +76,8 @@ HWTEST_F(DAudioSinkServiceTest, OnStart_001, TestSize.Level1)
 HWTEST_F(DAudioSinkServiceTest, InitSink_001, TestSize.Level1)
 {
     std::string param = "sink";
-    EXPECT_EQ(DH_SUCCESS, sinkSrv_->InitSink(param));
+    sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
+    EXPECT_EQ(DH_SUCCESS, sinkSrv_->InitSink(param, dAudioSinkIpcCallbackProxy));
 }
 
 /**
@@ -107,12 +120,26 @@ HWTEST_F(DAudioSinkServiceTest, UnsubscribeLocalHardware_001, TestSize.Level1)
     int32_t eventType = 2;
     std::string eventContent = "OPEN_MIC";
     std::string param = "sink";
+    sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
 
-    sinkSrv_->InitSink(param);
+    sinkSrv_->InitSink(param, dAudioSinkIpcCallbackProxy);
     sinkSrv_->DAudioNotify(devId, dhId, eventType, eventContent);
     EXPECT_EQ(DH_SUCCESS, sinkSrv_->UnsubscribeLocalHardware(dhId));
     sinkSrv_->ReleaseSink();
 }
 
+/**
+ * @tc.name: PauseDistributedHardware_001
+ * @tc.desc: Verify the PauseDistributedHardware function.
+ * @tc.type: FUNC
+ * @tc.require: AR000H0E5F
+ */
+HWTEST_F(DAudioSinkServiceTest, PauseDistributedHardware_001, TestSize.Level1)
+{
+    std::string networkId = "networkId";
+    EXPECT_EQ(DH_SUCCESS, sinkSrv_->PauseDistributedHardware(networkId));
+    EXPECT_EQ(DH_SUCCESS, sinkSrv_->ResumeDistributedHardware(networkId));
+    EXPECT_EQ(DH_SUCCESS, sinkSrv_->StopDistributedHardware(networkId));
+}
 } // DistributedHardware
 } // OHOS