From 5fec55f43967f7722230c22a82a04d7a5037d4db Mon Sep 17 00:00:00 2001 From: yangli Date: Thu, 15 Jun 2023 20:20:52 +0800 Subject: [PATCH 1/7] 20.20 Signed-off-by: yangli --- common/include/dscreen_constants.h | 14 +- common/include/dscreen_errcode.h | 12 + screenhandler/src/dscreen_handler.cpp | 4 +- services/screenservice/sinkservice/BUILD.gn | 5 +- .../include/dscreen_sink_service.h | 4 +- .../src/dscreen_sink_service.cpp | 1 + .../{ => 1.0}/include/screenregion.h | 4 +- .../{ => 1.0}/include/screenregionmgr.h | 8 +- .../{ => 1.0}/src/screenregion.cpp | 4 +- .../{ => 1.0}/src/screenregionmgr.cpp | 4 +- .../2.0/include/av_receiver_engine_adpater.h | 66 ++++ .../2.0/include/screenregion.h | 77 ++++ .../2.0/include/screenregionmgr.h | 64 +++ .../2.0/src/av_receiver_engine_adpater.cpp | 162 ++++++++ .../screenregionmgr/2.0/src/screenregion.cpp | 372 ++++++++++++++++++ .../2.0/src/screenregionmgr.cpp | 210 ++++++++++ 16 files changed, 998 insertions(+), 13 deletions(-) rename services/screenservice/sinkservice/screenregionmgr/{ => 1.0}/include/screenregion.h (97%) rename services/screenservice/sinkservice/screenregionmgr/{ => 1.0}/include/screenregionmgr.h (92%) rename services/screenservice/sinkservice/screenregionmgr/{ => 1.0}/src/screenregion.cpp (98%) rename services/screenservice/sinkservice/screenregionmgr/{ => 1.0}/src/screenregionmgr.cpp (99%) create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/include/av_receiver_engine_adpater.h create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregionmgr.h create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adpater.cpp create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp create mode 100644 services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregionmgr.cpp diff --git a/common/include/dscreen_constants.h b/common/include/dscreen_constants.h index bf763141..cc568fa2 100644 --- a/common/include/dscreen_constants.h +++ b/common/include/dscreen_constants.h @@ -62,6 +62,17 @@ enum DataType : uint8_t { VIDEO_PART_SCREEN_DATA = 1, }; +enum DScreenMsgType : uint32_t { + SETUP_SIGNAL = 0, +}; + +enum DScreenEventType : uint32_t { + REMOTE_MSG_RECEIVED = 0, + SENDER_ENGINE_ERROR, + RECEIVER_ENGINE_ERROR, + TRANS_CHANNEL_CLOSED, +}; + /* Screen package name */ const std::string PKG_NAME = "ohos.dhardware.dscreen"; @@ -150,6 +161,7 @@ const std::string KEY_COLOR_FORMAT = "colorFormat"; const std::string KEY_FPS = "fps"; const std::string KEY_CODECTYPE = "codecType"; const std::string SCREEN_CLIENT_WINDOW = "screenClientWindow"; +const std::string KEY_DEV_ID = "devId"; const std::string KEY_DH_ID = "dhId"; const std::string KEY_ERR_CODE = "errCode"; const std::string KEY_ERR_CONTENT = "errContent"; @@ -174,7 +186,7 @@ const std::string SINK_WIN_SHOW_Y = "sinkWinShowY"; constexpr uint32_t MAX_MESSAGES_LEN = 40 * 1024 * 1024; constexpr float DEFAULT_DENSITY = 2.0; constexpr int32_t DEFAULT_SCREEN_FLAGS = 0; -constexpr uint32_t DEFAULT_FPS = 30; +constexpr uint32_t DEFAULT_FPS = 60; constexpr int32_t DIRTY_MAX_SIZE = 10; constexpr uint8_t DEFAULT_CODECTYPE = VIDEO_CODEC_TYPE_VIDEO_H264; constexpr uint8_t DEFAULT_VIDEO_FORMAT = VIDEO_DATA_FORMAT_NV12; diff --git a/common/include/dscreen_errcode.h b/common/include/dscreen_errcode.h index 438a54da..2b92e14c 100644 --- a/common/include/dscreen_errcode.h +++ b/common/include/dscreen_errcode.h @@ -110,6 +110,18 @@ enum DScreenErrorCode { ERR_DH_SCREEN_SURFACE_BUFFER_INVALIED = -57001, ERR_DH_SCREEN_SURFACE_FLUSH_FAILED = -57002, ERR_DH_SCREEN_SURFACE_INVALIED = -57003, + // AV Transport component error code + ERR_DH_AV_TRANS_NULL_VALUE = -58000, + ERR_DH_AV_TRANS_ILLEGAL_PARAM = -58001, + ERR_DH_AV_TRANS_TIMEOUT = -58002, + ERR_DH_AV_TRANS_LOAD_ERROR = -58003, + ERR_DH_AV_TRANS_INIT_FAILED = -58004, + ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED = -58005, + ERR_DH_AV_TRANS_SETUP_FAILED = -58006, + ERR_DH_AV_TRANS_START_FAILED = -58007, + ERR_DH_AV_TRANS_STOP_FAILED = -58008, + ERR_DH_AV_TRANS_FEED_DATA_FAILED = -58009, + ERR_DH_AV_TRANS_SEND_MSG_FAILED = -58010, }; } // namespace DistributedHardware } // namespace OHOS diff --git a/screenhandler/src/dscreen_handler.cpp b/screenhandler/src/dscreen_handler.cpp index 018d2909..86dc4eb5 100644 --- a/screenhandler/src/dscreen_handler.cpp +++ b/screenhandler/src/dscreen_handler.cpp @@ -60,12 +60,12 @@ void ScreenListener::OnConnect(uint64_t screenId) { DHLOGI("on screen connect"); if (screenId != SCREEN_ID_DEFAULT) { - DHLOGI("screenId is invalid, screenId: %ulld", screenId); + DHLOGI("screenId is invalid, screenId: %u", screenId); return; } sptr screen = Rosen::ScreenManager::GetInstance().GetScreenById(screenId); if (screen == nullptr) { - DHLOGE("screen not found, screenId: %ulld", screenId); + DHLOGE("screen not found, screenId: %u", screenId); return; } diff --git a/services/screenservice/sinkservice/BUILD.gn b/services/screenservice/sinkservice/BUILD.gn index 45dc5331..3f254295 100644 --- a/services/screenservice/sinkservice/BUILD.gn +++ b/services/screenservice/sinkservice/BUILD.gn @@ -26,6 +26,7 @@ ohos_shared_library("distributed_screen_sink") { include_dirs += [ "./dscreenservice/include", "./screenregionmgr/include", + "${services_path}/screenservice/sinkservice/screenregionmgr", "${interfaces_path}/innerkits/native_cpp/screen_sink/include", "${interfaces_path}/innerkits/native_cpp/screen_sink/include/callback", "${interfaces_path}/innerkits/native_cpp/screen_source/include", @@ -48,8 +49,8 @@ ohos_shared_library("distributed_screen_sink") { "${services_path}/common/utils/src/video_param.cpp", "./dscreenservice/src/dscreen_sink_service.cpp", "./dscreenservice/src/dscreen_sink_stub.cpp", - "./screenregionmgr/src/screenregion.cpp", - "./screenregionmgr/src/screenregionmgr.cpp", + "./screenregionmgr/1.0/src/screenregion.cpp", + "./screenregionmgr/1.0/src/screenregionmgr.cpp", ] deps = [ diff --git a/services/screenservice/sinkservice/dscreenservice/include/dscreen_sink_service.h b/services/screenservice/sinkservice/dscreenservice/include/dscreen_sink_service.h index 720c0e88..0039543d 100644 --- a/services/screenservice/sinkservice/dscreenservice/include/dscreen_sink_service.h +++ b/services/screenservice/sinkservice/dscreenservice/include/dscreen_sink_service.h @@ -20,7 +20,7 @@ #include "system_ability.h" #include "dscreen_sink_stub.h" -#include "screenregionmgr.h" +#include "1.0/include/screenregionmgr.h" namespace OHOS { namespace DistributedHardware { @@ -43,7 +43,7 @@ protected: DISALLOW_COPY_AND_MOVE(DScreenSinkService); private: - std::shared_ptr screenRegionMgr_ = nullptr; + std::string version_ = "3.0"; bool registerToService_ = false; bool Init(); diff --git a/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp b/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp index df842e63..18ea1013 100644 --- a/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp +++ b/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp @@ -14,6 +14,7 @@ */ #include "dscreen_sink_service.h" +#include "1.0/include/screenregionmgr.h" #include "if_system_ability_manager.h" #include "ipc_skeleton.h" diff --git a/services/screenservice/sinkservice/screenregionmgr/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h similarity index 97% rename from services/screenservice/sinkservice/screenregionmgr/include/screenregion.h rename to services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h index 120044d2..1cde640b 100644 --- a/services/screenservice/sinkservice/screenregionmgr/include/screenregion.h +++ b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h @@ -28,6 +28,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class ScreenSinkTransCallback : public IScreenSinkTransCallback { public: ~ScreenSinkTransCallback() override {}; @@ -63,7 +64,7 @@ private: uint64_t screenId_; // local screen id uint64_t displayId_; // local display id bool isRunning = false; - std::string version_ = "1.0"; + std::string version_ = "2.0"; std::shared_ptr videoParam_ = nullptr; std::shared_ptr mapRelation_ = nullptr; @@ -72,6 +73,7 @@ private: std::shared_ptr sinkTrans_ = nullptr; std::shared_ptr windowProperty_ = nullptr; }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/include/screenregionmgr.h b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregionmgr.h similarity index 92% rename from services/screenservice/sinkservice/screenregionmgr/include/screenregionmgr.h rename to services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregionmgr.h index 34256b74..f3774862 100644 --- a/services/screenservice/sinkservice/screenregionmgr/include/screenregionmgr.h +++ b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregionmgr.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DSCREEN_SCREEN_REGION_MGR_H -#define OHOS_DSCREEN_SCREEN_REGION_MGR_H +#ifndef OHOS_DSCREEN_SCREEN_REGION_MGR_V1_0_H +#define OHOS_DSCREEN_SCREEN_REGION_MGR_V1_0_H #include #include @@ -27,6 +27,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class ScreenRegionManager { DECLARE_SINGLE_INSTANCE_BASE(ScreenRegionManager); public: @@ -42,7 +43,7 @@ private: std::map> screenRegions_; std::mutex screenRegionsMtx_; std::string localDevId_; - std::string version_ = "1.0"; + std::string version_ = "2.0"; sptr GetDScreenSourceSA(const std::string &devId); int32_t NotifyRemoteScreenService(const std::string &remoteDevId, const std::string &dhId, @@ -52,6 +53,7 @@ private: void NotifyRemoteSourceSetUpResult(const std::string &remoteDevId, const std::string &dhId, int32_t errCode, const std::string &errContent); }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/src/screenregion.cpp b/services/screenservice/sinkservice/screenregionmgr/1.0/src/screenregion.cpp similarity index 98% rename from services/screenservice/sinkservice/screenregionmgr/src/screenregion.cpp rename to services/screenservice/sinkservice/screenregionmgr/1.0/src/screenregion.cpp index 6e8fafd9..dfee0b80 100644 --- a/services/screenservice/sinkservice/screenregionmgr/src/screenregion.cpp +++ b/services/screenservice/sinkservice/screenregionmgr/1.0/src/screenregion.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "screenregion.h" +#include "1.0/include/screenregion.h" #include "dscreen_constants.h" #include "dscreen_errcode.h" @@ -26,6 +26,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { ScreenRegion::ScreenRegion(const std::string &remoteDevId, uint64_t screenId, uint64_t displayId) { DHLOGD("ScreenRegion construct"); @@ -214,5 +215,6 @@ int32_t ScreenRegion::Stop() isRunning = false; return DH_SUCCESS; } +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/src/screenregionmgr.cpp b/services/screenservice/sinkservice/screenregionmgr/1.0/src/screenregionmgr.cpp similarity index 99% rename from services/screenservice/sinkservice/screenregionmgr/src/screenregionmgr.cpp rename to services/screenservice/sinkservice/screenregionmgr/1.0/src/screenregionmgr.cpp index 85f1d512..f371657c 100644 --- a/services/screenservice/sinkservice/screenregionmgr/src/screenregionmgr.cpp +++ b/services/screenservice/sinkservice/screenregionmgr/1.0/src/screenregionmgr.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "screenregionmgr.h" +#include "1.0/include/screenregionmgr.h" #include "display_manager.h" #include "if_system_ability_manager.h" @@ -35,6 +35,7 @@ using json = nlohmann::json; namespace OHOS { namespace DistributedHardware { +namespace V1_0 { IMPLEMENT_SINGLE_INSTANCE(ScreenRegionManager); ScreenRegionManager::ScreenRegionManager() { @@ -268,5 +269,6 @@ void ScreenRegionManager::PublishMessage(const DHTopic topic, const uint64_t &sc DScreenFwkKit::GetInstance().GetDHFwkKit()->PublishMessage(topic, message); } +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/include/av_receiver_engine_adpater.h b/services/screenservice/sinkservice/screenregionmgr/2.0/include/av_receiver_engine_adpater.h new file mode 100644 index 00000000..b995223e --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/include/av_receiver_engine_adpater.h @@ -0,0 +1,66 @@ +/* + * 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_AV_TRANSPORT_SENDER_ADAPTER_H +#define OHOS_AV_TRANSPORT_SENDER_ADAPTER_H + +#include +#include +#include +#include +#include +#include + +#include "i_av_engine_provider.h" +#include "video_param.h" + +namespace OHOS { +namespace DistributedHardware { +class AVReceiverAdapterCallback { +public: + AVReceiverAdapterCallback() {}; + virtual ~AVReceiverAdapterCallback() = default; + virtual void OnEngineEvent(DScreenEventType event, const std::string &content) = 0; + virtual void OnEngineMessage(const std::shared_ptr &message) = 0; + virtual void OnEngineDataDone(const std::shared_ptr &buffer) = 0; +}; + +class AVTransReceiverAdapter : public IAVReceiverEngineCallback, + public std::enable_shared_from_this { +public: + AVTransReceiverAdapter() {}; + ~AVTransReceiverAdapter() override {}; + + int32_t Initialize(IAVEngineProvider *providerPtr, const std::string& peerDevId); + int32_t Release(); + int32_t Start(); + int32_t Stop(); + int32_t SetParameter(const AVTransTag &tag, const std::string ¶m); + int32_t SendMessageToRemote(const std::shared_ptr &message); + int32_t RegisterAdapterCallback(const std::shared_ptr &callback); + + // interfaces from IAVReceiverEngineCallback + int32_t OnReceiverEvent(const AVTransEvent& event) override; + int32_t OnMessageReceived(const std::shared_ptr &message) override; + int32_t OnDataAvaliable(const std::shared_ptr &buffer) override; + +private: + std::atomic initialized_ {false}; + std::shared_ptr receiverEngine_; + std::shared_ptr adapterCallback_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h new file mode 100644 index 00000000..a1a18d48 --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h @@ -0,0 +1,77 @@ +/* + * 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 + * + * 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_DSCREEN_SCREEN_REGION_V2_0_H +#define OHOS_DSCREEN_SCREEN_REGION_V2_0_H + +#include + +#include "surface.h" + +#include "2.0/include/av_receiver_engine_adpater.h" +#include "distributed_hardware_fwk_kit.h" +#include "dscreen_maprelation.h" +#include "screen_client_common.h" +#include "video_param.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +class ScreenRegion : public AVReceiverAdapterCallback, public std::enable_shared_from_this { +public: + ScreenRegion(const std::string &remoteDevId); + ~ScreenRegion(); + + // interfaces from AVReceiverAdapterCallback + void OnEngineEvent(DScreenEventType event, const std::string &content) override; + void OnEngineMessage(const std::shared_ptr &message) override; + void OnEngineDataDone(const std::shared_ptr &buffer) override; + + int32_t Release(); + int32_t InitReceiverEngine(IAVEngineProvider *providerPtr); + int32_t GetWindowId(); + uint64_t GetScreenId(); + std::string GetRemoteDevId(); + std::shared_ptr GetVideoParam(); + std::shared_ptr GetWindowProperty(); + +private: + int32_t StartReceiverEngine(const std::string &content); + int32_t StopReceiverEngine(); + int32_t SetUp(const std::string &content); + int32_t ConfigWindow(); + bool CheckContentJson(json &contentJson); + void PublishMessage(const DHTopic topic, const uint64_t &screenId, const std::string &remoteDevId, + const int32_t &windowId, std::shared_ptr windowProperty); + +private: + uint64_t screenId_; + uint64_t displayId_; + std::string remoteDevId_; + int32_t windowId_ = INVALID_WINDOW_ID; + uint32_t alignedHeight_ = 0; + bool isRunning = false; + std::atomic frameNumber_; + + sptr windowSurface_ = nullptr; + std::shared_ptr videoParam_ = nullptr; + std::shared_ptr windowProperty_ = nullptr; + std::shared_ptr mapRelation_ = nullptr; + std::shared_ptr receiverAdapter_ = nullptr; +}; +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregionmgr.h b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregionmgr.h new file mode 100644 index 00000000..853f8fcd --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregionmgr.h @@ -0,0 +1,64 @@ +/* + * 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 + * + * 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_DSCREEN_SCREEN_REGION_MGR_V2_0_H +#define OHOS_DSCREEN_SCREEN_REGION_MGR_V2_0_H + +#include +#include + +#include "single_instance.h" +#include "screenregion.h" +#include "idscreen_source.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +class EngineProviderListener : public IAVEngineProviderCallback { +public: + EngineProviderListener() {}; + ~EngineProviderListener() = default; + + // interfaces from IAVEngineProviderCallback + int32_t OnProviderEvent(const AVTransEvent& event) override; +}; + +class ScreenRegionManager { +DECLARE_SINGLE_INSTANCE_BASE(ScreenRegionManager); +public: + ScreenRegionManager(); + ~ScreenRegionManager(); + + int32_t Initialize(); + int32_t Release(); + int32_t CreateDScreenRegion(const std::string &peerDevId); + int32_t DestoryDScreenRegion(const std::string &peerDevId); + void GetScreenDumpInfo(std::string &result); + +private: + int32_t LoadAVReceiverEngineProvider(); + int32_t UnloadAVReceiverEngineProvider(); + +private: + std::vector> screenRegions_; + std::mutex screenRegionsMtx_; + std::string localDevId_; + + IAVEngineProvider *providerPtr_ = nullptr; +}; +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adpater.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adpater.cpp new file mode 100644 index 00000000..77959add --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/av_receiver_engine_adpater.cpp @@ -0,0 +1,162 @@ +/* + * Copyright (c) 2022 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 "2.0/include/av_receiver_engine_adpater.h" + +#include +#include +#include + +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_util.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t AVTransReceiverAdapter::Initialize(IAVEngineProvider *providerPtr, const std::string& peerDevId) +{ + DHLOGI("Initialize enter"); + if (initialized_.load()) { + return DH_SUCCESS; + } + if (providerPtr == nullptr) { + DHLOGE("av transport receiver engine provider ptr is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + receiverEngine_ = providerPtr->CreateAVReceiverEngine(peerDevId); + if (receiverEngine_ == nullptr) { + DHLOGE("create av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + receiverEngine_->RegisterReceiverCallback(shared_from_this()); + initialized_ = true; + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::Release() +{ + DHLOGI("Release enter"); + if (receiverEngine_ != nullptr) { + int32_t ret = receiverEngine_->Release(); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("Release av transport receiver engine failed"); + } + } + initialized_ = false; + receiverEngine_ = nullptr; + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::Start() +{ + DHLOGI("Start enter"); + if (receiverEngine_ == nullptr) { + DHLOGE("av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + return receiverEngine_->Start(); +} + +int32_t AVTransReceiverAdapter::Stop() +{ + DHLOGI("Stop enter"); + if (receiverEngine_ == nullptr) { + DHLOGE("av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverEngine_->Stop(); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("stop av transport receiver engine failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + DHLOGI("Stop Success"); + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::SetParameter(const AVTransTag &tag, const std::string ¶m) +{ + DHLOGI("SetParameter enter"); + if (receiverEngine_ == nullptr) { + DHLOGE("av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverEngine_->SetParameter(tag, param); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("set av transport receiver parameter failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::SendMessageToRemote(const std::shared_ptr &message) +{ + DHLOGI("SendMessageToRemote enter"); + if (receiverEngine_ == nullptr) { + DHLOGE("av transport receiver engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverEngine_->SendMessage(message); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("send meassage to remote sender engine failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_SEND_MSG_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::RegisterAdapterCallback(const std::shared_ptr &callback) +{ + if (callback == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + adapterCallback_ = callback; + return DH_SUCCESS; +} + +int32_t AVTransReceiverAdapter::OnReceiverEvent(const AVTransEvent& event) +{ + DHLOGI("OnReceiverEvent enter. event type:%" PRId32, event.type); + switch (event.type) { + case EventType::EVENT_START_SUCCESS: + DHLOGI("av transport recevier engine start success."); + break; + case EventType::EVENT_ENGINE_ERROR: + case EventType::EVENT_REMOTE_ERROR: + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineEvent(DScreenEventType::RECEIVER_ENGINE_ERROR, event.content); + } + break; + default: + DHLOGE("Invalid event type."); + } + return DH_AVT_SUCCESS; +} + +int32_t AVTransReceiverAdapter::OnMessageReceived(const std::shared_ptr &message) +{ + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineMessage(message); + } + return DH_AVT_SUCCESS; +} + +int32_t AVTransReceiverAdapter::OnDataAvaliable(const std::shared_ptr &buffer) +{ + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineDataDone(buffer); + } + return DH_AVT_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp new file mode 100644 index 00000000..018c0b6c --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp @@ -0,0 +1,372 @@ +/* + * 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 + * + * 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 "2.0/include/screenregion.h" + +#include +#include "display_manager.h" +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_fwkkit.h" +#include "dscreen_hisysevent.h" +#include "dscreen_log.h" +#include "dscreen_json_util.h" +#include "dscreen_util.h" +#include "screen.h" +#include "screen_client.h" +#include "screen_client_common.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +ScreenRegion::ScreenRegion(const std::string &remoteDevId) : remoteDevId_(remoteDevId) +{ + DHLOGI("ScreenRegion ctor."); + frameNumber_.store(0); +} + +ScreenRegion::~ScreenRegion() +{ + DHLOGI("ScreenRegion dctor."); + if (receiverAdapter_ != nullptr) { + receiverAdapter_->Release(); + } + receiverAdapter_ = nullptr; + frameNumber_.store(0); +} + +int32_t ScreenRegion::InitReceiverEngine(IAVEngineProvider *providerPtr) +{ + DHLOGI("InitReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + receiverAdapter_ = std::make_shared(); + } + int32_t ret = receiverAdapter_->Initialize(providerPtr, remoteDevId_); + if (ret != DH_SUCCESS) { + DHLOGE("initialize av receiver adapter failed."); + return ERR_DH_AV_TRANS_INIT_FAILED; + } + return receiverAdapter_->RegisterAdapterCallback(shared_from_this()); +} + +int32_t ScreenRegion::Release() +{ + DHLOGI("ScreenRegion::Release remoteDevId: %s", GetAnonyString(remoteDevId_).c_str()); + if (!isRunning) { + DHLOGI("ScreenRegion not running, no need release"); + return DH_SUCCESS; + } + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is nullptr."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverAdapter_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("sink trans stop failed."); + return ret; + } + ret = ScreenClient::GetInstance().RemoveWindow(windowId_); + if (ret != DH_SUCCESS) { + DHLOGE("remove window failed."); + return ret; + } + isRunning = false; + return DH_SUCCESS; +} + +int32_t ScreenRegion::StartReceiverEngine(const std::string &content) +{ + DHLOGI("StartReceiverEngine enter."); + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = SetUp(content); + if (ret != DH_SUCCESS) { + DHLOGE("set up av receiver parameter failed."); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + ret = receiverAdapter_->Start(); + if (ret != DH_SUCCESS) { + DHLOGE("start av receiver engine failed."); + return ERR_DH_AV_TRANS_START_FAILED; + } + isRunning = true; + PublishMessage(DHTopic::TOPIC_SINK_PROJECT_WINDOW_INFO, screenId_, remoteDevId_, windowId_, windowProperty_); + return DH_SUCCESS; +} + +int32_t ScreenRegion::StopReceiverEngine() +{ + DHLOGI("StopReceiverEngine, remoteDevId: %s, screenId: %u", GetAnonyString(remoteDevId_).c_str(), screenId_); + if (receiverAdapter_ == nullptr) { + DHLOGE("av transport receiver adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = receiverAdapter_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("stop av receiver adapter failed."); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + ret = receiverAdapter_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("release av receiver adapter failed."); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + return DH_SUCCESS; +} + +int32_t ScreenRegion::SetUp(const std::string &content) +{ + json contentJson = json::parse(content, nullptr, false); + if (contentJson.is_discarded()) { + return ERR_DH_SCREEN_INPUT_PARAM_INVALID; + } + if (!CheckContentJson(contentJson) || !contentJson.contains(KEY_VIDEO_PARAM) || + !contentJson.contains(KEY_MAPRELATION)) { + return ERR_DH_SCREEN_INPUT_PARAM_INVALID; + } + screenId_ = contentJson[KEY_SCREEN_ID].get(); + remoteDevId_ = contentJson[KEY_DEV_ID].get(); + displayId_ = Rosen::DisplayManager::GetInstance().GetDefaultDisplayId(); + videoParam_ = std::make_shared(contentJson[KEY_VIDEO_PARAM].get()); + mapRelation_ = std::make_shared(contentJson[KEY_MAPRELATION].get()); + + int32_t ret = ConfigWindow(); + if (ret != DH_SUCCESS) { + DHLOGE("config dscreen region window failed."); + return ret; + } + std::string codecType; + if (videoParam_->GetCodecType() == VIDEO_CODEC_TYPE_VIDEO_H265) { + codecType = MINE_VIDEO_H265; + } else if (videoParam_->GetCodecType() == VIDEO_CODEC_TYPE_VIDEO_H264) { + codecType = MINE_VIDEO_H264; + } else { + codecType = MINE_VIDEO_RAW; + } + std::string pixelFormat; + if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_YUVI420) { + pixelFormat = VIDEO_FORMAT_YUVI420; + } else if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_NV12) { + pixelFormat = VIDEO_FORMAT_NV12; + } else if (videoParam_->GetVideoFormat() == VIDEO_DATA_FORMAT_NV21) { + pixelFormat = VIDEO_FORMAT_NV21; + } else { + pixelFormat = VIDEO_FORMAT_RGBA8888; + } + receiverAdapter_->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, codecType); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_PIXEL_FORMAT, pixelFormat); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_WIDTH, std::to_string(videoParam_->GetVideoWidth())); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_HEIGHT, std::to_string(videoParam_->GetVideoHeight())); + receiverAdapter_->SetParameter(AVTransTag::VIDEO_FRAME_RATE, std::to_string(videoParam_->GetFps())); + receiverAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SCREEN); + + alignedHeight_ = videoParam_->GetVideoHeight(); + if (alignedHeight_ % ALIGNEDBITS != 0) { + alignedHeight_ = ((alignedHeight_ / ALIGNEDBITS) +1) * ALIGNEDBITS; + } + return DH_SUCCESS; +} + +int32_t ScreenRegion::ConfigWindow() +{ + DHLOGI("ConfigWindow enter"); + std::shared_ptr windowProperty = std::make_shared(); + windowProperty->displayId = displayId_; + if (mapRelation_ == nullptr) { + DHLOGE("mapRelation is nullptr."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + ScreenRect screenRect = mapRelation_->GetScreenRect(); + windowProperty->startX = screenRect.startX; + windowProperty->startY = screenRect.startY; + windowProperty->width = screenRect.width; + windowProperty->height = screenRect.height; + windowProperty_ = windowProperty; + + windowId_ = ScreenClient::GetInstance().AddWindow(windowProperty); + if (windowId_ < 0) { + DHLOGE("AddWindow failed."); + ReportOptFail(DSCREEN_OPT_FAIL, ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, "AddWindow failed."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + int32_t ret = ScreenClient::GetInstance().ShowWindow(windowId_); + if (ret != DH_SUCCESS) { + DHLOGE("show window failed."); + ReportOptFail(DSCREEN_OPT_FAIL, ret, "show window failed."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + + sptr surface = ScreenClient::GetInstance().GetSurface(windowId_); + if (surface == nullptr) { + DHLOGE("get window surface failed."); + ReportOptFail(DSCREEN_OPT_FAIL, ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, "get window surface failed."); + return ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED; + } + windowSurface_ = surface; + return DH_SUCCESS; +} + +void ScreenRegion::PublishMessage(const DHTopic topic, const uint64_t &screenId, + const std::string &remoteDevId, const int32_t &windowId, std::shared_ptr windowProperty) +{ + DHLOGI("ScreenRegion PublishMessage"); + if (DScreenFwkKit::GetInstance().GetDHFwkKit() == nullptr) { + DHLOGE("GetDHFwkKit fail."); + return; + } + json messageJosn; + std::string message; + messageJosn[SOURCE_WIN_ID] = screenId; + messageJosn[SOURCE_DEV_ID] = remoteDevId; + messageJosn[SINK_SHOW_WIN_ID] = windowId; + messageJosn[SINK_PROJ_SHOW_WIDTH] = windowProperty->width; + messageJosn[SINK_PROJ_SHOW_HEIGHT] = windowProperty->height; + messageJosn[SINK_WIN_SHOW_X] = windowProperty->startX; + messageJosn[SINK_WIN_SHOW_Y] = windowProperty->startY; + message = messageJosn.dump(); + DScreenFwkKit::GetInstance().GetDHFwkKit()->PublishMessage(topic, message); +} + +void ScreenRegion::OnEngineEvent(DScreenEventType event, const std::string &content) +{ + (void)event; + (void)content; +} + +void ScreenRegion::OnEngineMessage(const std::shared_ptr &message) +{ + DHLOGI("OnEngineMessage enter"); + if (message == nullptr) { + DHLOGE("received engine message is null."); + return; + } + if (message->type_ == DScreenMsgType::SETUP_SIGNAL) { + StartReceiverEngine(message->content_); + } +} + +void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer) +{ + ++frameNumber_; + DHLOGI("OnEngineDataDone enter"); + if (buffer == nullptr) { + DHLOGE("received video buffer data is nullptr."); + return; + } + if (windowSurface_ == nullptr) { + DHLOGE("window surface is nullptr."); + return; + } + sptr wsBuffer = nullptr; + int32_t releaseFence = -1; + OHOS::BufferRequestConfig requestConfig = { + .width = videoParam_->GetVideoWidth(), + .height = videoParam_->GetVideoHeight(), + .strideAlignment = STRIDE_ALIGNMENT, + .format = PIXEL_FMT_YCRCB_420_SP, + .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA, + }; + SurfaceError surfaceErr = windowSurface_->RequestBuffer(wsBuffer, releaseFence, requestConfig); + if(surfaceErr != SURFACE_ERROR_OK || wsBuffer == nullptr) { + DHLOGE("surface request buffer failed, surfaceErr: %d.", surfaceErr); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + auto bufferData = buffer->GetBufferData(0); + auto bufferAddr = bufferData->GetAddress(); + auto wsBufAddr = static_cast(wsBuffer->GetVirAddr()); + uint32_t wsBufSize = wsBuffer->GetSize(); + uint32_t srcOffset = 0; + uint32_t dstOffset = 0; + uint32_t alignedWidth = videoParam_->GetVideoWidth(); + uint32_t chromaOffset = videoParam_->GetVideoWidth() * videoParam_->GetVideoHeight(); + + for (unsigned int yh = 0 ; yh < videoParam_->GetVideoHeight(); yh++) { + int32_t ret = memcpy_s(wsBufAddr + dstOffset, chromaOffset - dstOffset, + bufferAddr + srcOffset, videoParam_->GetVideoWidth()); + if (ret != EOK) { + DHLOGE("memcpy video buffer y data failed,ret: %d.", ret); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + dstOffset += videoParam_->GetVideoWidth(); + srcOffset += alignedWidth; + } + + dstOffset = chromaOffset; + srcOffset = alignedWidth * alignedHeight_; + + for (unsigned int uvh = 0 ; uvh < videoParam_->GetVideoHeight() / TWO; uvh++) { + int32_t ret = memcpy_s(wsBufAddr + dstOffset, wsBufSize - dstOffset, + bufferAddr + srcOffset, videoParam_->GetVideoWidth()); + if (ret != EOK) { + DHLOGE("memcpy video buffer uv data failed,ret: %d.", ret); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + dstOffset += videoParam_->GetVideoWidth(); + srcOffset += alignedWidth; + } + + BufferFlushConfig flushConfig = { {0, 0, wsBuffer->GetWidth(), wsBuffer->GetHeight()}, 0}; + surfaceErr = windowSurface_->FlushBuffer(wsBuffer, -1, flushConfig); + if (surfaceErr != SURFACE_ERROR_OK) { + DHLOGE("surface flush buffer failed, surfaceErr: %d.", surfaceErr); + windowSurface_->CancelBuffer(wsBuffer); + return; + } + DHLOGI("Fill video buffer data to window surface success. frameNumber: %zu", frameNumber_.load()); +} + +uint64_t ScreenRegion::GetScreenId() +{ + return screenId_; +} + +std::string ScreenRegion::GetRemoteDevId() +{ + return remoteDevId_; +} + +std::shared_ptr ScreenRegion::GetVideoParam() +{ + return videoParam_; +} + +int32_t ScreenRegion::GetWindowId() +{ + return windowId_; +} + +std::shared_ptr ScreenRegion::GetWindowProperty() +{ + return windowProperty_; +} + +bool ScreenRegion::CheckContentJson(json &contentJson) +{ + if (!IsUInt64(contentJson, KEY_SCREEN_ID)) { + return false; + } + if (!IsString(contentJson, KEY_DEV_ID)) { + return false; + } + return true; +} +} // namespace V1_0 +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregionmgr.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregionmgr.cpp new file mode 100644 index 00000000..d68b14a9 --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregionmgr.cpp @@ -0,0 +1,210 @@ +/* + * 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 + * + * 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 "2.0/include/screenregionmgr.h" + +#include +#include +#include + +#include "display_manager.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_fwkkit.h" +#include "dscreen_json_util.h" +#include "dscreen_log.h" +#include "dscreen_maprelation.h" +#include "dscreen_util.h" +#include "idscreen_source.h" +#include "screen_client.h" +#include "screen_client_common.h" + +using json = nlohmann::json; + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +IMPLEMENT_SINGLE_INSTANCE(ScreenRegionManager); + +using AVTransProviderClass = IAVEngineProvider *(*)(const std::string); + +const std::string RECEIVER_SO_NAME = "libdistributed_av_receiver.z.so"; +const std::string GET_PROVIDER_FUNC = "GetAVReceiverEngineProvider"; +#ifdef __LP64__ +const std::string LIB_LOAD_PATH = "/system/lib64/"; +#else +const std::string LIB_LOAD_PATH = "/system/lib/"; +#endif + +ScreenRegionManager::ScreenRegionManager() +{ + DHLOGI("ScreenRegionManager"); +} + +ScreenRegionManager::~ScreenRegionManager() +{ + DHLOGI("~ScreenRegionManager"); +} + +int32_t ScreenRegionManager::Initialize() +{ + int32_t ret = LoadAVReceiverEngineProvider(); + if ((ret != DH_SUCCESS) || (providerPtr_ == nullptr)) { + DHLOGE("Load av transport receiver engine provider failed."); + return ERR_DH_AV_TRANS_LOAD_ERROR; + } + return providerPtr_->RegisterProviderCallback(std::make_shared()); +} + +int32_t ScreenRegionManager::Release() +{ + DHLOGI("ScreenRegionManager::ReleaseAllRegion"); + UnloadAVReceiverEngineProvider(); + std::lock_guard lock(screenRegionsMtx_); + for (const auto &screenRegion : screenRegions_) { + if (screenRegion == nullptr) { + continue; + } + int32_t ret = screenRegion->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("Release region failed, remoteDevId: %s, err: %" PRId32, + GetAnonyString(screenRegion->GetRemoteDevId()).c_str(), ret); + } + } + screenRegions_.clear(); + providerPtr_ = nullptr; + return DH_SUCCESS; +} + +int32_t ScreenRegionManager::CreateDScreenRegion(const std::string &peerDevId) +{ + DHLOGI("CreateDScreenRegion for peerDevId: %s", GetAnonyString(peerDevId).c_str()); + auto screenRegion = std::make_shared(peerDevId); + screenRegion->InitReceiverEngine(providerPtr_); + screenRegions_.push_back(screenRegion); + return DH_SUCCESS; +} + +int32_t ScreenRegionManager::DestoryDScreenRegion(const std::string &peerDevId) +{ + DHLOGI("DestoryDScreenRegion for peerDevId: %s", GetAnonyString(peerDevId).c_str()); + for (auto iter = screenRegions_.begin(); iter != screenRegions_.end();) { + if ((*iter)->GetRemoteDevId() == peerDevId) { + (*iter)->Release(); + iter = screenRegions_.erase(iter); + } else { + iter++; + } + } + return DH_SUCCESS; +} + +void ScreenRegionManager::GetScreenDumpInfo(std::string &result) +{ + DHLOGI("GetScreenDumpInfo."); + result.clear(); + result.append("screenRegion OnLine:\n[\n"); + if (screenRegions_.size() == 0) { + result.append("]"); + DHLOGD("no screenRegion"); + return; + } + + for (const auto &screenRegion : screenRegions_) { + result.append(" {\n"); + if (screenRegion == nullptr) { + continue; + } + uint64_t screenId = screenRegion->GetScreenId(); + std::string remoteDevId = screenRegion->GetRemoteDevId(); + std::shared_ptr videoParam = screenRegion->GetVideoParam(); + if (videoParam == nullptr) { + continue; + } + uint32_t screenHeight = videoParam->GetScreenHeight(); + uint32_t screenWidth = videoParam->GetScreenWidth(); + int32_t windowId = screenRegion->GetWindowId(); + std::string screenInfo = " \"clientWindowId\" : \"" + std::to_string(windowId) + "\",\n" + + " \"remoteScreenId\" : \"" + std::to_string(screenId) + "\",\n" + + " \"localDevId\" : \"" + GetAnonyString(localDevId_) + "\",\n" + + " \"remoteDevId\" : \"" + GetAnonyString(remoteDevId) + "\",\n" + + " \"screenWidth\" : \"" + std::to_string(screenWidth) + "\",\n" + + " \"screenHeight\" : \"" + std::to_string(screenHeight) + "\"\n"; + result.append(screenInfo); + } + result.append(" }\n]"); +} + +int32_t ScreenRegionManager::LoadAVReceiverEngineProvider() +{ + DHLOGI("LoadAVReceiverEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + RECEIVER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + RECEIVER_SO_NAME).c_str(), path) == nullptr) { + DHLOGE("File canonicalization failed"); + return ERR_DH_AV_TRANS_LOAD_ERROR; + } + void *pHandler = dlopen(path, RTLD_LAZY | RTLD_NODELETE); + if (pHandler == nullptr) { + DHLOGE("%s handler load failed, failed reason : %s", path, dlerror()); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + AVTransProviderClass getEngineFactoryFunc = (AVTransProviderClass)dlsym(pHandler, GET_PROVIDER_FUNC.c_str()); + if (getEngineFactoryFunc == nullptr) { + DHLOGE("av transport engine factory function handler is null, failed reason : %s", dlerror()); + dlclose(pHandler); + pHandler = nullptr; + return ERR_DH_AV_TRANS_NULL_VALUE; + } + providerPtr_ = getEngineFactoryFunc(OWNER_NAME_D_SCREEN); + return DH_SUCCESS; +} + +int32_t ScreenRegionManager::UnloadAVReceiverEngineProvider() +{ + DHLOGI("UnloadAVReceiverEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + RECEIVER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + RECEIVER_SO_NAME).c_str(), path) == nullptr) { + DHLOGE("File canonicalization failed"); + return ERR_DH_AV_TRANS_LOAD_ERROR; + } + void *pHandler = dlopen(path, RTLD_LAZY | RTLD_NODELETE); + if (pHandler != nullptr) { + dlclose(pHandler); + pHandler = nullptr; + } + return DH_SUCCESS; +} + +int32_t EngineProviderListener::OnProviderEvent(const AVTransEvent& event) +{ + DHLOGI("OnProviderEvent enter. event type:%" PRId32, event.type); + if (event.type == EventType::EVENT_CHANNEL_OPENED) { + ScreenRegionManager::GetInstance().CreateDScreenRegion(event.peerDevId); + } else if (event.type == EventType::EVENT_CHANNEL_CLOSED) { + ScreenRegionManager::GetInstance().DestoryDScreenRegion(event.peerDevId); + } else { + DHLOGE("Invalid event type."); + } + return DH_AVT_SUCCESS; +} +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file -- Gitee From 8e0b7f85a75e9f587ba3d320e945448670ce1ddd Mon Sep 17 00:00:00 2001 From: yangli Date: Thu, 15 Jun 2023 21:18:47 +0800 Subject: [PATCH 2/7] 21:18 Signed-off-by: yangli --- .../sinkservice/screenregionmgr/1.0/include/screenregion.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h index 1cde640b..27049e61 100644 --- a/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h +++ b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DSCREEN_SCREEN_REGION_H -#define OHOS_DSCREEN_SCREEN_REGION_H +#ifndef OHOS_DSCREEN_SCREEN_REGION_V1_0_H +#define OHOS_DSCREEN_SCREEN_REGION_V1_0_H #include -- Gitee From 721f71711fc976774b740bbac4413422b60a963c Mon Sep 17 00:00:00 2001 From: yangli Date: Thu, 15 Jun 2023 21:24:59 +0800 Subject: [PATCH 3/7] 21:18 Signed-off-by: yangli --- .../sinkservice/dscreenservice/src/dscreen_sink_service.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp b/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp index 18ea1013..23f5708a 100644 --- a/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp +++ b/services/screenservice/sinkservice/dscreenservice/src/dscreen_sink_service.cpp @@ -78,7 +78,7 @@ int32_t DScreenSinkService::InitSink(const std::string ¶ms) int32_t DScreenSinkService::ReleaseSink() { DHLOGI("ReleaseSink"); - ScreenRegionManager::GetInstance().ReleaseAllRegions(); + V1_0::ScreenRegionManager::GetInstance().ReleaseAllRegions(); DHLOGI("exit sink sa process"); auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (systemAbilityMgr == nullptr) { @@ -113,7 +113,7 @@ void DScreenSinkService::DScreenNotify(const std::string &devId, int32_t eventCo { DHLOGI("DScreenNotify, devId:%s, eventCode: %" PRId32 ", eventContent:%s", GetAnonyString(devId).c_str(), eventCode, eventContent.c_str()); - ScreenRegionManager::GetInstance().HandleDScreenNotify(devId, eventCode, eventContent); + V1_0::ScreenRegionManager::GetInstance().HandleDScreenNotify(devId, eventCode, eventContent); } int32_t DScreenSinkService::Dump(int32_t fd, const std::vector& args) @@ -121,7 +121,7 @@ int32_t DScreenSinkService::Dump(int32_t fd, const std::vector& DHLOGI("DScreenSinkService Dump."); (void)args; std::string result; - ScreenRegionManager::GetInstance().GetScreenDumpInfo(result); + V1_0::ScreenRegionManager::GetInstance().GetScreenDumpInfo(result); int ret = dprintf(fd, "%s\n", result.c_str()); if (ret < 0) { DHLOGE("dprintf error"); -- Gitee From 0d64e673a6574d9f936a5d548cd5e4ec5395e4e6 Mon Sep 17 00:00:00 2001 From: yangli Date: Thu, 15 Jun 2023 22:52:53 +0800 Subject: [PATCH 4/7] 22.50 Signed-off-by: yangli --- services/screenservice/sinkservice/BUILD.gn | 1 - .../sinkservice/screenregionmgr/2.0/src/screenregion.cpp | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/services/screenservice/sinkservice/BUILD.gn b/services/screenservice/sinkservice/BUILD.gn index 3f254295..e12d77b9 100644 --- a/services/screenservice/sinkservice/BUILD.gn +++ b/services/screenservice/sinkservice/BUILD.gn @@ -25,7 +25,6 @@ ohos_shared_library("distributed_screen_sink") { include_dirs += [ "./dscreenservice/include", - "./screenregionmgr/include", "${services_path}/screenservice/sinkservice/screenregionmgr", "${interfaces_path}/innerkits/native_cpp/screen_sink/include", "${interfaces_path}/innerkits/native_cpp/screen_sink/include/callback", diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp index 018c0b6c..945cfb8e 100644 --- a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp @@ -281,7 +281,7 @@ void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA, }; SurfaceError surfaceErr = windowSurface_->RequestBuffer(wsBuffer, releaseFence, requestConfig); - if(surfaceErr != SURFACE_ERROR_OK || wsBuffer == nullptr) { + if (surfaceErr != SURFACE_ERROR_OK || wsBuffer == nullptr) { DHLOGE("surface request buffer failed, surfaceErr: %d.", surfaceErr); windowSurface_->CancelBuffer(wsBuffer); return; -- Gitee From 84803db4f5286baddf155d7f940c0aa2e68a63a4 Mon Sep 17 00:00:00 2001 From: yangli Date: Fri, 16 Jun 2023 09:11:05 +0800 Subject: [PATCH 5/7] 6.16 Signed-off-by: yangli --- .../test/unittest/sinkservice/screenregionmgr/BUILD.gn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn b/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn index 857e84d4..2c254712 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn @@ -39,7 +39,7 @@ config("module_private_config") { "${services_path}/screentransport/screensinkprocessor/include", "${services_path}/screentransport/screensinkprocessor/decoder/include", "${services_path}/screenclient/include/", - "${services_path}/screenservice/sinkservice/screenregionmgr/include", + "${services_path}/screenservice/sinkservice/screenregionmgr/1.0/include", ] } -- Gitee From 963c716ea86499af7f9e9bfd786fc0e252cc9d11 Mon Sep 17 00:00:00 2001 From: yangli Date: Fri, 16 Jun 2023 10:04:25 +0800 Subject: [PATCH 6/7] 6.16 Signed-off-by: yangli --- .../sinkservice/screenregionmgr/include/screenregion_test.h | 6 ++++-- .../screenregionmgr/include/screenregionmgr_test.h | 6 ++++-- .../sinkservice/screenregionmgr/src/screenregion_test.cpp | 2 ++ .../screenregionmgr/src/screenregionmgr_test.cpp | 2 ++ 4 files changed, 12 insertions(+), 4 deletions(-) diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregion_test.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregion_test.h index 25db650a..5efc80f1 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregion_test.h +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregion_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_SCREEN_REGION_TEST_H -#define OHOS_SCREEN_REGION_TEST_H +#ifndef OHOS_SCREEN_REGION_TEST_V1_0_H +#define OHOS_SCREEN_REGION_TEST_V1_0_H #include #include @@ -27,6 +27,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class ScreenRegionTest : public testing::Test { public: static void SetUpTestCase(void); @@ -35,6 +36,7 @@ public: void TearDown(); std::shared_ptr screenRegion_ = nullptr; }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregionmgr_test.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregionmgr_test.h index 1d9df844..a365a2bc 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregionmgr_test.h +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregionmgr_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_SCREEN_REGION_MANAGER_TEST_H -#define OHOS_SCREEN_REGION_MANAGER_TEST_H +#ifndef OHOS_SCREEN_REGION_MANAGER_TEST_V1_0_H +#define OHOS_SCREEN_REGION_MANAGER_TEST_V1_0_H #include #include @@ -26,6 +26,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class ScreenRegionManagerTest : public testing::Test { public: static void SetUpTestCase(void); @@ -33,6 +34,7 @@ public: void SetUp(); void TearDown(); }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregion_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregion_test.cpp index ab31d9de..47edb234 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregion_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregion_test.cpp @@ -21,6 +21,7 @@ using namespace testing::ext; namespace OHOS { namespace DistributedHardware { +namespace V1_0 { void ScreenRegionTest::SetUpTestCase(void) {} void ScreenRegionTest::TearDownTestCase(void) {} @@ -266,4 +267,5 @@ HWTEST_F(ScreenRegionTest, Stop_003, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret); } } +} } \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregionmgr_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregionmgr_test.cpp index 4b480600..dddf4c46 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregionmgr_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screenregionmgr_test.cpp @@ -20,6 +20,7 @@ using namespace testing::ext; namespace OHOS { namespace DistributedHardware { +namespace V1_0 { void ScreenRegionManagerTest::SetUpTestCase(void) {} void ScreenRegionManagerTest::TearDownTestCase(void) {} @@ -200,4 +201,5 @@ HWTEST_F(ScreenRegionManagerTest, GetDScreenSourceSA_001, TestSize.Level1) EXPECT_EQ(nullptr, ret); } } +} } \ No newline at end of file -- Gitee From cac3e0496279eddb6342ed94474472f543141725 Mon Sep 17 00:00:00 2001 From: yangli Date: Fri, 16 Jun 2023 11:58:50 +0800 Subject: [PATCH 7/7] 6.16 Signed-off-by: yangli --- .../2.0/include/screenregion.h | 1 + .../screenregionmgr/2.0/src/screenregion.cpp | 20 ++++++++++++------- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h index a1a18d48..dd914e07 100644 --- a/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h @@ -38,6 +38,7 @@ public: void OnEngineEvent(DScreenEventType event, const std::string &content) override; void OnEngineMessage(const std::shared_ptr &message) override; void OnEngineDataDone(const std::shared_ptr &buffer) override; + std::sptr GetWSBuffer(); int32_t Release(); int32_t InitReceiverEngine(IAVEngineProvider *providerPtr); diff --git a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp index 945cfb8e..928ff159 100644 --- a/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp @@ -259,14 +259,8 @@ void ScreenRegion::OnEngineMessage(const std::shared_ptr &messag } } -void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer) +std::sptr ScreenRegion::GetWSBuffer() { - ++frameNumber_; - DHLOGI("OnEngineDataDone enter"); - if (buffer == nullptr) { - DHLOGE("received video buffer data is nullptr."); - return; - } if (windowSurface_ == nullptr) { DHLOGE("window surface is nullptr."); return; @@ -286,6 +280,18 @@ void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer windowSurface_->CancelBuffer(wsBuffer); return; } + return wsBuffer; +} + +void ScreenRegion::OnEngineDataDone(const std::shared_ptr &buffer) +{ + ++frameNumber_; + DHLOGI("OnEngineDataDone enter"); + if (buffer == nullptr) { + DHLOGE("received video buffer data is nullptr."); + return; + } + sptr wsBuffer = GetWSBuffer(); auto bufferData = buffer->GetBufferData(0); auto bufferAddr = bufferData->GetAddress(); auto wsBufAddr = static_cast(wsBuffer->GetVirAddr()); -- Gitee