diff --git a/common/include/dscreen_constants.h b/common/include/dscreen_constants.h index bf763141929649b71cb2f44fcaa18d3021e90d62..cc568fa2f5c27bb2d59acdbc5d80cb6f52f67770 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 438a54da10f00aacbd81d9e204b301c6907e605e..2b92e14c0970ccc169300c163e256c81152a3f03 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 018d2909e2554652a9ffb67b2afa6f87b49bd8e3..86dc4eb545dcc218e89a2d866ff93ead4a563e7d 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 45dc53319904917af1c523c525fb3587409288d6..e12d77b9b44f1a918161a79740b1a0dc6034cc53 100644 --- a/services/screenservice/sinkservice/BUILD.gn +++ b/services/screenservice/sinkservice/BUILD.gn @@ -25,7 +25,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 +48,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 720c0e88f91a00c104ef248b9999df9e22aa3cac..0039543d92a2dc7455e7fe02d6da3a306a17c5b9 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 df842e63e6719269c6e3b9792f5a252054a72d9d..23f5708ad1bd06b063ac36a339f48b53391116f3 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" @@ -77,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) { @@ -112,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) @@ -120,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"); diff --git a/services/screenservice/sinkservice/screenregionmgr/include/screenregion.h b/services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h similarity index 94% rename from services/screenservice/sinkservice/screenregionmgr/include/screenregion.h rename to services/screenservice/sinkservice/screenregionmgr/1.0/include/screenregion.h index 120044d2daeba4512f7661029b9f613c11b4468f..27049e619f7c2249c786502c45937a69da6a3f16 100644 --- a/services/screenservice/sinkservice/screenregionmgr/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 @@ -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 34256b7422024847ffc9deccbf0796cbb8d6481c..f37748624c9b02f4a8ec709ee865d972c722b4d5 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 6e8fafd9b37129eb3e58dbeaf2eb8766a6e950f6..dfee0b809b55cf1dcbc7eed1f00f7ec99ddb1bdd 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 85f1d512d77656cc2f0148cd36a8a3c49e34b588..f371657c50519625ca5c2944feffe635b6b390ba 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 0000000000000000000000000000000000000000..b995223e04a290ee688529e0d717be8dae5584a5 --- /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 0000000000000000000000000000000000000000..dd914e07c126d4f76c5f69d6b8fe52c271d50e68 --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/include/screenregion.h @@ -0,0 +1,78 @@ +/* + * 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; + std::sptr GetWSBuffer(); + + 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 0000000000000000000000000000000000000000..853f8fcd3dac585ea5bacef37332166a7e98c5a9 --- /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 0000000000000000000000000000000000000000..77959add7d3fbda7f471ccd36b21361c19534b35 --- /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 0000000000000000000000000000000000000000..928ff15982c2eb22243c18a2559629b6497336db --- /dev/null +++ b/services/screenservice/sinkservice/screenregionmgr/2.0/src/screenregion.cpp @@ -0,0 +1,378 @@ +/* + * 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_); + } +} + +std::sptr ScreenRegion::GetWSBuffer() +{ + 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; + } + 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()); + 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 0000000000000000000000000000000000000000..d68b14a96f99a0ea52e028282fa494e320286518 --- /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 diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn b/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn index 857e84d40a88f5b49c555690a9be68768ea35c5f..2c2547121c5c883974e18f23342154af559a0da1 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", ] } 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 25db650aab1d82f1a9e164a894522d52ed8e3eee..5efc80f1bd4c1c0ada0cf283729dbddfa09d40de 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 1d9df8448bdcada714f67401c7bcdf0232ad2168..a365a2bc7a8ab57cf7319cd282e491d9a683a876 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 ab31d9de57a9a09dd3f830771ba814e5ac9a289d..47edb234d4d978e249cb2b791505139acd127b22 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 4b480600d624a90814cf411bf17d6400306effa1..dddf4c460b1502b65cf9e355a4d1777a46f39310 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