diff --git a/common/include/dscreen_constants.h b/common/include/dscreen_constants.h index cc568fa2f5c27bb2d59acdbc5d80cb6f52f67770..101c26a197c4f54e0fe8c582b750c9eb692484f5 100644 --- a/common/include/dscreen_constants.h +++ b/common/include/dscreen_constants.h @@ -204,6 +204,7 @@ constexpr uint32_t DECODE_WAIT_MILLISECONDS = 5000; constexpr size_t DATA_BUFFER_MAX_SIZE = 10 * 1024 * 1024; constexpr uint8_t TASK_WAIT_SECONDS = 1; constexpr int32_t JPEG_QUALITY = 80; +constexpr uint32_t BIT_RATE = 12000000; } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/common/imageJpeg/src/jpeg_image_processor.cpp b/services/common/imageJpeg/src/jpeg_image_processor.cpp index b5d17eec5f9ba40fd50dedf35790fc9c9196fb77..c8c5a2be2d2a8a6fa27396eae28aecf628819fd2 100644 --- a/services/common/imageJpeg/src/jpeg_image_processor.cpp +++ b/services/common/imageJpeg/src/jpeg_image_processor.cpp @@ -61,8 +61,8 @@ int32_t JpegImageProcessor::FillDirtyImages2Surface(const std::shared_ptrRequestBuffer(windowSurfaceBuffer, releaseFence, requestConfig); if (surfaceErr != SURFACE_ERROR_OK || windowSurfaceBuffer == nullptr) { diff --git a/services/screenservice/sourceservice/BUILD.gn b/services/screenservice/sourceservice/BUILD.gn index 0029ec5a73710fc1c54846e4eb0928c98b447ef5..b27cdf1ca0c904a9e167593e524caaf544d01c43 100644 --- a/services/screenservice/sourceservice/BUILD.gn +++ b/services/screenservice/sourceservice/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2023 Huawei Device Co., Ltd. +# 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 @@ -27,7 +27,8 @@ ohos_shared_library("distributed_screen_source") { include_dirs += [ "./dscreenservice/include", "./dscreenservice/include/callback", - "./dscreenmgr/include", + "${services_path}/screenservice/sourceservice/dscreenmgr", + "${services_path}/screenservice/sourceservice/dscreenmgr/common/include", "${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", @@ -49,9 +50,9 @@ ohos_shared_library("distributed_screen_source") { "${services_path}/common/utils/src/dscreen_fwkkit.cpp", "${services_path}/common/utils/src/dscreen_maprelation.cpp", "${services_path}/common/utils/src/video_param.cpp", - "./dscreenmgr/src/dscreen.cpp", - "./dscreenmgr/src/dscreen_manager.cpp", - "./dscreenmgr/src/screen_manager_adapter.cpp", + "./dscreenmgr/1.0/src/dscreen.cpp", + "./dscreenmgr/1.0/src/dscreen_manager.cpp", + "./dscreenmgr/common/src/screen_manager_adapter.cpp", "./dscreenservice/src/callback/dscreen_source_callback_proxy.cpp", "./dscreenservice/src/dscreen_source_service.cpp", "./dscreenservice/src/dscreen_source_stub.cpp", diff --git a/services/screenservice/sourceservice/dscreenmgr/include/dscreen.h b/services/screenservice/sourceservice/dscreenmgr/1.0/include/dscreen.h similarity index 97% rename from services/screenservice/sourceservice/dscreenmgr/include/dscreen.h rename to services/screenservice/sourceservice/dscreenmgr/1.0/include/dscreen.h index 2fb81b3a73c216ed8ead1c54a9c144cfd144fa8a..72bf959ad3814e5adacc26d31fc0174c748ca4e5 100644 --- a/services/screenservice/sourceservice/dscreenmgr/include/dscreen.h +++ b/services/screenservice/sourceservice/dscreenmgr/1.0/include/dscreen.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DSCREEN_H -#define OHOS_DSCREEN_H +#ifndef OHOS_DSCREEN_V1_0_H +#define OHOS_DSCREEN_V1_0_H #include #include @@ -28,6 +28,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class DScreen; class IDScreenCallback { public: @@ -121,6 +122,7 @@ private: bool taskThreadRunning_; std::string version_ = "1.0"; }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/include/dscreen_manager.h b/services/screenservice/sourceservice/dscreenmgr/1.0/include/dscreen_manager.h similarity index 97% rename from services/screenservice/sourceservice/dscreenmgr/include/dscreen_manager.h rename to services/screenservice/sourceservice/dscreenmgr/1.0/include/dscreen_manager.h index c970b29f7e4480a9962dfabef15d4f3287cf150c..26490b58e9b5f0171382c5c85ca5ebaecc4fbbf0 100644 --- a/services/screenservice/sourceservice/dscreenmgr/include/dscreen_manager.h +++ b/services/screenservice/sourceservice/dscreenmgr/1.0/include/dscreen_manager.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DSCREEN_MGR_H -#define OHOS_DSCREEN_MGR_H +#ifndef OHOS_DSCREEN_MGR_V1_0_H +#define OHOS_DSCREEN_MGR_V1_0_H #include "distributed_hardware_fwk_kit.h" #include "dm_common.h" @@ -29,6 +29,7 @@ namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class DScreenCallback : public IDScreenCallback { public: void OnRegResult(const std::shared_ptr &dScreen, const std::string &reqId, @@ -84,6 +85,7 @@ private: bool CheckContent(json &eventContent); void HandleNotifySetUpResult(const std::string &remoteDevId, const std::string &eventContent); }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp b/services/screenservice/sourceservice/dscreenmgr/1.0/src/dscreen.cpp similarity index 99% rename from services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp rename to services/screenservice/sourceservice/dscreenmgr/1.0/src/dscreen.cpp index 1b91c09926e0b396348561c8df4f01200f05d655..b75026b573557f1d00a03e29f42667874da84eda 100644 --- a/services/screenservice/sourceservice/dscreenmgr/src/dscreen.cpp +++ b/services/screenservice/sourceservice/dscreenmgr/1.0/src/dscreen.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "dscreen.h" +#include "1.0/include/dscreen.h" #include "avcodec_info.h" #include "avcodec_list.h" @@ -25,11 +25,12 @@ #include "dscreen_json_util.h" #include "dscreen_log.h" #include "dscreen_util.h" -#include "screen_manager_adapter.h" +#include "common/include/screen_manager_adapter.h" #include "screen_source_trans.h" namespace OHOS { namespace DistributedHardware { +namespace V1_0 { constexpr const char* TASK_THREAD = "TaskThread"; DScreen::DScreen(const std::string &devId, const std::string &dhId, std::shared_ptr dscreenCallback) @@ -460,5 +461,6 @@ int32_t DScreen::Stop() sourceTrans_ = nullptr; return DH_SUCCESS; } +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp b/services/screenservice/sourceservice/dscreenmgr/1.0/src/dscreen_manager.cpp similarity index 96% rename from services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp rename to services/screenservice/sourceservice/dscreenmgr/1.0/src/dscreen_manager.cpp index ad3191f350557d0a3c7e7c38d3128536efe7ee2e..c72f342110e30840216e6c0726b2bb4f4285d795 100644 --- a/services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp +++ b/services/screenservice/sourceservice/dscreenmgr/1.0/src/dscreen_manager.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "dscreen_manager.h" +#include "1.0/include/dscreen_manager.h" #include @@ -28,12 +28,13 @@ #include "dscreen_log.h" #include "dscreen_util.h" #include "idscreen_sink.h" -#include "screen_manager_adapter.h" +#include "common/include/screen_manager_adapter.h" using json = nlohmann::json; namespace OHOS { namespace DistributedHardware { +namespace V1_0 { IMPLEMENT_SINGLE_INSTANCE(DScreenManager); const std::map stateMap = { @@ -58,7 +59,7 @@ DScreenManager::~DScreenManager() int32_t DScreenManager::Init() { - DHLOGI("DScreenManager::Init"); + DHLOGI("DScreenManager::Init2.0"); if (dScreenGroupListener_ == nullptr) { dScreenGroupListener_ = new (std::nothrow) DScreenGroupListener(); int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(dScreenGroupListener_); @@ -106,7 +107,7 @@ void DScreenGroupListener::OnChange(const std::vector &screenIds, Rose for (uint64_t screenId : screenIds) { std::shared_ptr changedScreen = DScreenManager::GetInstance().FindDScreenByScreenId(screenId); if (changedScreen == nullptr) { - DHLOGD("screen change not about remote screen, screenId: %ulld", screenId); + DHLOGD("screen change not about remote screen, screenId: %u", screenId); continue; } DScreenManager::GetInstance().HandleScreenChange(changedScreen, event); @@ -122,7 +123,7 @@ void DScreenManager::HandleScreenChange(const std::shared_ptr &changedS } uint64_t screenId = changedScreen->GetScreenId(); - DHLOGI("DScreenManager::HandleScreenChange, screenId: %ulld, changeEvent: %", screenId, event); + DHLOGI("DScreenManager::HandleScreenChange, screenId: %u, changeEvent: %", screenId, event); if (event == Rosen::ScreenGroupChangeEvent::ADD_TO_GROUP) { if (AddToGroup(changedScreen, screenId) != DH_SUCCESS) { DHLOGE("AddToGroup failed."); @@ -144,7 +145,7 @@ void DScreenManager::HandleScreenChange(const std::shared_ptr &changedS int32_t DScreenManager::AddToGroup(const std::shared_ptr &changedScreen, uint64_t screenId) { - DHLOGI("DScreenManager::ADDToGroup, screenId: %ulld", screenId); + DHLOGI("DScreenManager::ADDToGroup, screenId: %u", screenId); if (changedScreen == nullptr) { DHLOGE("DScreenManager::ADDToGroup, dScreen is null."); return ERR_DH_SCREEN_SA_VALUE_NOT_INIT; @@ -156,7 +157,7 @@ int32_t DScreenManager::AddToGroup(const std::shared_ptr &changedScreen } std::shared_ptr mapRelation = ScreenMgrAdapter::GetInstance().GetMapRelation(screenId); if (mapRelation == nullptr) { - DHLOGE("mapRelation construct failed. screenId: %ulld", screenId); + DHLOGE("mapRelation construct failed. screenId: %u", screenId); return ERR_DH_SCREEN_SA_VALUE_NOT_INIT; } @@ -179,7 +180,7 @@ int32_t DScreenManager::AddToGroup(const std::shared_ptr &changedScreen int32_t DScreenManager::RemoveFromGroup(const std::shared_ptr &changedScreen, uint64_t screenId) { - DHLOGI("DScreenManager::RemoveFromGroup, screenId: %ulld", screenId); + DHLOGI("DScreenManager::RemoveFromGroup, screenId: %u", screenId); if (changedScreen == nullptr) { DHLOGE("DScreenManager::RemoveFromGroup, dScreen is null."); return ERR_DH_SCREEN_SA_VALUE_NOT_INIT; @@ -249,7 +250,7 @@ void DScreenManager::OnUnregResult(const std::shared_ptr &dScreen, int32_t DScreenManager::EnableDistributedScreen(const std::string &devId, const std::string &dhId, const std::string &attrs, const std::string &reqId) { - DHLOGI("EnableDistributedScreen, devId: %s, dhId:%s", + DHLOGI("EnableDistributedScreen2.0, devId: %s, dhId:%s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str()); if (dScreenCallback_ == nullptr) { DHLOGE("dscreen manager not init."); @@ -328,7 +329,7 @@ void DScreenManager::RegisterDScreenCallback(const sptr std::shared_ptr DScreenManager::FindDScreenByScreenId(uint64_t screenId) { - DHLOGD("FindDScreenByScreenId, screenId: %ulld", screenId); + DHLOGD("FindDScreenByScreenId, screenId: %u", screenId); std::lock_guard lock(dScreenMapMtx_); for (const auto &iter : dScreens_) { std::shared_ptr dScreen = iter.second; @@ -340,7 +341,7 @@ std::shared_ptr DScreenManager::FindDScreenByScreenId(uint64_t screenId return dScreen; } } - DHLOGD("DScreen not found, screenId: %ulld", screenId); + DHLOGD("DScreen not found, screenId: %u", screenId); return nullptr; } @@ -479,14 +480,14 @@ void DScreenManager::NotifyRemoteSinkSetUp(const std::shared_ptr &dScre eventContentJson[KEY_SCREEN_ID] = dScreen->GetScreenId(); eventContentJson[KEY_DH_ID] = dScreen->GetDHId(); if (dScreen->GetVideoParam() == nullptr) { - DHLOGE("videoParam is null, back to enabled state screedId: %ulld", dScreen->GetScreenId()); + DHLOGE("videoParam is null, back to enabled state screedId: %u", dScreen->GetScreenId()); dScreen->SetState(ENABLED); return; } eventContentJson[KEY_VIDEO_PARAM] = *(dScreen->GetVideoParam()); eventContentJson[KEY_VERSION] = dScreen->GetScreenVersion(); if (mapRelations_.count(dScreen->GetScreenId()) == 0) { - DHLOGE("mapRelation not found, back to enabled state screedId: %ulld", dScreen->GetScreenId()); + DHLOGE("mapRelation not found, back to enabled state screedId: %u", dScreen->GetScreenId()); dScreen->SetState(ENABLED); return; } @@ -555,5 +556,6 @@ std::string DScreenManager::GetScreenVersion() { return version_; } +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/2.0/include/av_sender_engine_adpater.h b/services/screenservice/sourceservice/dscreenmgr/2.0/include/av_sender_engine_adpater.h new file mode 100644 index 0000000000000000000000000000000000000000..8b43e91711062db28ca74d5317b6213af35281b1 --- /dev/null +++ b/services/screenservice/sourceservice/dscreenmgr/2.0/include/av_sender_engine_adpater.h @@ -0,0 +1,85 @@ +/* + * 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 { +struct VideoData { + uint8_t *data; + size_t size; + uint32_t width; + uint32_t height; + int64_t timestamp; + std::string format; +}; +class AVSenderAdapterCallback { +public: + AVSenderAdapterCallback() {}; + virtual ~AVSenderAdapterCallback() = default; + virtual void OnEngineEvent(DScreenEventType event, const std::string &content) = 0; + virtual void OnEngineMessage(const std::shared_ptr &message) = 0; +}; + +class AVTransSenderAdapter : public IAVSenderEngineCallback, + public std::enable_shared_from_this { +public: + AVTransSenderAdapter() {}; + ~AVTransSenderAdapter() 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 PushData(const VideoData &video); + int32_t SendMessageToRemote(const std::shared_ptr &message); + int32_t CreateControlChannel(const std::string& peerDevId); + int32_t RegisterAdapterCallback(const std::shared_ptr &callback); + + // interfaces from IAVSenderEngineCallback + int32_t OnSenderEvent(const AVTransEvent& event) override; + int32_t OnMessageReceived(const std::shared_ptr &message) override; + +private: + int32_t WaitForChannelCreated(); + int32_t WaitForAVTransStarted(); + +private: + std::atomic initialized_ {false}; + std::mutex chnCreatedMtx_; + std::mutex transStartedMtx_; + std::condition_variable chnCreatedCondVar_; + std::condition_variable transStartedCondVar_; + std::atomic chnCreateSuccess_ {false}; + std::atomic transStartSuccess_ {false}; + + std::shared_ptr senderEngine_; + std::shared_ptr adapterCallback_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/2.0/include/dscreen.h b/services/screenservice/sourceservice/dscreenmgr/2.0/include/dscreen.h new file mode 100644 index 0000000000000000000000000000000000000000..02e4f13e8b0691106d47407438fc174eae2c33eb --- /dev/null +++ b/services/screenservice/sourceservice/dscreenmgr/2.0/include/dscreen.h @@ -0,0 +1,135 @@ +/* + * 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_DSCREEN_V2_0_H +#define OHOS_DSCREEN_V2_0_H + +#include +#include +#include +#include + +#include "surface.h" +#include "iconsumer_surface.h" +#include "dscreen_constants.h" +#include "video_param.h" +#include "av_sender_engine_adpater.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +class DScreen; +class IDScreenCallback { +public: + virtual ~IDScreenCallback() {}; + virtual void OnRegResult(const std::shared_ptr &dScreen, + const std::string &reqId, const int32_t status, const std::string &data) = 0; + virtual void OnUnregResult(const std::shared_ptr &dScreen, + const std::string &reqId, const int32_t status, const std::string &data) = 0; +}; + +class Task { +public: + Task(TaskType taskType, const std::string &taskId, const std::string &taskParam) : taskType_(taskType), + taskId_(taskId), taskParam_(taskParam) {}; + Task(TaskType taskType, const std::string &taskParam) : taskType_(taskType), + taskId_(""), taskParam_(taskParam) {}; + ~Task() {}; + + TaskType GetTaskType() + { + return taskType_; + }; + std::string GetTaskId() + { + return taskId_; + }; + std::string GetTaskParam() + { + return taskParam_; + }; + +private: + TaskType taskType_; + std::string taskId_; + std::string taskParam_; +}; + +class ConsumBufferListener : public IBufferConsumerListener { +public: + ConsumBufferListener(const std::shared_ptr dScreen) : dScreen_(dScreen) {}; + ~ConsumBufferListener() = default; + void OnBufferAvailable() override; +private: + static const constexpr char *LOG_TAG = "ConsumBufferListener"; + std::shared_ptr dScreen_; +}; + +class DScreen : public AVSenderAdapterCallback, public std::enable_shared_from_this { +public: + DScreen(const std::string &devId, const std::string &dhId, std::shared_ptr dscreenCallback); + ~DScreen(); + + // interfaces from AVSenderAdapterCallback + void OnEngineEvent(DScreenEventType event, const std::string &content) override; + void OnEngineMessage(const std::shared_ptr &message) override; + + int32_t AddTask(const std::shared_ptr &task); + int32_t InitSenderEngine(IAVEngineProvider *providerPtr, const std::string &peerDevId); + void ConsumeSurface(); + std::string GetDHId() const; + std::string GetDevId() const; + uint64_t GetScreenId() const; + DScreenState GetState() const; + std::shared_ptr GetVideoParam(); + +private: + void TaskThreadLoop(); + void HandleTask(const std::shared_ptr &task); + void HandleEnable(const std::string ¶m, const std::string &taskId); + void HandleDisable(const std::string &taskId); + void HandleConnect(); + void HandleDisconnect(); + int32_t StartSenderEngine(); + int32_t StopSenderEngine(); + int32_t NegotiateCodecType(const std::string &remoteCodecInfoStr); + int32_t ConfigSurface(); + int32_t RemoveSurface(); + int32_t SetUp(); + void Judgment(); + bool CheckJsonData(json &attrJson); + void SetState(DScreenState state); + + std::string devId_; + std::string dhId_; + uint64_t screenId_ = SCREEN_ID_INVALID; + std::shared_ptr videoParam_ = nullptr; + std::shared_ptr dscreenCallback_ = nullptr; + sptr consumerSurface_ = nullptr; + sptr consumerBufferListener_; + + DScreenState curState_; + std::mutex stateMtx_; + std::thread taskQueueThread_; + std::condition_variable taskQueueCond_; + std::mutex taskQueueMtx_; + std::queue> taskQueue_; + bool taskThreadRunning_; + std::shared_ptr senderAdapter_; +}; +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/2.0/include/dscreen_manager.h b/services/screenservice/sourceservice/dscreenmgr/2.0/include/dscreen_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..289cafb79f29a75c490d7f567f1fa5003e4da9e9 --- /dev/null +++ b/services/screenservice/sourceservice/dscreenmgr/2.0/include/dscreen_manager.h @@ -0,0 +1,89 @@ +/* + * 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_DSCREEN_MGR_V2_0_H +#define OHOS_DSCREEN_MGR_V2_0_H + +#include "distributed_hardware_fwk_kit.h" +#include "dm_common.h" +#include "single_instance.h" +#include "screen_manager.h" + +#include "av_sender_engine_adpater.h" +#include "dscreen.h" +#include "dscreen_maprelation.h" +#include "idscreen_sink.h" +#include "idscreen_source_callback.h" +#include "video_param.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +class DScreenCallback : public IDScreenCallback { +public: + void OnRegResult(const std::shared_ptr &dScreen, const std::string &reqId, + const int32_t status, const std::string &data) override; + void OnUnregResult(const std::shared_ptr &dScreen, const std::string &reqId, + const int32_t status, const std::string &data) override; +}; + +class DScreenGroupListener : public Rosen::ScreenManager::IScreenGroupListener { +public: + void OnChange(const std::vector &screenIds, Rosen::ScreenGroupChangeEvent event) override; +}; + +class DScreenManager : public std::enable_shared_from_this { +DECLARE_SINGLE_INSTANCE_BASE(DScreenManager); + +public: + DScreenManager(); + ~DScreenManager(); + + void OnRegResult(const std::shared_ptr &dScreen, const std::string &reqId, + const int32_t status, const std::string &data); + void OnUnregResult(const std::shared_ptr &dScreen, const std::string &reqId, + const int32_t status, const std::string &data); + + int32_t Initialize(); + int32_t Release(); + int32_t EnableDistributedScreen(const std::string &devId, const std::string &dhId, const std::string &attrs, + const std::string &reqId); + int32_t DisableDistributedScreen(const std::string &devId, const std::string &dhId, const std::string &reqId); + void RegisterDScreenCallback(const sptr &callback); + void HandleScreenChange(const std::shared_ptr &changedScreen, Rosen::ScreenGroupChangeEvent event); + std::shared_ptr FindDScreenById(uint64_t screenId); + void GetScreenDumpInfo(std::string &result); + +private: + int32_t StartDScreenMirror(const std::shared_ptr &dScreen); + int32_t StopDScreenMirror(const std::shared_ptr &dScreen); + int32_t LoadAVSenderEngineProvider(); + int32_t UnloadAVSenderEngineProvider(); + void PublishMessage(const DHTopic topic, const std::shared_ptr &dScreen); + +private: + std::string localDevId_; + std::mutex dScreenMapMtx_; + std::map> dScreens_; + + IAVEngineProvider *providerPtr_ = nullptr; + sptr dScreenGroupListener_ = nullptr; + std::shared_ptr dScreenCallback_ = nullptr; + sptr dScreenSourceCallbackProxy_ = nullptr; +}; +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/2.0/src/av_sender_engine_adpater.cpp b/services/screenservice/sourceservice/dscreenmgr/2.0/src/av_sender_engine_adpater.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b421a696ff7858d91b685071f71580d6d1e2673f --- /dev/null +++ b/services/screenservice/sourceservice/dscreenmgr/2.0/src/av_sender_engine_adpater.cpp @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "2.0/include/av_sender_engine_adpater.h" + +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_util.h" + +namespace OHOS { +namespace DistributedHardware { +constexpr int32_t WAIT_TIMEOUT_MS = 5000; + +int32_t AVTransSenderAdapter::Initialize(IAVEngineProvider *providerPtr, const std::string &peerDevId) +{ + DHLOGI("Initialize enter"); + if (initialized_.load()) { + return DH_SUCCESS; + } + if (providerPtr == nullptr) { + DHLOGE("av transport sender engine provider ptr is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + senderEngine_ = providerPtr->CreateAVSenderEngine(peerDevId); + if (senderEngine_ == nullptr) { + DHLOGE("create av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + senderEngine_->RegisterSenderCallback(shared_from_this()); + initialized_ = true; + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::Release() +{ + DHLOGI("Release enter"); + if (senderEngine_ != nullptr) { + int32_t ret = senderEngine_->Release(); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("release av transport sender engine failed"); + } + } + initialized_ = false; + senderEngine_ = nullptr; + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::Start() +{ + DHLOGI("Start enter"); + if (transStartSuccess_.load()) { + DHLOGI("av transport sender channel already created"); + return DH_SUCCESS; + } + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->Start(); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("start av transport sender engine failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_START_FAILED; + } + ret = WaitForAVTransStarted(); + if (ret != DH_SUCCESS) { + DHLOGE("wait for start av transport sender engine failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_START_FAILED; + } + DHLOGI("Start Success"); + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::Stop() +{ + DHLOGI("Stop enter"); + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->Stop(); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("stop av transport sender engine failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + DHLOGI("Stop Success"); + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::CreateControlChannel(const std::string& peerDevId) +{ + DHLOGI("CreateControlChannel enter, peerDevId:%s", GetAnonyString(peerDevId).c_str()); + if (chnCreateSuccess_.load()) { + DHLOGI("av transport sender channel already created"); + return DH_SUCCESS; + } + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + std::vector dstDevIds = {peerDevId}; + int32_t ret = senderEngine_->CreateControlChannel(dstDevIds, ChannelAttribute{TransStrategy::LOW_LATANCY_STRATEGY}); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("create av transport sender channel failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + ret = WaitForChannelCreated(); + if (ret != DH_SUCCESS) { + DHLOGE("wait for create av transport sender channel failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + DHLOGI("CreateControlChannel Success, peerDevId:%s", GetAnonyString(peerDevId).c_str()); + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::SetParameter(const AVTransTag &tag, const std::string ¶m) +{ + DHLOGI("AVTransSenderAdapter::SetParameter enter"); + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->SetParameter(tag, param); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("set av transport sender parameter failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::PushData(const VideoData &video) +{ + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + auto transBuffer = std::make_shared(MetaType::VIDEO); + auto bufferData = transBuffer->WrapBufferData(video.data, video.size, video.size); + auto bufferMata = transBuffer->GetBufferMeta(); + bufferMata->SetMetaItem(AVTransTag::BUFFER_DATA_TYPE, std::to_string(static_cast(MetaType::VIDEO))); + bufferMata->SetMetaItem(AVTransTag::VIDEO_WIDTH, std::to_string(video.width)); + bufferMata->SetMetaItem(AVTransTag::VIDEO_HEIGHT, std::to_string(video.height)); + bufferMata->SetMetaItem(AVTransTag::VIDEO_PIXEL_FORMAT, video.format); + bufferMata->SetMetaItem(AVTransTag::PRE_TIMESTAMP, std::to_string(video.timestamp)); + + int32_t ret = senderEngine_->PushData(transBuffer); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("feed data to av transport sender failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_FEED_DATA_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::SendMessageToRemote(const std::shared_ptr &message) +{ + DHLOGI("AVTransSenderAdapter::SendMessageToRemote enter"); + if (senderEngine_ == nullptr) { + DHLOGE("av transport sender engine is null"); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderEngine_->SendMessage(message); + if (ret != DH_AVT_SUCCESS) { + DHLOGE("send meassage to remote receiver engine failed, ret:%" PRId32, ret); + return ERR_DH_AV_TRANS_SEND_MSG_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::RegisterAdapterCallback(const std::shared_ptr &callback) +{ + if (callback == nullptr) { + return ERR_DH_AV_TRANS_NULL_VALUE; + } + adapterCallback_ = callback; + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::WaitForChannelCreated() +{ + std::unique_lock lock(chnCreatedMtx_); + auto status = chnCreatedCondVar_.wait_for(lock, std::chrono::milliseconds(WAIT_TIMEOUT_MS)); + if (status == std::cv_status::timeout) { + DHLOGE("wait for av transport sender channel created timeout"); + return ERR_DH_AV_TRANS_TIMEOUT; + } + if (!chnCreateSuccess_.load()) { + DHLOGE("create av transport sender channel failed"); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::WaitForAVTransStarted() +{ + std::unique_lock lock(transStartedMtx_); + auto status = transStartedCondVar_.wait_for(lock, std::chrono::milliseconds(WAIT_TIMEOUT_MS)); + if (status == std::cv_status::timeout) { + DHLOGE("wait for av transport sender started timeout"); + return ERR_DH_AV_TRANS_TIMEOUT; + } + if (!transStartSuccess_.load()) { + DHLOGE("start av transport sender engine failed"); + return ERR_DH_AV_TRANS_START_FAILED; + } + return DH_SUCCESS; +} + +int32_t AVTransSenderAdapter::OnSenderEvent(const AVTransEvent& event) +{ + DHLOGI("OnSenderEvent enter. event type:%" PRId32, event.type); + switch (event.type) { + case EventType::EVENT_CHANNEL_OPEN_FAIL: + case EventType::EVENT_CHANNEL_OPENED: { + chnCreateSuccess_ = (event.type == EventType::EVENT_CHANNEL_OPENED); + chnCreatedCondVar_.notify_one(); + break; + } + case EventType::EVENT_CHANNEL_CLOSED: { + chnCreateSuccess_ = false; + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineEvent(DScreenEventType::TRANS_CHANNEL_CLOSED, event.peerDevId); + } + break; + } + case EventType::EVENT_START_FAIL: + case EventType::EVENT_START_SUCCESS: { + transStartSuccess_ = (event.type == EventType::EVENT_START_SUCCESS); + transStartedCondVar_.notify_one(); + 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 AVTransSenderAdapter::OnMessageReceived(const std::shared_ptr &message) +{ + if (adapterCallback_ != nullptr) { + adapterCallback_->OnEngineMessage(message); + } + return DH_AVT_SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/2.0/src/dscreen.cpp b/services/screenservice/sourceservice/dscreenmgr/2.0/src/dscreen.cpp new file mode 100644 index 0000000000000000000000000000000000000000..93378d30ecd092f1d2126b187ea7a3c16505df3a --- /dev/null +++ b/services/screenservice/sourceservice/dscreenmgr/2.0/src/dscreen.cpp @@ -0,0 +1,567 @@ +/* + * 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/dscreen.h" + +#include "avcodec_info.h" +#include "avcodec_list.h" +#include "2.0/include/av_sender_engine_adpater.h" +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_hisysevent.h" +#include "dscreen_json_util.h" +#include "dscreen_log.h" +#include "dscreen_util.h" +#include "common/include/screen_manager_adapter.h" + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +DScreen::DScreen(const std::string &devId, const std::string &dhId, + std::shared_ptr dscreenCallback) +{ + DHLOGD("DScreen construct, devId: %s, dhId: %s", GetAnonyString(devId).c_str(), + GetAnonyString(dhId).c_str()); + devId_ = devId; + dhId_ = dhId; + dscreenCallback_ = dscreenCallback; + SetState(DISABLED); + taskThreadRunning_ = true; + taskQueueThread_ = std::thread(&DScreen::TaskThreadLoop, this); +} + +DScreen::~DScreen() +{ + DHLOGD("DScreen deconstruct, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str()); + taskThreadRunning_ = false; + taskQueueCond_.notify_all(); + if (taskQueueThread_.joinable()) { + taskQueueThread_.join(); + } + StopSenderEngine(); + ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(screenId_); + videoParam_ = nullptr; + senderAdapter_ = nullptr; + DHLOGD("DScreen deconstruct end."); +} + +int32_t DScreen::AddTask(const std::shared_ptr &task) +{ + DHLOGI("DScreen::AddTask, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (task == nullptr) { + DHLOGE("AddTask, task is invalid."); + return ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID; + } + DHLOGI("AddTask, task type: %" PRId32, task->GetTaskType()); + { + std::lock_guard lock(taskQueueMtx_); + taskQueue_.push(task); + } + taskQueueCond_.notify_all(); + return DH_SUCCESS; +} + +void DScreen::HandleTask(const std::shared_ptr &task) +{ + int32_t taskType = task->GetTaskType(); + DHLOGI("HandleTask, devId: %s, dhId: %s, task type: %" PRId32, GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str(), taskType); + switch (taskType) { + case TaskType::TASK_ENABLE: + HandleEnable(task->GetTaskParam(), task->GetTaskId()); + break; + case TaskType::TASK_DISABLE: + HandleDisable(task->GetTaskId()); + break; + case TaskType::TASK_CONNECT: + HandleConnect(); + break; + case TaskType::TASK_DISCONNECT: + HandleDisconnect(); + break; + default: + DHLOGD("task type unkown."); + } +} + +void DScreen::HandleEnable(const std::string ¶m, const std::string &taskId) +{ + DHLOGI("HandleEnable, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (dscreenCallback_ == nullptr) { + DHLOGE("DScreen::HandleEnable, dscreenCallback_ is nullptr"); + return; + } + if ((curState_ == ENABLED) || (curState_ == ENABLING) || (curState_ == CONNECTING) || (curState_ == CONNECTED)) { + dscreenCallback_->OnRegResult(shared_from_this(), taskId, DH_SUCCESS, "dscreen enable success."); + return; + } + SetState(ENABLING); + + json attrJson = json::parse(param, nullptr, false); + if (!CheckJsonData(attrJson)) { + DHLOGE("HandleEnable, check json data failed."); + dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED, + "enable param json is invalid."); + ReportRegisterFail(DSCREEN_REGISTER_FAIL, ERR_DH_SCREEN_SA_ENABLE_FAILED, GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str(), "check json data failed."); + return; + } + if (videoParam_ == nullptr) { + videoParam_ = std::make_shared(); + } + int32_t ret = NegotiateCodecType(attrJson[KEY_CODECTYPE]); + if (ret != DH_SUCCESS) { + DHLOGE("HandleEnable, negotiate codec type failed."); + dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED, + "negotiate codec type failed."); + ReportRegisterFail(DSCREEN_REGISTER_FAIL, ERR_DH_SCREEN_SA_ENABLE_FAILED, GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str(), "negotiate codec type failed."); + return; + } + videoParam_->SetScreenWidth(attrJson[KEY_SCREEN_WIDTH].get()); + videoParam_->SetScreenHeight(attrJson[KEY_SCREEN_HEIGHT].get()); + uint64_t screenId = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId_, dhId_, videoParam_); + if (screenId == SCREEN_ID_INVALID) { + DHLOGE("HandleEnable, create virtual screen failed."); + dscreenCallback_->OnRegResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_ENABLE_FAILED, + "create virtual screen failed."); + ReportRegisterFail(DSCREEN_REGISTER_FAIL, ERR_DH_SCREEN_SA_ENABLE_FAILED, GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str(), "create virtual screen failed."); + return; + } + + screenId_ = screenId; + SetState(ENABLED); + dscreenCallback_->OnRegResult(shared_from_this(), taskId, DH_SUCCESS, "dscreen enable success."); + ReportRegisterScreenEvent(DSCREEN_REGISTER, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), + "dscreen enable success."); +} + +void DScreen::HandleDisable(const std::string &taskId) +{ + DHLOGI("HandleDisable, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (dscreenCallback_ == nullptr) { + DHLOGE("DScreen::HandleDisable, dscreenCallback_ is nullptr"); + return; + } + SetState(DISABLING); + int32_t ret = ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(screenId_); + if (ret != DH_SUCCESS) { + DHLOGE("HandleDisable, remove virtual screen failed."); + dscreenCallback_->OnUnregResult(shared_from_this(), taskId, ERR_DH_SCREEN_SA_DISABLE_FAILED, + "remove virtual screen failed."); + ReportUnRegisterFail(DSCREEN_UNREGISTER_FAIL, ERR_DH_SCREEN_SA_DISABLE_FAILED, GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str(), "remove virtual screen failed."); + return; + } + SetState(DISABLED); + dscreenCallback_->OnUnregResult(shared_from_this(), taskId, DH_SUCCESS, ""); + ReportUnRegisterScreenEvent(DSCREEN_UNREGISTER, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), + "dscreen disable success."); +} + +void DScreen::HandleConnect() +{ + DHLOGI("HandleConnect, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + SetState(CONNECTING); + int32_t ret = StartSenderEngine(); + if (ret != DH_SUCCESS) { + SetState(ENABLED); + ScreenMgrAdapter::GetInstance().RemoveScreenFromGroup(screenId_); + DHLOGE("HandleConnect, start av transport sender engine failed."); + return; + } + ret = ConfigSurface(); + if (ret != DH_SUCCESS) { + SetState(ENABLED); + ScreenMgrAdapter::GetInstance().RemoveScreenFromGroup(screenId_); + DHLOGE("HandleConnect, config image surface failed."); + return; + } + SetState(CONNECTED); + ReportScreenMirrorEvent(DSCREEN_PROJECT_START, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), + "dscreen connect success"); +} + +void DScreen::HandleDisconnect() +{ + DHLOGD("HandleDisconnect, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (curState_ != CONNECTED) { + DHLOGE("dscreen is not connected, cannot disconnect"); + return; + } + SetState(DISCONNECTING); + int32_t ret = RemoveSurface(); + if (ret != DH_SUCCESS) { + DHLOGE("remove image surface failed."); + } + ret = StopSenderEngine(); + if (ret != DH_SUCCESS) { + SetState(CONNECTED); + DHLOGE("dScreen Stop failed."); + return; + } + SetState(ENABLED); + ReportScreenMirrorEvent(DSCREEN_PROJECT_END, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), + "dscreen disconnect success"); +} + +int32_t DScreen::ConfigSurface() +{ + DHLOGD("ConfigSurface, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + consumerSurface_ = Surface::CreateSurfaceAsConsumer(); + if (consumerSurface_ == nullptr) { + DHLOGE("Create consumer surface failed."); + return ERR_DH_SCREEN_CODEC_SURFACE_ERROR; + } + sptr producer = consumerSurface_->GetProducer(); + if (producer == nullptr) { + DHLOGE("Get preducer surface failed."); + return ERR_DH_SCREEN_CODEC_SURFACE_ERROR; + } + sptr producerSurface = Surface::CreateSurfaceAsProducer(producer); + if (producerSurface == nullptr) { + DHLOGE("Create preducer surface failed."); + return ERR_DH_SCREEN_CODEC_SURFACE_ERROR; + } + if (consumerBufferListener_ == nullptr) { + consumerBufferListener_ = new ConsumBufferListener(shared_from_this()); + } + consumerSurface_->RegisterConsumerListener(consumerBufferListener_); + ScreenMgrAdapter::GetInstance().SetImageSurface(screenId_, producerSurface); + DHLOGI("ConfigSurface success."); + return DH_SUCCESS; +} + +int32_t DScreen::RemoveSurface() +{ + if (consumerSurface_ == nullptr) { + DHLOGE("consumerSurface_ is nullptr."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + consumerSurface_->UnregisterConsumerListener(); + + consumerSurface_ = nullptr; + DHLOGI("RemoveSurface success."); + return DH_SUCCESS; +} + +void ConsumBufferListener::OnBufferAvailable() +{ + DHLOGI("OnBufferAvailable enter."); + if (dScreen_ == nullptr) { + DHLOGE("dScreen is nullptr, cannot consume surface buffer."); + return; + } + if (dScreen_->GetState() != CONNECTED) { + DHLOGD("screen is not connected, no need consume surface buffer."); + return; + } + dScreen_->ConsumeSurface(); +} + +void DScreen::ConsumeSurface() +{ + DHLOGI("ConsumeSurface enter."); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null."); + return; + } + if (consumerSurface_ == nullptr) { + DHLOGE("consumerSurface_ is nullptr, cannot consume surface buffer."); + return; + } + sptr surfaceBuffer = nullptr; + int32_t fence = -1; + int64_t timestamp = 0; + OHOS::Rect damage = {0, 0, 0, 0}; + SurfaceError surfaceErr = consumerSurface_->AcquireBuffer(surfaceBuffer, fence, timestamp, damage); + if (surfaceErr != SURFACE_ERROR_OK) { + DHLOGE("consumerSurface_ acquire buffer failed, errcode: %d", surfaceErr); + return; + } + uint32_t surBufSize = surfaceBuffer->GetSize(); + auto surBufAddr = static_cast(surfaceBuffer->GetVirAddr()); + uint32_t videoWidth = videoParam_->GetVideoWidth(); + uint32_t videoHeight = videoParam_->GetVideoHeight(); + VideoData data = { surBufAddr, surBufSize, videoWidth, videoHeight, timestamp, VIDEO_FORMAT_RGBA8888 }; + int32_t ret = senderAdapter_->PushData(data); + if (ret != DH_SUCCESS) { + DHLOGE("feed buffer to av transport sender failed."); + } + consumerSurface_->ReleaseBuffer(surfaceBuffer, -1); + DHLOGI("ConsumeSurface success. timestamp=%lld", (long long)timestamp); +} + +int32_t DScreen::InitSenderEngine(IAVEngineProvider *providerPtr, const std::string &peerDevId) +{ + DHLOGI("InitSenderEngine enter."); + if (senderAdapter_ == nullptr) { + senderAdapter_ = std::make_shared(); + } + int32_t ret = senderAdapter_->Initialize(providerPtr, peerDevId); + if (ret != DH_SUCCESS) { + DHLOGE("initialize av sender adapter failed."); + return ERR_DH_AV_TRANS_INIT_FAILED; + } + return senderAdapter_->RegisterAdapterCallback(shared_from_this()); +} + +int32_t DScreen::StartSenderEngine() +{ + DHLOGI("StartSenderEngine, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderAdapter_->CreateControlChannel(devId_); + if (ret != DH_SUCCESS) { + DHLOGE("create av sender control channel failed."); + return ERR_DH_AV_TRANS_CREATE_CHANNEL_FAILED; + } + ret = SetUp(); + if (ret != DH_SUCCESS) { + DHLOGE("set up av sender engine failed."); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + ret = senderAdapter_->Start(); + if (ret != DH_SUCCESS) { + DHLOGE("start av sender engine failed."); + return ERR_DH_AV_TRANS_START_FAILED; + } + return DH_SUCCESS; +} + +int32_t DScreen::StopSenderEngine() +{ + DHLOGI("StopSenderEngine, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + int32_t ret = senderAdapter_->Stop(); + if (ret != DH_SUCCESS) { + DHLOGE("stop av sender adapter failed."); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + ret = senderAdapter_->Release(); + if (ret != DH_SUCCESS) { + DHLOGE("release av sender adapter failed."); + return ERR_DH_AV_TRANS_STOP_FAILED; + } + return DH_SUCCESS; +} + +void DScreen::Judgment() +{ + DHLOGI("SetUp, devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + if (senderAdapter_ == nullptr) { + DHLOGE("av transport sender adapter is null."); + return ERR_DH_AV_TRANS_NULL_VALUE; + } + if (videoParam_ == nullptr) { + DHLOGE("videoParam is nullptr."); + return ERR_DH_SCREEN_SA_VALUE_NOT_INIT; + } +} + +int32_t DScreen::SetUp() +{ + Judgment() + auto mapRelation = ScreenMgrAdapter::GetInstance().GetMapRelation(screenId_); + if (mapRelation == nullptr) { + DHLOGE("get map relation failed."); + return ERR_DH_AV_TRANS_SETUP_FAILED; + } + DisplayRect displayRect = mapRelation->GetDisplayRect(); + videoParam_->SetVideoWidth(displayRect.width); + videoParam_->SetVideoHeight(displayRect.height); + + json paramJson; + paramJson[KEY_DEV_ID] = devId_; + paramJson[KEY_DH_ID] = dhId_; + paramJson[KEY_SCREEN_ID] = screenId_; + paramJson[KEY_VIDEO_PARAM] = *videoParam_; + paramJson[KEY_MAPRELATION] = *mapRelation; + + auto avMessage = std::make_shared(DScreenMsgType::SETUP_SIGNAL, paramJson.dump(), devId_); + int32_t ret = senderAdapter_->SendMessageToRemote(avMessage); + if (ret != DH_SUCCESS) { + DHLOGE("set message to remote engine 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; + } + senderAdapter_->SetParameter(AVTransTag::VIDEO_CODEC_TYPE, codecType); + senderAdapter_->SetParameter(AVTransTag::VIDEO_PIXEL_FORMAT, pixelFormat); + senderAdapter_->SetParameter(AVTransTag::VIDEO_WIDTH, std::to_string(videoParam_->GetVideoWidth())); + senderAdapter_->SetParameter(AVTransTag::VIDEO_HEIGHT, std::to_string(videoParam_->GetVideoHeight())); + senderAdapter_->SetParameter(AVTransTag::VIDEO_FRAME_RATE, std::to_string(videoParam_->GetFps())); + senderAdapter_->SetParameter(AVTransTag::VIDEO_BIT_RATE, std::to_string(BIT_RATE)); + return senderAdapter_->SetParameter(AVTransTag::ENGINE_READY, OWNER_NAME_D_SCREEN); +} + +int32_t DScreen::NegotiateCodecType(const std::string &remoteCodecInfoStr) +{ + json remoteCodecArray = json::parse(remoteCodecInfoStr, nullptr, false); + if (remoteCodecArray.is_discarded() || !remoteCodecArray.is_array()) { + DHLOGE("remoteCodecInfoStrjson is invalid."); + return ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL; + } + + std::vector localCodecArray; + std::shared_ptr codecList = Media::AVCodecListFactory::CreateAVCodecList(); + if (codecList == nullptr) { + DHLOGE("codecList is nullptr."); + return ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL; + } + std::vector> caps = codecList->GetVideoEncoderCaps(); + for (const auto &cap : caps) { + if (cap == nullptr) { + continue; + } + std::shared_ptr codecInfo = cap->GetCodecInfo(); + if (codecInfo == nullptr) { + continue; + } + localCodecArray.push_back(codecInfo->GetName()); + } + std::vector codecTypeCandidates; + for (const auto &remoteCodecType : remoteCodecArray) { + if (std::find(localCodecArray.begin(), localCodecArray.end(), + remoteCodecType) != localCodecArray.end()) { + codecTypeCandidates.push_back(remoteCodecType); + } + } + if (std::find(codecTypeCandidates.begin(), codecTypeCandidates.end(), + CODEC_NAME_H265) != codecTypeCandidates.end()) { + videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H265); + videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_NV12); + } else if (std::find(codecTypeCandidates.begin(), codecTypeCandidates.end(), + CODEC_NAME_H264) != codecTypeCandidates.end()) { + videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_H264); + videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_NV12); + } else if (std::find(codecTypeCandidates.begin(), codecTypeCandidates.end(), + CODEC_NAME_MPEG4) != codecTypeCandidates.end()) { + videoParam_->SetCodecType(VIDEO_CODEC_TYPE_VIDEO_MPEG4); + videoParam_->SetVideoFormat(VIDEO_DATA_FORMAT_RGBA8888); + } else { + DHLOGI("codec type not support."); + return ERR_DH_SCREEN_SA_DSCREEN_NEGOTIATE_CODEC_FAIL; + } + return DH_SUCCESS; +} + +void DScreen::TaskThreadLoop() +{ + DHLOGI("DScreen taskThread start. devId: %s, dhId: %s", GetAnonyString(devId_).c_str(), + GetAnonyString(dhId_).c_str()); + while (taskThreadRunning_) { + std::shared_ptr task; + { + std::unique_lock lock(taskQueueMtx_); + taskQueueCond_.wait_for(lock, std::chrono::seconds(TASK_WAIT_SECONDS), + [this]() { return !taskQueue_.empty(); }); + if (taskQueue_.empty()) { + continue; + } + task = taskQueue_.front(); + taskQueue_.pop(); + } + if (task == nullptr) { + DHLOGD("task is null."); + continue; + } + DHLOGD("run task, task queue size: %zu", taskQueue_.size()); + HandleTask(task); + } +} + +bool DScreen::CheckJsonData(json &attrJson) +{ + if (attrJson.is_discarded()) { + DHLOGE("enable param json is invalid."); + return false; + } + if (!IsUInt32(attrJson, KEY_SCREEN_WIDTH) || !IsUInt32(attrJson, KEY_SCREEN_HEIGHT) || + !attrJson.contains(KEY_CODECTYPE)) { + DHLOGE("enable param is invalid."); + return false; + } + return true; +} + +void DScreen::OnEngineEvent(DScreenEventType event, const std::string &content) +{ + (void)event; + (void)content; +} + +void DScreen::OnEngineMessage(const std::shared_ptr &message) +{ + (void)message; +} + +std::shared_ptr DScreen::GetVideoParam() +{ + return videoParam_; +} + +void DScreen::SetState(DScreenState state) +{ + std::lock_guard lock(stateMtx_); + curState_ = state; +} + +DScreenState DScreen::GetState() const +{ + return curState_; +} + +uint64_t DScreen::GetScreenId() const +{ + return screenId_; +} + +std::string DScreen::GetDHId() const +{ + return dhId_; +} + +std::string DScreen::GetDevId() const +{ + return devId_; +} +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/2.0/src/dscreen_manager.cpp b/services/screenservice/sourceservice/dscreenmgr/2.0/src/dscreen_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2278288f184dcfd40741dcc4039f2fd99981f04c --- /dev/null +++ b/services/screenservice/sourceservice/dscreenmgr/2.0/src/dscreen_manager.cpp @@ -0,0 +1,436 @@ +/* + * 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/dscreen_manager.h" + +#include +#include +#include +#include + +#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_util.h" +#include "idscreen_sink.h" +#include "common/include/screen_manager_adapter.h" + +using json = nlohmann::json; + +namespace OHOS { +namespace DistributedHardware { +namespace V2_0 { +IMPLEMENT_SINGLE_INSTANCE(DScreenManager); + +using AVTransProviderClass = IAVEngineProvider *(*)(const std::string); + +const std::string SENDER_SO_NAME = "libdistributed_av_sender.z.so"; +const std::string GET_PROVIDER_FUNC = "GetAVSenderEngineProvider"; +#ifdef __LP64__ +const std::string LIB_LOAD_PATH = "/system/lib64/"; +#else +const std::string LIB_LOAD_PATH = "/system/lib/"; +#endif + +const std::map stateMap = { + { DISABLED, "disabled" }, + { ENABLED, "enabled" }, + { DISABLING, "disabling" }, + { ENABLING, "enabling" }, + { CONNECTING, "connecting" }, + { CONNECTED, "connected" }, + { DISCONNECTING, "disconnecting" } +}; + +DScreenManager::DScreenManager() +{ + DHLOGI("DScreenMgr construct."); +} + +DScreenManager::~DScreenManager() +{ + DHLOGI("DScreenMgr deConstruct."); +} + +int32_t DScreenManager::Initialize() +{ + DHLOGI("DScreenManager::Init3.0"); + if (dScreenGroupListener_ == nullptr) { + dScreenGroupListener_ = new (std::nothrow) DScreenGroupListener(); + int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(dScreenGroupListener_); + if (ret != DH_SUCCESS) { + DHLOGE("DScreenManager Init failed, err: %" PRId32, ret); + delete dScreenGroupListener_; + dScreenGroupListener_ = nullptr; + return ret; + } + } + if (dScreenCallback_ == nullptr) { + dScreenCallback_ = std::make_shared(); + } + int32_t ret = LoadAVSenderEngineProvider(); + if (ret != DH_SUCCESS) { + DHLOGE("Load av transport sender engine provider failed."); + } + return ret; +} + +int32_t DScreenManager::Release() +{ + DHLOGI("DScreenManager::UnInit"); + UnloadAVSenderEngineProvider(); + ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(dScreenGroupListener_); + { + std::lock_guard lock(dScreenMapMtx_); + dScreens_.clear(); + } + providerPtr_ = nullptr; + dScreenCallback_ = nullptr; + DHLOGI("DScreenManager::UnInit success"); + return DH_SUCCESS; +} + +void DScreenGroupListener::OnChange(const std::vector &screenIds, Rosen::ScreenGroupChangeEvent event) +{ + DHLOGI("On Screen change, screenIds size: %" PRId32, screenIds.size()); + for (uint64_t screenId : screenIds) { + std::shared_ptr changedScreen = DScreenManager::GetInstance().FindDScreenById(screenId); + if (changedScreen == nullptr) { + DHLOGD("screen change not about remote screen, screenId: %u", screenId); + continue; + } + DScreenManager::GetInstance().HandleScreenChange(changedScreen, event); + } +} + +void DScreenManager::HandleScreenChange(const std::shared_ptr &changedScreen, + Rosen::ScreenGroupChangeEvent event) +{ + if (changedScreen == nullptr) { + DHLOGE("DScreenManager::HandleScreenChange, dScreen is null."); + return; + } + DHLOGI("DScreenManager::HandleScreenChange, screenId: %u, changeEvent: %", changedScreen->GetScreenId(), event); + if (event == Rosen::ScreenGroupChangeEvent::ADD_TO_GROUP) { + if (StartDScreenMirror(changedScreen) != DH_SUCCESS) { + DHLOGE("start dScreen mirror failed."); + return; + } + PublishMessage(DHTopic::TOPIC_START_DSCREEN, changedScreen); + } else if (event == Rosen::ScreenGroupChangeEvent::REMOVE_FROM_GROUP) { + if (StopDScreenMirror(changedScreen) != DH_SUCCESS) { + DHLOGE("stop dScreen mirror failed."); + } + PublishMessage(DHTopic::TOPIC_STOP_DSCREEN, changedScreen); + } else if (event == Rosen::ScreenGroupChangeEvent::CHANGE_GROUP) { + DHLOGE("CHANGE_GROUP not implement."); + } else { + DHLOGE("unknown change type."); + } +} + +int32_t DScreenManager::StartDScreenMirror(const std::shared_ptr &dScreen) +{ + if (dScreen == nullptr) { + DHLOGE("DScreenManager::StartDScreenMirror, dScreen is null."); + return ERR_DH_SCREEN_SA_VALUE_NOT_INIT; + } + uint64_t screenId = dScreen->GetScreenId(); + DHLOGI("DScreenManager::StartDScreenMirror, screenId: %u", screenId); + if (dScreen->GetState() == CONNECTING) { + DHLOGD("screen is connecting, no need handle change"); + return DH_SUCCESS; + } + int32_t ret = dScreen->InitSenderEngine(providerPtr_, dScreen->GetDevId()); + if (ret != DH_SUCCESS) { + DHLOGE("init av transport sender engine failed."); + return ret; + } + dScreen->AddTask(std::make_shared(TaskType::TASK_CONNECT, "")); + DHLOGI("StartDScreenMirror success, screenId:%u, peerDeviceId:%s", screenId, + GetAnonyString(dScreen->GetDevId()).c_str()); + return DH_SUCCESS; +} + +int32_t DScreenManager::StopDScreenMirror(const std::shared_ptr &dScreen) +{ + if (dScreen == nullptr) { + DHLOGE("DScreenManager::StopDScreenMirror, dScreen is null."); + return ERR_DH_SCREEN_SA_VALUE_NOT_INIT; + } + DHLOGI("DScreenManager::StopDScreenMirror, screenId: %u", dScreen->GetScreenId()); + if (dScreen->GetState() == DISCONNECTING) { + DHLOGD("screen is disconnecting, no need handle change"); + return DH_SUCCESS; + } + dScreen->AddTask(std::make_shared(TaskType::TASK_DISCONNECT, "")); + return DH_SUCCESS; +} + +void DScreenCallback::OnRegResult(const std::shared_ptr &dScreen, + const std::string &reqId, const int32_t status, const std::string &data) +{ + if (dScreen == nullptr) { + DHLOGE("DScreenCallback::OnRegResult, dScreen id nullptr"); + return; + } + DHLOGI("DScreenCallback::OnRegResult, devId: %s, dhId: %s, reqId: %s", + GetAnonyString(dScreen->GetDevId()).c_str(), GetAnonyString(dScreen->GetDHId()).c_str(), reqId.c_str()); + DScreenManager::GetInstance().OnRegResult(dScreen, reqId, status, data); +} + +void DScreenCallback::OnUnregResult(const std::shared_ptr &dScreen, + const std::string &reqId, const int32_t status, const std::string &data) +{ + if (dScreen == nullptr) { + DHLOGE("DScreenCallback::OnUnregResult, dScreen id nullptr"); + return; + } + DHLOGI("DScreenCallback::OnUnregResult, devId: %s, dhId: %s, reqId: %s", + GetAnonyString(dScreen->GetDevId()).c_str(), GetAnonyString(dScreen->GetDHId()).c_str(), reqId.c_str()); + DScreenManager::GetInstance().OnUnregResult(dScreen, reqId, status, data); +} + +void DScreenManager::OnRegResult(const std::shared_ptr &dScreen, + const std::string &reqId, const int32_t status, const std::string &data) +{ + DHLOGI("DScreenManager::OnRegResult, devId: %s, dhId: %s, reqId: %s", + GetAnonyString(dScreen->GetDevId()).c_str(), GetAnonyString(dScreen->GetDHId()).c_str(), reqId.c_str()); + if (dScreenSourceCallbackProxy_ == nullptr) { + DHLOGE("dScreenSourceCallbackProxy is null"); + return; + } + dScreenSourceCallbackProxy_->OnNotifyRegResult(dScreen->GetDevId(), dScreen->GetDHId(), reqId, status, data); +} + +void DScreenManager::OnUnregResult(const std::shared_ptr &dScreen, + const std::string &reqId, const int32_t status, const std::string &data) +{ + DHLOGI("DScreenManager::OnUnregResult, devId: %s, dhId: %s, reqId: %s", + GetAnonyString(dScreen->GetDevId()).c_str(), GetAnonyString(dScreen->GetDHId()).c_str(), reqId.c_str()); + if (dScreenSourceCallbackProxy_ == nullptr) { + DHLOGE("dScreenSourceCallbackProxy is null"); + return; + } + dScreenSourceCallbackProxy_->OnNotifyUnregResult(dScreen->GetDevId(), dScreen->GetDHId(), reqId, status, data); +} + +int32_t DScreenManager::EnableDistributedScreen(const std::string &devId, const std::string &dhId, + const std::string &attrs, const std::string &reqId) +{ + DHLOGI("EnableDistributedScreen3.0, devId: %s, dhId:%s", GetAnonyString(devId).c_str(), + GetAnonyString(dhId).c_str()); + if (dScreenCallback_ == nullptr) { + DHLOGE("dscreen manager not init."); + return ERR_DH_SCREEN_SA_ENABLE_FAILED; + } + std::string dScreenIdx = devId + SEPERATOR + dhId; + std::lock_guard lock(dScreenMapMtx_); + std::shared_ptr dScreen = dScreens_[dScreenIdx]; + if (dScreen == nullptr) { + dScreen = std::make_shared(devId, dhId, dScreenCallback_); + } + int32_t dScreenState = dScreen->GetState(); + if (dScreenState == ENABLED || dScreenState == ENABLING) { + DHLOGI("dScreen state Already is ENABLED or ENABLING."); + return DH_SUCCESS; + } + dScreens_[dScreenIdx] = dScreen; + int32_t ret = dScreen->AddTask(std::make_shared(TaskType::TASK_ENABLE, reqId, attrs)); + if (ret != DH_SUCCESS) { + DHLOGE("EnableDistributedScreen, add task failed. devId: %s, dhId:%s", + GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str()); + } + return ret; +} + +int32_t DScreenManager::DisableDistributedScreen(const std::string &devId, const std::string &dhId, + const std::string &reqId) +{ + DHLOGI("DisableDistributedScreen, devId: %s, dhId:%s", GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str()); + std::string dScreenIdx = devId + SEPERATOR + dhId; + std::lock_guard lock(dScreenMapMtx_); + if (dScreens_.count(dScreenIdx) == 0) { + DHLOGE("dscreen not found, devId: %s, dhId: %s", + GetAnonyString(devId).c_str(), GetAnonyString(dhId).c_str()); + return ERR_DH_SCREEN_SA_DISABLE_FAILED; + } + int32_t dScreenState = dScreens_[dScreenIdx]->GetState(); + int32_t ret = DH_SUCCESS; + switch (dScreenState) { + case DISABLED: + case DISABLING: + DHLOGE("dScreen state is invalid."); + ret = ERR_DH_SCREEN_SA_DISABLE_FAILED; + break; + case ENABLED: + case ENABLING: + ret = dScreens_[dScreenIdx]->AddTask(std::make_shared(TaskType::TASK_DISABLE, reqId, "")); + break; + case CONNECTING: + case CONNECTED: + case DISCONNECTING: + ret = dScreens_[dScreenIdx]->AddTask(std::make_shared(TaskType::TASK_DISCONNECT, "")); + if (ret == DH_SUCCESS) { + ret = dScreens_[dScreenIdx]->AddTask(std::make_shared(TaskType::TASK_DISABLE, reqId, "")); + } + break; + default: + ret = ERR_DH_SCREEN_SA_DISABLE_FAILED; + break; + } + return ret; +} + +void DScreenManager::RegisterDScreenCallback(const sptr &callback) +{ + DHLOGI("RegisterDScreenCallback"); + dScreenSourceCallbackProxy_ = callback; +} + +std::shared_ptr DScreenManager::FindDScreenById(uint64_t screenId) +{ + DHLOGD("FindDScreenById, screenId: %u", screenId); + std::lock_guard lock(dScreenMapMtx_); + for (const auto &iter : dScreens_) { + std::shared_ptr dScreen = iter.second; + if (dScreen == nullptr) { + continue; + } + if (dScreen->GetScreenId() == screenId) { + return dScreen; + } + } + DHLOGD("DScreen not found, screenId: %u", screenId); + return nullptr; +} + +void DScreenManager::GetScreenDumpInfo(std::string &result) +{ + DHLOGI("GetScreenDumpInfo."); + result.clear(); + result.append("RemoteScreens OnLine:\n[\n"); + std::lock_guard lock(dScreenMapMtx_); + if (dScreens_.size() == 0) { + result.append("]"); + DHLOGD("no virtualscreen"); + return; + } + for (const auto &iter : dScreens_) { + result.append(" {\n"); + std::shared_ptr dScreen = iter.second; + if (dScreen == nullptr) { + continue; + } + uint64_t screenId = dScreen->GetScreenId(); + std::string devId = dScreen->GetDevId(); + std::shared_ptr videoParam = dScreen->GetVideoParam(); + if (videoParam == nullptr) { + continue; + } + uint32_t screenHeight = videoParam->GetScreenHeight(); + uint32_t screenWidth = videoParam->GetScreenWidth(); + DScreenState state = dScreen->GetState(); + std::string screenState = + stateMap.find(state) == stateMap.end() ? "unknown state" : stateMap.find(state)->second; + std::string screenInfo = " \"virtualScreenId\" : \"" + std::to_string(screenId) + "\",\n" + + " \"localDevId\" : \"" + GetAnonyString(localDevId_) + "\",\n" + + " \"remoteDevId\" : \"" + GetAnonyString(devId) + "\",\n" + + " \"screenWidth\" : \"" + std::to_string(screenWidth) + "\",\n" + + " \"screenHeight\" : \"" + std::to_string(screenHeight) + "\",\n" + + " \"state\" : \"" + screenState + "\"\n"; + result.append(screenInfo); + } + result.append(" }\n]"); +} + +void DScreenManager::PublishMessage(const DHTopic topic, const std::shared_ptr &dScreen) +{ + DHLOGD("PublishMessage"); + if (DScreenFwkKit::GetInstance().GetDHFwkKit() == nullptr) { + DHLOGE("GetDHFwkKit fail."); + return; + } + json messageJosn; + std::string message; + if (topic == DHTopic::TOPIC_START_DSCREEN) { + messageJosn[SOURCE_WIN_ID] = dScreen->GetScreenId(); + messageJosn[SINK_DEV_ID] = dScreen->GetDevId(); + std::shared_ptr videoParam = dScreen->GetVideoParam(); + if (videoParam == nullptr) { + DHLOGE("videoParam is nullptr"); + return; + } + messageJosn[SOURCE_WIN_WIDTH] = videoParam->GetScreenWidth(); + messageJosn[SOURCE_WIN_HEIGHT] = videoParam->GetScreenHeight(); + message = messageJosn.dump(); + } else if (topic == DHTopic::TOPIC_STOP_DSCREEN) { + messageJosn[SOURCE_WIN_ID] = dScreen->GetScreenId(); + messageJosn[SINK_DEV_ID] = dScreen->GetDevId(); + message = messageJosn.dump(); + } + DScreenFwkKit::GetInstance().GetDHFwkKit()->PublishMessage(topic, message); +} + +int32_t DScreenManager::LoadAVSenderEngineProvider() +{ + DHLOGI("LoadAVSenderEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + SENDER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + SENDER_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 DScreenManager::UnloadAVSenderEngineProvider() +{ + DHLOGI("UnloadAVSenderEngineProvider enter"); + char path[PATH_MAX + 1] = {0x00}; + if ((LIB_LOAD_PATH.length() + SENDER_SO_NAME.length()) > PATH_MAX || + realpath((LIB_LOAD_PATH + SENDER_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; +} +} // namespace V2_0 +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/screenservice/sourceservice/dscreenmgr/include/screen_manager_adapter.h b/services/screenservice/sourceservice/dscreenmgr/common/include/screen_manager_adapter.h similarity index 100% rename from services/screenservice/sourceservice/dscreenmgr/include/screen_manager_adapter.h rename to services/screenservice/sourceservice/dscreenmgr/common/include/screen_manager_adapter.h diff --git a/services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp b/services/screenservice/sourceservice/dscreenmgr/common/src/screen_manager_adapter.cpp similarity index 92% rename from services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp rename to services/screenservice/sourceservice/dscreenmgr/common/src/screen_manager_adapter.cpp index cb003f185dc9cd446b0b367498277c4af60ec407..bbd51dc7ce7460b3a5da7171b0da462875dadd7a 100644 --- a/services/screenservice/sourceservice/dscreenmgr/src/screen_manager_adapter.cpp +++ b/services/screenservice/sourceservice/dscreenmgr/common/src/screen_manager_adapter.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "screen_manager_adapter.h" +#include "common/include/screen_manager_adapter.h" #include @@ -52,7 +52,7 @@ uint64_t ScreenMgrAdapter::CreateVirtualScreen(const std::string &devId, const s DHLOGI("remove an exist virtual screen."); Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(iter->second); if (err != Rosen::DMError::DM_OK) { - DHLOGE("remove virtual screen failed, screenId:%ulld", iter->second); + DHLOGE("remove virtual screen failed, screenId:%u", iter->second); return SCREEN_ID_INVALID; } screenIdMap_.erase(screenName); @@ -116,7 +116,7 @@ int32_t ScreenMgrAdapter::UnregisterScreenGroupListener(sptr screenIds; screenIds.push_back(screenId); Rosen::ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(screenIds); @@ -124,10 +124,10 @@ void ScreenMgrAdapter::RemoveScreenFromGroup(uint64_t screenId) int32_t ScreenMgrAdapter::RemoveVirtualScreen(uint64_t screenId) { - DHLOGI("remove virtual screen, screenId: %ulld", screenId); + DHLOGI("remove virtual screen, screenId: %u", screenId); Rosen::DMError err = Rosen::ScreenManager::GetInstance().DestroyVirtualScreen(screenId); if (err != Rosen::DMError::DM_OK) { - DHLOGE("remove virtual screen failed, screenId:%ulld", screenId); + DHLOGE("remove virtual screen failed, screenId:%u", screenId); return ERR_DH_SCREEN_SA_REMOVE_VIRTUALSCREEN_FAIL; } return DH_SUCCESS; @@ -139,14 +139,14 @@ int32_t ScreenMgrAdapter::SetImageSurface(uint64_t screenId, sptr DHLOGE("ScreenMgrAdapter::SetImageSurface, surface is nullptr"); return ERR_DH_SCREEN_SA_SET_IMAGESURFACE_FAIL; } - DHLOGI("SetImageSurface for virtualscreen, screenId: %ulld", screenId); + DHLOGI("SetImageSurface for virtualscreen, screenId: %u", screenId); Rosen::ScreenManager::GetInstance().SetVirtualScreenSurface(screenId, surface); return DH_SUCCESS; } std::shared_ptr ScreenMgrAdapter::GetMapRelation(uint64_t screenId) { - DHLOGI("GetMapRelation screenId: %ulld", screenId); + DHLOGI("GetMapRelation screenId: %u", screenId); std::shared_ptr mapRelation = std::make_shared(); sptr screen = Rosen::ScreenManager::GetInstance().GetScreenById(screenId); if (screen == nullptr) { diff --git a/services/screenservice/sourceservice/dscreenservice/include/dscreen_source_service.h b/services/screenservice/sourceservice/dscreenservice/include/dscreen_source_service.h index 7e0cd7472bb688af9b055d70d55e40aadd29a360..2e60efff6463adc153b96106d5391754e7d09ad5 100644 --- a/services/screenservice/sourceservice/dscreenservice/include/dscreen_source_service.h +++ b/services/screenservice/sourceservice/dscreenservice/include/dscreen_source_service.h @@ -19,7 +19,8 @@ #include "system_ability.h" #include "ipc_object_stub.h" -#include "dscreen_manager.h" +#include "1.0/include/dscreen_manager.h" + #include "dscreen_source_stub.h" #include "idscreen_source_callback.h" @@ -48,6 +49,7 @@ protected: DISALLOW_COPY_AND_MOVE(DScreenSourceService); private: + std::string version_ = "2.0"; bool Init(); bool registerToService_ = false; diff --git a/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp b/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp index 89d4d6376396e1037aedac1f6cb978a85260daaf..a307390d56e27227f566e96968ecd6ad77b3ff34 100644 --- a/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp +++ b/services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp @@ -46,9 +46,9 @@ void DScreenSourceService::OnStart() void DScreenSourceService::OnStop() { DHLOGI("dscreen source service stop."); - int32_t ret = DScreenManager::GetInstance().UnInit(); + int32_t ret = V1_0::DScreenManager::GetInstance().UnInit(); if (ret != DH_SUCCESS) { - DHLOGE("UnInit DScreenManager failed. err: %" PRId32, ret); + DHLOGE("UnInit V1_0::DScreenManager failed. err: %" PRId32, ret); } registerToService_ = false; } @@ -75,22 +75,22 @@ int32_t DScreenSourceService::InitSource(const std::string ¶ms, const sptr& args) @@ -161,7 +161,7 @@ int32_t DScreenSourceService::Dump(int32_t fd, const std::vector DHLOGI("DScreenSourceService Dump."); (void)args; std::string result; - DScreenManager::GetInstance().GetScreenDumpInfo(result); + V1_0::DScreenManager::GetInstance().GetScreenDumpInfo(result); int ret = dprintf(fd, "%s\n", result.c_str()); if (ret < 0) { DHLOGE("dprintf error"); diff --git a/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/BUILD.gn b/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/BUILD.gn index 301cb5083bfa2c9f47f8594e8931a72484b3448f..a178c78166809c44b04a93580d31e1d659f0b5af 100644 --- a/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/BUILD.gn +++ b/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/BUILD.gn @@ -36,7 +36,7 @@ ohos_fuzztest("OnChangeFuzzTest") { "${interfaces_path}/innerkits/native_cpp/screen_source/include", "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", "${services_path}/common/utils/include", - "${services_path}/screenservice/sourceservice/dscreenmgr/include", + "${services_path}/screenservice/sourceservice/dscreenmgr/", "${services_path}/screentransport/screensourcetrans/include", ] diff --git a/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/onchange_fuzzer.cpp b/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/onchange_fuzzer.cpp index 5204c47aa16a6d209f20f8e25d366ec6ce245987..e415b6e7a566b95a6129262729499fa4ef92b01c 100644 --- a/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/onchange_fuzzer.cpp +++ b/services/screenservice/test/fuzztest/sourceservice/dscreenmgr/onchange_fuzzer/onchange_fuzzer.cpp @@ -18,10 +18,11 @@ #include #include -#include "dscreen_manager.h" +#include "1.0/include/dscreen_manager.h" namespace OHOS { namespace DistributedHardware { +namespace V1_0 { void OnChangeFuzzTest(const uint8_t* data, size_t size) { if ((data == nullptr) || (size < sizeof(uint64_t))) { @@ -36,12 +37,13 @@ void OnChangeFuzzTest(const uint8_t* data, size_t size) } } } +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::DistributedHardware::OnChangeFuzzTest(data, size); + OHOS::DistributedHardware::V1_0::OnChangeFuzzTest(data, size); return 0; } diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn b/services/screenservice/test/unittest/sinkservice/screenregionmgr/BUILD.gn index 2c2547121c5c883974e18f23342154af559a0da1..8c5a3bd32c4a6f8261e6790d63f06011aaa9baa5 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/1.0/include", + "${services_path}/screenservice/sinkservice/screenregionmgr/", ] } 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 5efc80f1bd4c1c0ada0cf283729dbddfa09d40de..191f6e5b76ef00ffb9dc42a186077b7684a838d0 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregion_test.h +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregion_test.h @@ -22,7 +22,7 @@ #define private public #include "dscreen_errcode.h" #include "screen_sink_trans.h" -#include "screenregion.h" +#include "1.0/include/screenregion.h" #undef private namespace OHOS { 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 a365a2bc7a8ab57cf7319cd282e491d9a683a876..8752f79c9d550c951bcdf827faf8433e8e7e1b72 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregionmgr_test.h +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screenregionmgr_test.h @@ -21,7 +21,7 @@ #define private public #include "dscreen_errcode.h" -#include "screenregionmgr.h" +#include "1.0/include/screenregionmgr.h" #undef private namespace OHOS { diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn b/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn index db1501d0c445fc1fb523bdbb4facdbd5fa97f846..6fe62d70444d1edf78df3dae196587558922a3b3 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/BUILD.gn @@ -42,7 +42,7 @@ config("module_private_config") { "${services_path}/common/imageJpeg/include", "${services_path}/common/screen_channel/include", "${services_path}/common/utils/include", - "${services_path}/screenservice/sourceservice/dscreenmgr/include", + "${services_path}/screenservice/sourceservice/dscreenmgr/", "${services_path}/screentransport/screensourceprocessor/encoder/include", "${services_path}/screentransport/screensourceprocessor/include", "${services_path}/screentransport/screensourcetrans/include", diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h index 194016806d9bcf6c0d161c2b02489073ceac014d..ecec03a5f472ab7704e95fd906ea63ff06ef5a3e 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h @@ -13,19 +13,20 @@ * limitations under the License. */ -#ifndef OHOS_DSCREEN_MANAGER_TEST_H -#define OHOS_DSCREEN_MANAGER_TEST_H +#ifndef OHOS_DSCREEN_MANAGER_TEST_V1_0_H +#define OHOS_DSCREEN_MANAGER_TEST_V1_0_H #include #include #define private public #include "dscreen_errcode.h" -#include "dscreen_manager.h" +#include "1.0/include/dscreen_manager.h" #undef private namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class DScreenManagerTest : 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/sourceservice/dscreenmgr/include/dscreen_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h index 11d3870715e8c48a66d7ad285bab58ee600c166a..528f816f89e2de89fc1c862a9c71bd5e17181243 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h @@ -13,17 +13,18 @@ * limitations under the License. */ -#ifndef OHOS_DSCREEN_TEST_H -#define OHOS_DSCREEN_TEST_H +#ifndef OHOS_DSCREEN_TEST_V1_0_H +#define OHOS_DSCREEN_TEST_V1_0_H #include #include #define private public -#include "dscreen.h" +#include "1.0/include/dscreen.h" #undef private namespace OHOS { namespace DistributedHardware { +namespace V1_0 { class DScreenTest : public testing::Test { public: static void SetUpTestCase(void); @@ -32,6 +33,7 @@ public: void TearDown(); std::shared_ptr dScreen_ = nullptr; }; +} // namespace V1_0 } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp index bb8b34e4f5666780fd486e182ce50078287e08dc..e47872e7aba445d96da44a9b21665cc72f792f51 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp @@ -20,6 +20,7 @@ using namespace testing::ext; namespace OHOS { namespace DistributedHardware { +namespace V1_0 { void DScreenManagerTest::SetUpTestCase(void) {} void DScreenManagerTest::TearDownTestCase(void) {} @@ -332,4 +333,5 @@ HWTEST_F(DScreenManagerTest, DisableDistributedScreen_001, TestSize.Level1) EXPECT_EQ(DH_SUCCESS, ret); } } +} } \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp index 04d0b554e37a872958d8b4fd8e9627ecc96bab3b..9c776eb84e0ff2d7ed5753410f5cfaf3481b1629 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp @@ -18,8 +18,8 @@ #define private public #include "dscreen_constants.h" #include "dscreen_errcode.h" -#include "dscreen_manager.h" -#include "screen_manager_adapter.h" +#include "1.0/include/dscreen_manager.h" +#include "common/include/screen_manager_adapter.h" #include "dscreen_util.h" #include "video_param.h" #include "screen_source_trans.h" @@ -30,6 +30,7 @@ using namespace testing::ext; namespace OHOS { namespace DistributedHardware { +namespace V1_0 { constexpr static int32_t videoDataNum = 100; void DScreenTest::SetUpTestCase(void) {} @@ -406,4 +407,5 @@ HWTEST_F(DScreenTest, Stop_002, TestSize.Level1) EXPECT_EQ(ERR_DH_SCREEN_TRANS_NULL_VALUE, ret); } } +} } \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp index ce3ccdaf208e38af08f971a7e12652977c90d88d..2797e1eed0db40e9cade9e3313f2a32436b5e03a 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp @@ -16,7 +16,7 @@ #include "screen_manager_adapter_test.h" #define private public -#include "screen_manager_adapter.h" +#include "common/include/screen_manager_adapter.h" #undef private #include "dscreen_constants.h" #include "dscreen_errcode.h" diff --git a/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp b/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp index 9b380a39b248df134ae107f21605a2fb9274d56b..0c1900fefcd0021f751aaa5ffb76724c6d9cfc12 100644 --- a/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp +++ b/services/screentransport/screensinkprocessor/decoder/src/image_sink_decoder.cpp @@ -101,8 +101,8 @@ sptr ImageSinkDecoder::GetWinSurfaceBuffer() .width = configParam_.GetVideoWidth(), .height = configParam_.GetVideoHeight(), .strideAlignment = STRIDE_ALIGNMENT, - .format = PIXEL_FMT_YCBCR_420_SP, - .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA, + .format = GRAPHIC_PIXEL_FMT_YCBCR_420_SP, + .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, }; SurfaceError surfaceErr = windowSurface_->RequestBuffer(windowSurfaceBuffer, releaseFence, requestConfig); if (surfaceErr != SURFACE_ERROR_OK || windowSurfaceBuffer == nullptr) { diff --git a/services/screentransport/screensourceprocessor/encoder/src/image_source_encoder.cpp b/services/screentransport/screensourceprocessor/encoder/src/image_source_encoder.cpp index d5318e91065ccd7f310196d558d86097bf3785e5..760763df6f5572190edc2d2a3abe0aba57af7a6a 100644 --- a/services/screentransport/screensourceprocessor/encoder/src/image_source_encoder.cpp +++ b/services/screentransport/screensourceprocessor/encoder/src/image_source_encoder.cpp @@ -200,9 +200,9 @@ sptr ImageSourceEncoder::GetEncoderInputSurfaceBuffer() OHOS::BufferRequestConfig requestConfig; requestConfig.width = configParam_.GetVideoWidth(); requestConfig.height = configParam_.GetVideoHeight(); - requestConfig.usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA; + requestConfig.usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA; requestConfig.strideAlignment = STRIDE_ALIGNMENT; - requestConfig.format = PixelFormat::PIXEL_FMT_RGBA_8888; + requestConfig.format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888; requestConfig.timeout = 0; sptr encoderSurfaceBuffer = nullptr; int32_t releaseFence = -1;