From 5cc68f7d1c2e5e30b4e9f3780798c5f98f2010d0 Mon Sep 17 00:00:00 2001 From: w30042960 Date: Thu, 16 Nov 2023 20:50:31 +0800 Subject: [PATCH] add controlled code Signed-off-by: w30042960 --- common/include/daudio_ipc_interface_code.h | 3 + .../inner_kits/native_cpp/audio_sink/BUILD.gn | 4 +- .../audio_sink/include/daudio_sink_handler.h | 8 +- .../include/daudio_sink_ipc_callback.h | 42 +++++++++++ .../include/daudio_sink_ipc_callback_stub.h | 41 +++++++++++ .../audio_sink/include/daudio_sink_proxy.h | 7 +- .../audio_sink/include/idaudio_sink.h | 6 +- .../include/idaudio_sink_ipc_callback.h | 37 ++++++++++ .../audio_sink/src/daudio_sink_handler.cpp | 49 ++++++++++++- .../src/daudio_sink_ipc_callback.cpp | 50 +++++++++++++ .../src/daudio_sink_ipc_callback_stub.cpp | 63 ++++++++++++++++ .../audio_sink/src/daudio_sink_proxy.cpp | 61 +++++++++++++++- .../sinkproxyinitsink_fuzzer.cpp | 5 +- .../src/daudio_sink_proxy_test.cpp | 4 +- .../micclient/include/dmic_client.h | 3 + .../audioclient/micclient/src/dmic_client.cpp | 22 ++++-- .../managersink/include/daudio_sink_dev.h | 11 ++- .../managersink/include/daudio_sink_manager.h | 7 +- .../managersink/src/daudio_sink_dev.cpp | 73 ++++++++++++++++++- .../managersink/src/daudio_sink_manager.cpp | 36 ++++++++- services/audiomanager/servicesink/BUILD.gn | 2 + .../include/daudio_sink_ipc_callback_proxy.h | 38 ++++++++++ .../servicesink/include/daudio_sink_service.h | 7 +- .../servicesink/include/daudio_sink_stub.h | 5 +- .../src/daudio_sink_ipc_callback_proxy.cpp | 46 ++++++++++++ .../servicesink/src/daudio_sink_service.cpp | 27 ++++++- .../servicesink/src/daudio_sink_stub.cpp | 40 +++++++++- .../sinkserviceinitsink_fuzzer/BUILD.gn | 5 +- .../sinkserviceinitsink_fuzzer.cpp | 4 +- .../test/unittest/managersink/BUILD.gn | 9 +++ .../include/daudio_sink_manager_test.h | 1 + .../managersink/src/daudio_sink_dev_test.cpp | 17 ++++- .../src/daudio_sink_manager_test.cpp | 35 ++++++++- .../include/daudio_sink_service_test.h | 1 + .../src/daudio_sink_service_test.cpp | 31 +++++++- 35 files changed, 758 insertions(+), 42 deletions(-) create mode 100644 interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback.h create mode 100644 interfaces/inner_kits/native_cpp/audio_sink/include/daudio_sink_ipc_callback_stub.h create mode 100644 interfaces/inner_kits/native_cpp/audio_sink/include/idaudio_sink_ipc_callback.h create mode 100644 interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback.cpp create mode 100644 interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback_stub.cpp create mode 100644 services/audiomanager/servicesink/include/daudio_sink_ipc_callback_proxy.h create mode 100644 services/audiomanager/servicesink/src/daudio_sink_ipc_callback_proxy.cpp diff --git a/common/include/daudio_ipc_interface_code.h b/common/include/daudio_ipc_interface_code.h index 93cee7c8..a18c0683 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 0e55bae2..9db8e363 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 ab4725ce..af92873c 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 @@ -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 @@ -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" @@ -32,6 +33,10 @@ public: int32_t UnsubscribeLocalHardware(const std::string &dhId) override; void OnRemoteSinkSvrDied(const wptr &remote); void FinishStartSA(const std::string ¶m, const sptr &remoteObject); + int32_t RegisterPrivacyResources(std::shared_ptr listener) 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: class DAudioSinkSvrRecipient : public IRemoteObject::DeathRecipient { @@ -46,6 +51,7 @@ private: std::condition_variable sinkProxyConVar_; sptr dAudioSinkProxy_ = nullptr; sptr sinkSvrRecipient_ = nullptr; + sptr 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 00000000..da6bdc96 --- /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 +#include + +#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 &listener); + +private: + std::mutex privacyResMtx_; + std::vector> 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 00000000..a9833851 --- /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 + +#include "idaudio_sink_ipc_callback.h" +#include "iremote_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class DAudioSinkIpcCallbackStub : public IRemoteStub { +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 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 5734ddba..027c76cf 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 impl) : IRemoteProxy(impl) {} ~DAudioSinkProxy() = default; - int32_t InitSink(const std::string ¶ms) override; + int32_t InitSink(const std::string ¶ms, const sptr &sinkCallback) override; int32_t ReleaseSink() override; int32_t SubscribeLocalHardware(const std::string &dhId, const std::string ¶m) 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 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 ba07a292..b6021b22 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 ¶ms) = 0; + virtual int32_t InitSink(const std::string ¶ms, const sptr &sinkCallback) = 0; virtual int32_t ReleaseSink() = 0; virtual int32_t SubscribeLocalHardware(const std::string &dhId, const std::string ¶m) = 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 00000000..15974dfa --- /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 8361fa6a..28d2d51c 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 ¶m, const sptrInitSink(param); + dAudioSinkProxy_->InitSink(param, dAudioSinkIpcCallback_); sinkProxyConVar_.notify_one(); DAudioHisysevent::GetInstance().SysEventWriteBehavior(DAUDIO_INIT, "daudio sink sa load success."); } @@ -163,5 +166,49 @@ IDistributedHardwareSink *GetSinkHardwareHandler() DHLOGD("Get sink hardware handler."); return &DAudioSinkHandler::GetInstance(); } + +int32_t DAudioSinkHandler::RegisterPrivacyResources(std::shared_ptr listener) +{ + DHLOGI("RegisterPrivacyResources start."); + if (dAudioSinkIpcCallback_ == nullptr) { + DHLOGE("Daudio sink ipc callback not is nullptr."); + return ERR_DH_AUDIO_SA_PROXY_NOT_INIT; + } + dAudioSinkIpcCallback_->PushPrivacyResCallback(listener); + return DH_SUCCESS; +} + +int32_t DAudioSinkHandler::PauseDistributedHardware(const std::string &networkId) +{ + DHLOGI("pause distributed hardware."); + std::lock_guard 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) +{ + DHLOGI("resume distributed hardware."); + std::lock_guard 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) +{ + DHLOGI("stop distributed hardware."); + std::lock_guard 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 00000000..aaf78e2f --- /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 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 &callback) +{ + DHLOGD("Push resource info callback"); + std::lock_guard 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 00000000..3119c1ed --- /dev/null +++ b/interfaces/inner_kits/native_cpp/audio_sink/src/daudio_sink_ipc_callback_stub.cpp @@ -0,0 +1,63 @@ +/* + * 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::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(data.ReadInt32()); + std::string subType = data.ReadString(); + std::string networkId = data.ReadString(); + bool isSensitive = data.ReadBool(); + bool isSameAccout = data.ReadBool(); + int32_t ret = OnNotifyResourceInfo(type, subType, networkId, isSensitive, isSameAccout); + return ret; +} +} // 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 d33e6e39..94915c96 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 ¶ms) +int32_t DAudioSinkProxy::InitSink(const std::string ¶ms, const sptr &sinkCallback) { MessageParcel data; MessageParcel reply; @@ -34,7 +34,7 @@ int32_t DAudioSinkProxy::InitSink(const std::string ¶ms) 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,62 @@ void DAudioSinkProxy::DAudioNotify(const std::string &devId, const std::string & Remote()->SendRequest(static_cast(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(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE), + data, reply, option); + int32_t ret = reply.ReadInt32(); + return ret; +} + +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(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE), + data, reply, option); + int32_t ret = reply.ReadInt32(); + return ret; +} + +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(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE), + data, reply, option); + int32_t ret = reply.ReadInt32(); + return ret; +} } // 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 b3d6e2d0..465eeb80 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 dAudioProxy = std::make_shared(remoteObject); - - dAudioProxy->InitSink(params); + sptr 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 3422d851..e9e0370a 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 40ba06d1..c453410b 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 micTrans_ = nullptr; int64_t lastCaptureStartTime_ = 0; int64_t lastTransStartTime_ = 0; + std::atomic isPauseStatus_ = false; }; } // DistributedHardware } // OHOS diff --git a/services/audioclient/micclient/src/dmic_client.cpp b/services/audioclient/micclient/src/dmic_client.cpp index 1fb71277..d8fc0f65 100644 --- a/services/audioclient/micclient/src/dmic_client.cpp +++ b/services/audioclient/micclient/src/dmic_client.cpp @@ -178,11 +178,6 @@ int32_t DMicClient::SetUp(const AudioParam ¶m) int32_t DMicClient::SendMessage(uint32_t type, std::string content, std::string dstDevId) { DHLOGI("Send message to remote."); - if (type != static_cast(NOTIFY_OPEN_MIC_RESULT) && - type != static_cast(NOTIFY_CLOSE_MIC_RESULT)) { - DHLOGE("event type is not NOTIFY_OPEN_MIC or NOTIFY_CLOSE_MIC. type: %u", type); - return ERR_DH_AUDIO_NULLPTR; - } if (micTrans_ == nullptr) { DHLOGE("mic trans is null."); return ERR_DH_AUDIO_NULLPTR; @@ -280,6 +275,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(audioData->Data()), audioData->Size()); @@ -391,5 +389,19 @@ void DMicClient::SetAttrs(const std::string &devId, const std::shared_ptr { public: - explicit DAudioSinkDev(const std::string &networkId); + explicit DAudioSinkDev(const std::string &networkId, const sptr &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); @@ -86,11 +90,12 @@ private: std::shared_ptr speakerClient_ = nullptr; std::mutex spkClientMutex_; std::map> spkClientMap_; - std::shared_ptr micClient_ = nullptr; std::mutex micClientMutex_; - std::map> micClientMap_; + std::map> micClientMap_; std::shared_ptr audioCtrlMgr_ = nullptr; static constexpr size_t WAIT_HANDLER_IDLE_TIME_US = 10000; + sptr ipcSinkCallback_ = nullptr; + std::atomic isPageStatus_ = false; std::atomic isSpkInUse_ = false; std::atomic isMicInUse_ = false; diff --git a/services/audiomanager/managersink/include/daudio_sink_manager.h b/services/audiomanager/managersink/include/daudio_sink_manager.h index 4c898f0a..e9892a6d 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 &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 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 e207e541..e2df0261 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 &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 micClient = nullptr; + std::shared_ptr micClient = nullptr; { std::lock_guard 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 isSameAccout = false; + ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_PULL_UP_PAGE, subType, devId_, + isSensitive, isSameAccout); + 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 devLck(micClientMutex_); - std::shared_ptr micClient = micClientMap_[dhId]; + std::shared_ptr 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 isSameAccout = false; + ipcSinkCallback_->OnNotifyResourceInfo(ResourceEventType::EVENT_TYPE_CLOSE_PAGE, subType, devId_, + isSensitive, isSameAccout); + } + 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(type), jEvent.dump(), devId_); } - std::shared_ptr micClient = nullptr; + std::shared_ptr micClient = nullptr; { std::lock_guard 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 micClient = nullptr; + { + std::lock_guard 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 micClient = nullptr; + { + std::lock_guard 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 781bca30..7de419e6 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 &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(devId); + dev = std::make_shared(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 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 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 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 2c6f68cf..e6fd761a 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 00000000..01b0b17a --- /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 { +public: + explicit DAudioSinkIpcCallbackProxy(const sptr impl) : IRemoteProxy(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 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 633d3934..c282ae56 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 ¶ms) override; + int32_t InitSink(const std::string ¶ms, const sptr &sinkCallback) override; int32_t ReleaseSink() override; int32_t SubscribeLocalHardware(const std::string &dhId, const std::string ¶m) 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& 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 f9000041..d9882b4f 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,9 @@ 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); 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 00000000..28d78ae4 --- /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(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 624ebe1b..8e504ec9 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 ¶ms) +int32_t DAudioSinkService::InitSink(const std::string ¶ms, const sptr &sinkCallback) { - DAudioSinkManager::GetInstance().Init(); + DAudioSinkManager::GetInstance().Init(sinkCallback); return DH_SUCCESS; } @@ -139,5 +139,26 @@ int DAudioSinkService::Dump(int32_t fd, const std::vector &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 77d9b00f..5f3688aa 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(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY)] = &DAudioSinkStub::DAudioNotifyInner; + memberFuncMap_[static_cast(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE)] = + &DAudioSinkStub::PauseDistributedHardwareInner; + memberFuncMap_[static_cast(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE)] = + &DAudioSinkStub::ResumeDistributedHardwareInner; + memberFuncMap_[static_cast(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 remoteObject = data.ReadRemoteObject(); + if (remoteObject == nullptr) { + DHLOGE("Read ReadRemoteObject failed."); + return ERR_DH_AUDIO_NULLPTR; + } + + sptr dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject)); + int32_t ret = InitSink(param, dAudioSinkIpcCallbackProxy); reply.WriteInt32(ret); return DH_SUCCESS; } @@ -128,5 +142,29 @@ 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) +{ + 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) +{ + 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) +{ + std::string networkId = data.ReadString(); + int32_t ret = StopDistributedHardware(networkId); + reply.WriteInt32(ret); + return DH_SUCCESS; +} } // 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 a8a8ff45..3fe80e02 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 c866e317..5530f22b 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 #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(data)); auto dAudioSinkService = std::make_shared(saId, runOnCreate); + sptr 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 e68da596..042c318b 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 84489fe6..0ef1663e 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 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 c15854ec..a387770d 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(networkId); + sptr samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgr == nullptr) { + return; + } + sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID); + if (remoteObject == nullptr) { + return; + } + sptr dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject)); + sinkDev_ = std::make_shared(networkId, dAudioSinkIpcCallbackProxy); } void DAudioSinkDevTest::TearDown() @@ -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(devId, dhId, sinkDev_); + auto micClient = std::make_shared(devId, dhId, sinkDev_); + sinkDev_->micClientMap_.insert(std::make_pair(DEFAULT_CAPTURE_ID, micClient)); EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args)); } 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 4903da76..712f30dc 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 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(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(devId); + sptr dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_)); + auto dev = std::make_shared(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 9d4193c2..973b0ddf 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 sinkSrv_ = nullptr; + sptr 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 ff31b03f..55dfa438 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 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(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(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(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 -- Gitee