From 69bc53cd7817dba67bdb7253bab9473c15805480 Mon Sep 17 00:00:00 2001 From: lu Date: Tue, 11 Jan 2022 16:27:33 +0800 Subject: [PATCH] Add interface for 'Screen' Signed-off-by: lu Change-Id: Ifae6fde45bfc57ffd18b0db42624ed113a20c409 --- dm/src/screen.cpp | 83 ++++++++++++ .../src/screen.cpp => dm/src/screen_group.cpp | 38 +++++- dm/src/screen_manager.cpp | 65 +++++++++ ...anager.h => abstract_display_controller.h} | 14 +- dmserver/include/abstract_screen.h | 55 ++++++++ dmserver/include/abstract_screen_controller.h | 65 +++++++++ dmserver/include/display_manager_service.h | 5 +- ...er.cpp => abstract_display_controller.cpp} | 24 ++-- .../src/abstract_screen.cpp | 18 ++- dmserver/src/abstract_screen_controller.cpp | 125 ++++++++++++++++++ dmserver/src/display_manager_service.cpp | 10 +- .../src/display_manager_service_inner.cpp | 2 +- .../innerkits/dm/{monitor.h => screen.h} | 45 ++++++- .../innerkits/dm/screen_group.h | 28 +++- interfaces/innerkits/dm/screen_manager.h | 50 +++++++ wm/BUILD.gn | 2 +- wmserver/BUILD.gn | 5 +- 17 files changed, 595 insertions(+), 39 deletions(-) create mode 100644 dm/src/screen.cpp rename dmserver/src/screen.cpp => dm/src/screen_group.cpp (48%) create mode 100644 dm/src/screen_manager.cpp rename dmserver/include/{abstract_display_manager.h => abstract_display_controller.h} (77%) create mode 100644 dmserver/include/abstract_screen.h create mode 100644 dmserver/include/abstract_screen_controller.h rename dmserver/src/{abstract_display_manager.cpp => abstract_display_controller.cpp} (66%) rename dm/src/monitor.cpp => dmserver/src/abstract_screen.cpp (64%) create mode 100644 dmserver/src/abstract_screen_controller.cpp rename interfaces/innerkits/dm/{monitor.h => screen.h} (42%) rename dmserver/include/screen.h => interfaces/innerkits/dm/screen_group.h (55%) create mode 100644 interfaces/innerkits/dm/screen_manager.h diff --git a/dm/src/screen.cpp b/dm/src/screen.cpp new file mode 100644 index 0000000000..e881f81ddc --- /dev/null +++ b/dm/src/screen.cpp @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2021 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 "screen.h" + +namespace OHOS::Rosen { +class Screen::Impl : public RefBase { +friend class Screen; +public: + Impl() = default; + ~Impl() = default; + + ScreenId id_ { SCREEN_ID_INVALD }; + uint32_t width_ { 0 }; + uint32_t height_ { 0 }; + uint32_t virtualWidth_ { 0 }; + uint32_t virtualHeight_ { 0 }; + float virtualPixelRatio_ { 0.0 }; + sptr parent_ { nullptr }; + bool hasChild_ { false }; +}; + +Screen::Screen() +{ + pImpl_ = new Impl(); +} + +Screen::~Screen() +{ +} + +bool Screen::IsGroup() const +{ + return pImpl_->hasChild_; +} + +ScreenId Screen::GetId() const +{ + return pImpl_->id_; +} + +uint32_t Screen::GetWidth() const +{ + return pImpl_->width_; +} + +uint32_t Screen::GetHeight() const +{ + return pImpl_->height_; +} + +uint32_t Screen::GetVirtualWidth() const +{ + return pImpl_->virtualWidth_; +} + +uint32_t Screen::GetVirtualHeight() const +{ + return pImpl_->virtualHeight_; +} + +float Screen::GetVirtualPixelRatio() const +{ + return pImpl_->virtualPixelRatio_; +} + +sptr Screen::GetParent() const +{ + return pImpl_->parent_; +} +} // namespace OHOS::Rosen \ No newline at end of file diff --git a/dmserver/src/screen.cpp b/dm/src/screen_group.cpp similarity index 48% rename from dmserver/src/screen.cpp rename to dm/src/screen_group.cpp index 11c222d130..e127d4c2bd 100644 --- a/dmserver/src/screen.cpp +++ b/dm/src/screen_group.cpp @@ -13,7 +13,43 @@ * limitations under the License. */ -#include "screen.h" +#include "screen_group.h" + +#include "wm_common.h" namespace OHOS::Rosen { +class ScreenGroup::Impl : public RefBase { +friend class ScreenGroup; +private: + Impl() = default; + ~Impl() = default; + + std::vector> children_; + std::vector position_; + ScreenType type_ { ScreenType::SCREEN_ALONE }; +}; + +ScreenGroup::ScreenGroup() +{ + pImpl_ = new Impl(); +} + +ScreenGroup::~ScreenGroup() +{ +} + +ScreenType ScreenGroup::GetType() const +{ + return pImpl_->type_; +} + +std::vector> ScreenGroup::GetChildren() const +{ + return pImpl_->children_; +} + +std::vector ScreenGroup::GetChildrenPosition() const +{ + return pImpl_->position_; +} } // namespace OHOS::Rosen \ No newline at end of file diff --git a/dm/src/screen_manager.cpp b/dm/src/screen_manager.cpp new file mode 100644 index 0000000000..9278df3f0b --- /dev/null +++ b/dm/src/screen_manager.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 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 "screen_manager.h" + +#include +#include + +namespace OHOS::Rosen { +class ScreenManager::Impl : public RefBase { +friend class ScreenManager; +private: + Impl() = default; + ~Impl() = default; + + std::map> monitorMap_; +}; + +ScreenManager::ScreenManager() +{ + pImpl_ = new Impl(); +} + +ScreenManager::~ScreenManager() +{ +} + +sptr ScreenManager::GetScreenById(ScreenId id) +{ + return nullptr; +} + +std::vector> ScreenManager::GetAllScreens() +{ + std::vector> res; + return res; +} + +sptr ScreenManager::makeExpand(std::vector screenId, std::vector startPoint) +{ + return nullptr; +} + +sptr ScreenManager::makeMirror(ScreenId mainScreenId, std::vector mirrorScreenId) +{ + return nullptr; +} + +sptr ScreenManager::createVirtualScreen(VirtualScreenOption option) +{ + return nullptr; +} +} // namespace OHOS::Rosen \ No newline at end of file diff --git a/dmserver/include/abstract_display_manager.h b/dmserver/include/abstract_display_controller.h similarity index 77% rename from dmserver/include/abstract_display_manager.h rename to dmserver/include/abstract_display_controller.h index d2a7852dc2..f921657660 100644 --- a/dmserver/include/abstract_display_manager.h +++ b/dmserver/include/abstract_display_controller.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef FOUNDATION_DMSERVER_ABSTRACT_DISPLAY_MANAGER_H -#define FOUNDATION_DMSERVER_ABSTRACT_DISPLAY_MANAGER_H +#ifndef FOUNDATION_DMSERVER_ABSTRACT_DISPLAY_CONTROLLER_H +#define FOUNDATION_DMSERVER_ABSTRACT_DISPLAY_CONTROLLER_H #include #include @@ -26,8 +26,8 @@ #include "virtual_display_info.h" namespace OHOS::Rosen { -class AbstractDisplayManager { -DECLARE_SINGLE_INSTANCE_BASE(AbstractDisplayManager); +class AbstractDisplayController { +DECLARE_SINGLE_INSTANCE_BASE(AbstractDisplayController); public: std::map> abstractDisplayMap_; @@ -38,11 +38,11 @@ public: sptr GetScreenSnapshot(ScreenId screenId); private: - AbstractDisplayManager(); - ~AbstractDisplayManager(); + AbstractDisplayController(); + ~AbstractDisplayController(); void parepareRSScreenManger(); OHOS::Rosen::RSInterfaces *rsInterface_; }; } // namespace OHOS::Rosen -#endif // FOUNDATION_DMSERVER_ABSTRACT_DISPLAY_MANAGER_H \ No newline at end of file +#endif // FOUNDATION_DMSERVER_ABSTRACT_DISPLAY_CONTROLLER_H \ No newline at end of file diff --git a/dmserver/include/abstract_screen.h b/dmserver/include/abstract_screen.h new file mode 100644 index 0000000000..6c3112190e --- /dev/null +++ b/dmserver/include/abstract_screen.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 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 FOUNDATION_DMSERVER_ABSTRACT_SCREEN_H +#define FOUNDATION_DMSERVER_ABSTRACT_SCREEN_H + +#include +#include + +namespace OHOS::Rosen { +struct Point { + int32_t posX_; + int32_t posY_; +}; + +enum class AbstractScreenType : uint32_t { + SCREEN_ALONE, + SCREEN_EXPAND, + SCREEN_MIRROR, +}; + +class AbstractScreen : public RefBase { +public: + AbstractScreen(ScreenId dmsId, ScreenId rsId); + AbstractScreen() = delete; + ~AbstractScreen(); + + ScreenId dmsId_; + ScreenId rsId_; +}; + +class AbstractScreenGroup : public AbstractScreen { +public: + AbstractScreenGroup(ScreenId dmsId, ScreenId rsId); + AbstractScreenGroup() = delete; + ~AbstractScreenGroup(); + + AbstractScreenType GetType() const; + std::vector> GetChildren() const; + std::vector GetChildrenPosition() const; +}; +} // namespace OHOS::Rosen +#endif // FOUNDATION_DMSERVER_ABSTRACT_SCREEN_H \ No newline at end of file diff --git a/dmserver/include/abstract_screen_controller.h b/dmserver/include/abstract_screen_controller.h new file mode 100644 index 0000000000..394dcac4fc --- /dev/null +++ b/dmserver/include/abstract_screen_controller.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 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 FOUNDATION_DMSERVER_ABSTRACT_SCREEN_CONTROLLER_H +#define FOUNDATION_DMSERVER_ABSTRACT_SCREEN_CONTROLLER_H + +#include +#include + +#include +#include +#include + +#include "abstract_screen.h" + +namespace OHOS::Rosen { +class AbstractScreenController : public RefBase { +using OnAbstractScreenCallback = std::function; +struct AbstractScreenCallback : public RefBase { + OnAbstractScreenCallback onConnected_; + OnAbstractScreenCallback onDisconnected_; + OnAbstractScreenCallback onChanged_; +}; + +public: + AbstractScreenController(std::recursive_mutex& mutex); + ~AbstractScreenController(); + + std::vector GetAllScreenIds(); + std::shared_ptr> ConvertToRsScreenId(ScreenId dmsScreenId); + std::shared_ptr> ConvertToDmsScreenId(ScreenId rsScreenId); + void RegisterAbstractScreenCallback(sptr cb); + + std::map> abstractDisplayMap_; + +private: + void PrepareRSScreenManger(); + void OnRsScreenChange(ScreenId rsScreenId, ScreenEvent screenEvent); + void AddToGroup(sptr newScreen); + void AddAsFirstScreenLocked(sptr newScreen); + void AddAsSuccedentScreenLocked(sptr newScreen); + + std::recursive_mutex& mutex_; + RSInterfaces& rsInterface_; + volatile ScreenId dmsScreenCount_; + std::map>> rs2DmsScreenIdMap_; + std::map>> dms2RsScreenIdMap_; + std::map> dmsScreenMap_; + ScreenId defaultScreenId_ {INVALID_SCREEN_ID}; + sptr abstractScreenCallback_; +}; +} // namespace OHOS::Rosen +#endif // FOUNDATION_DMSERVER_ABSTRACT_SCREEN_CONTROLLER_H \ No newline at end of file diff --git a/dmserver/include/display_manager_service.h b/dmserver/include/display_manager_service.h index 05bca80997..c8d652a946 100644 --- a/dmserver/include/display_manager_service.h +++ b/dmserver/include/display_manager_service.h @@ -23,7 +23,8 @@ #include #include "abstract_display.h" -#include "abstract_display_manager.h" +#include "abstract_display_controller.h" +#include "abstract_screen_controller.h" #include "display_manager_stub.h" #include "display_power_controller.h" #include "single_instance.h" @@ -58,8 +59,10 @@ private: DisplayId GetDisplayIdFromScreenId(ScreenId screenId); ScreenId GetScreenIdFromDisplayId(DisplayId displayId); + std::recursive_mutex mutex_; static inline SingletonDelegator delegator_; std::map> abstractDisplayMap_; + AbstractScreenController screenController_ = AbstractScreenController(mutex_); DisplayPowerController displayPowerController_; }; } // namespace OHOS::Rosen diff --git a/dmserver/src/abstract_display_manager.cpp b/dmserver/src/abstract_display_controller.cpp similarity index 66% rename from dmserver/src/abstract_display_manager.cpp rename to dmserver/src/abstract_display_controller.cpp index 2ed3b24e26..9d2762ec9c 100644 --- a/dmserver/src/abstract_display_manager.cpp +++ b/dmserver/src/abstract_display_controller.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "abstract_display_manager.h" +#include "abstract_display_controller.h" #include "window_manager_hilog.h" @@ -21,24 +21,24 @@ namespace OHOS::Rosen { namespace { - constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, 0, "AbstractDisplayManager"}; + constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, 0, "AbstractDisplayController"}; } -AbstractDisplayManager::AbstractDisplayManager() : rsInterface_(&(RSInterfaces::GetInstance())) +AbstractDisplayController::AbstractDisplayController() : rsInterface_(&(RSInterfaces::GetInstance())) { parepareRSScreenManger(); } -AbstractDisplayManager::~AbstractDisplayManager() +AbstractDisplayController::~AbstractDisplayController() { rsInterface_ = nullptr; } -void AbstractDisplayManager::parepareRSScreenManger() +void AbstractDisplayController::parepareRSScreenManger() { } -ScreenId AbstractDisplayManager::GetDefaultScreenId() +ScreenId AbstractDisplayController::GetDefaultScreenId() { if (rsInterface_ == nullptr) { return INVALID_SCREEN_ID; @@ -46,7 +46,7 @@ ScreenId AbstractDisplayManager::GetDefaultScreenId() return rsInterface_->GetDefaultScreenId(); } -RSScreenModeInfo AbstractDisplayManager::GetScreenActiveMode(ScreenId id) +RSScreenModeInfo AbstractDisplayController::GetScreenActiveMode(ScreenId id) { RSScreenModeInfo screenModeInfo; if (rsInterface_ == nullptr) { @@ -55,7 +55,7 @@ RSScreenModeInfo AbstractDisplayManager::GetScreenActiveMode(ScreenId id) return rsInterface_->GetScreenActiveMode(id); } -ScreenId AbstractDisplayManager::CreateVirtualScreen(const VirtualDisplayInfo &virtualDisplayInfo, +ScreenId AbstractDisplayController::CreateVirtualScreen(const VirtualDisplayInfo &virtualDisplayInfo, sptr surface) { if (rsInterface_ == nullptr) { @@ -63,21 +63,21 @@ ScreenId AbstractDisplayManager::CreateVirtualScreen(const VirtualDisplayInfo &v } ScreenId result = rsInterface_->CreateVirtualScreen(virtualDisplayInfo.name_, virtualDisplayInfo.width_, virtualDisplayInfo.height_, surface, virtualDisplayInfo.displayIdToMirror_, virtualDisplayInfo.flags_); - WLOGFI("AbstractDisplayManager::CreateVirtualDisplay id: %{public}llu", result >> 32); + WLOGFI("AbstractDisplayController::CreateVirtualDisplay id: %{public}llu", result); return result; } -bool AbstractDisplayManager::DestroyVirtualScreen(ScreenId screenId) +bool AbstractDisplayController::DestroyVirtualScreen(ScreenId screenId) { if (rsInterface_ == nullptr) { return false; } - WLOGFI("AbstractDisplayManager::DestroyVirtualScreen"); + WLOGFI("AbstractDisplayController::DestroyVirtualScreen"); rsInterface_->RemoveVirtualScreen(screenId); return true; } -sptr AbstractDisplayManager::GetScreenSnapshot(ScreenId screenId) +sptr AbstractDisplayController::GetScreenSnapshot(ScreenId screenId) { if (rsInterface_ == nullptr) { return nullptr; diff --git a/dm/src/monitor.cpp b/dmserver/src/abstract_screen.cpp similarity index 64% rename from dm/src/monitor.cpp rename to dmserver/src/abstract_screen.cpp index ca8933d58b..72c7b87869 100644 --- a/dm/src/monitor.cpp +++ b/dmserver/src/abstract_screen.cpp @@ -13,7 +13,23 @@ * limitations under the License. */ -#include "monitor.h" +#include "abstract_screen.h" namespace OHOS::Rosen { +AbstractScreen::AbstractScreen(ScreenId dmsId, ScreenId rsId) + : dmsId_(dmsId), rsId_(rsId) +{ +} + +AbstractScreen::~AbstractScreen() +{ +} + +AbstractScreenGroup::AbstractScreenGroup(ScreenId dmsId, ScreenId rsId) : AbstractScreen(dmsId, rsId) +{ +} + +AbstractScreenGroup::~AbstractScreenGroup() +{ +} } // namespace OHOS::Rosen \ No newline at end of file diff --git a/dmserver/src/abstract_screen_controller.cpp b/dmserver/src/abstract_screen_controller.cpp new file mode 100644 index 0000000000..7019239d36 --- /dev/null +++ b/dmserver/src/abstract_screen_controller.cpp @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2021 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 "abstract_screen_controller.h" + +#include +#include + +#include "display_manager_service.h" +#include "window_manager_hilog.h" + +namespace OHOS::Rosen { +namespace { + constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, 0, "AbstractScreenController"}; +} + +AbstractScreenController::AbstractScreenController(std::recursive_mutex& mutex) + : mutex_(mutex), rsInterface_(RSInterfaces::GetInstance()) +{ + dmsScreenCount_ = 0; + // TODO : PrepareRSScreenManger +} + +AbstractScreenController::~AbstractScreenController() +{ +} + +std::vector AbstractScreenController::GetAllScreenIds() +{ + std::vector tmp; + return tmp; +} + +std::shared_ptr> AbstractScreenController::ConvertToRsScreenId(ScreenId dmsScreenId) +{ + std::lock_guard lock(mutex_); + std::shared_ptr> empty = std::make_shared>(); + return empty; +} + +std::shared_ptr> AbstractScreenController::ConvertToDmsScreenId(ScreenId rsScreenId) +{ + std::lock_guard lock(mutex_); + std::shared_ptr> empty = std::make_shared>(); + return empty; +} + +void AbstractScreenController::RegisterAbstractScreenCallback(sptr cb) +{ + std::lock_guard lock(mutex_); + abstractScreenCallback_ = cb; +} + +void AbstractScreenController::PrepareRSScreenManger() +{ + { + std::lock_guard lock(mutex_); + defaultScreenId_ = rsInterface_.GetDefaultScreenId(); + } + rsInterface_.SetScreenChangeCallback( + std::bind(&AbstractScreenController::OnRsScreenChange, this, std::placeholders::_1, std::placeholders::_2)); +} + +void AbstractScreenController::OnRsScreenChange(ScreenId rsScreenId, ScreenEvent screenEvent) +{ + ScreenId dmsScreenId = INVALID_SCREEN_ID; + std::lock_guard lock(mutex_); + if (screenEvent == ScreenEvent::CONNECTED) { + auto iter = rs2DmsScreenIdMap_.find(rsScreenId); + if (iter == rs2DmsScreenIdMap_.end()) { + dmsScreenId = dmsScreenCount_++; + std::shared_ptr> dmsVector = std::make_shared>(); + dmsVector->push_back(dmsScreenId); + rs2DmsScreenIdMap_.insert(std::make_pair(rsScreenId, dmsVector)); + std::shared_ptr> rsVector = std::make_shared>(); + dmsVector->push_back(rsScreenId); + dms2RsScreenIdMap_.insert(std::make_pair(dmsScreenId, rsVector)); + sptr absScreen = new AbstractScreen(dmsScreenId, rsScreenId); + dmsScreenMap_.insert(std::make_pair(dmsScreenId, absScreen)); + // TODO: rsInterface_.GetScreenActiveMode() + // TODO: rsInterface_.GetScreenSupportedModes() + AddToGroup(absScreen); + } + } else if (screenEvent == ScreenEvent::DISCONNECTED) { + WLOGI("connect screen"); + } else { + WLOGE("unknow message:%{public}ud", static_cast(screenEvent)); + } +} + +void AbstractScreenController::AddToGroup(sptr newScreen) +{ + std::lock_guard lock(mutex_); + auto iter = dmsScreenMap_.find(defaultScreenId_); + if (iter == dmsScreenMap_.end()) { + WLOGE("did not find default screen screenId:%{public}llu", defaultScreenId_); + AddAsFirstScreenLocked(newScreen); + } else { + sptr defaultScreen = iter->second; + AddAsSuccedentScreenLocked(newScreen); + } +} + +void AbstractScreenController::AddAsFirstScreenLocked(sptr newScreen) +{ + // TODO: Create default display +} + +void AbstractScreenController::AddAsSuccedentScreenLocked(sptr newScreen) +{ + // TODO: Mirror to default screen +} +} // namespace OHOS::Rosen \ No newline at end of file diff --git a/dmserver/src/display_manager_service.cpp b/dmserver/src/display_manager_service.cpp index 5907c5b937..a6ff2b589d 100644 --- a/dmserver/src/display_manager_service.cpp +++ b/dmserver/src/display_manager_service.cpp @@ -67,7 +67,7 @@ ScreenId DisplayManagerService::GetScreenIdFromDisplayId(DisplayId displayId) DisplayId DisplayManagerService::GetDefaultDisplayId() { - ScreenId screenId = AbstractDisplayManager::GetInstance().GetDefaultScreenId(); + ScreenId screenId = AbstractDisplayController::GetInstance().GetDefaultScreenId(); WLOGFI("GetDefaultDisplayId %{public}llu", screenId); return GetDisplayIdFromScreenId(screenId); } @@ -76,7 +76,7 @@ DisplayInfo DisplayManagerService::GetDisplayInfoById(DisplayId displayId) { DisplayInfo displayInfo; ScreenId screenId = GetScreenIdFromDisplayId(displayId); - auto screenModeInfo = AbstractDisplayManager::GetInstance().GetScreenActiveMode(screenId); + auto screenModeInfo = AbstractDisplayController::GetInstance().GetScreenActiveMode(screenId); displayInfo.id_ = displayId; displayInfo.width_ = screenModeInfo.GetScreenWidth(); displayInfo.height_ = screenModeInfo.GetScreenHeight(); @@ -90,7 +90,7 @@ DisplayId DisplayManagerService::CreateVirtualDisplay(const VirtualDisplayInfo & WLOGFI("name %{public}s, width %{public}u, height %{public}u, mirrotId %{public}llu, flags %{public}d", virtualDisplayInfo.name_.c_str(), virtualDisplayInfo.width_, virtualDisplayInfo.height_, virtualDisplayInfo.displayIdToMirror_, virtualDisplayInfo.flags_); - ScreenId screenId = AbstractDisplayManager::GetInstance().CreateVirtualScreen(virtualDisplayInfo, surface); + ScreenId screenId = AbstractDisplayController::GetInstance().CreateVirtualScreen(virtualDisplayInfo, surface); return GetDisplayIdFromScreenId(screenId); } @@ -98,13 +98,13 @@ bool DisplayManagerService::DestroyVirtualDisplay(DisplayId displayId) { WLOGFI("DisplayManagerService::DestroyVirtualDisplay"); ScreenId screenId = GetScreenIdFromDisplayId(displayId); - return AbstractDisplayManager::GetInstance().DestroyVirtualScreen(screenId); + return AbstractDisplayController::GetInstance().DestroyVirtualScreen(screenId); } sptr DisplayManagerService::GetDispalySnapshot(DisplayId displayId) { ScreenId screenId = GetScreenIdFromDisplayId(displayId); - sptr screenSnapshot = AbstractDisplayManager::GetInstance().GetScreenSnapshot(screenId); + sptr screenSnapshot = AbstractDisplayController::GetInstance().GetScreenSnapshot(screenId); return screenSnapshot; } diff --git a/dmserver/src/display_manager_service_inner.cpp b/dmserver/src/display_manager_service_inner.cpp index 6b65413d81..b1ad4d34bf 100644 --- a/dmserver/src/display_manager_service_inner.cpp +++ b/dmserver/src/display_manager_service_inner.cpp @@ -22,7 +22,7 @@ #include #include -#include "abstract_display_manager.h" +#include "abstract_display_controller.h" #include "display_manager_service.h" #include "window_manager_hilog.h" diff --git a/interfaces/innerkits/dm/monitor.h b/interfaces/innerkits/dm/screen.h similarity index 42% rename from interfaces/innerkits/dm/monitor.h rename to interfaces/innerkits/dm/screen.h index 0cb2b16475..ae2221364c 100644 --- a/interfaces/innerkits/dm/monitor.h +++ b/interfaces/innerkits/dm/screen.h @@ -13,12 +13,49 @@ * limitations under the License. */ -#ifndef FOUNDATION_DM_MONITOR_H -#define FOUNDATION_DM_MONITOR_H +#ifndef FOUNDATION_DM_SCREEN_H +#define FOUNDATION_DM_SCREEN_H + +#include +#include + +#include namespace OHOS::Rosen { -class Monitor { +using ScreenId = uint64_t; +static constexpr ScreenId SCREEN_ID_INVALD = -1ULL; + +struct Point { + int32_t posX_; + int32_t posY_; +}; + +struct VirtualScreenOption { + const std::string& name_; + uint32_t width_; + uint32_t height_; + float density_; + sptr surface_; + int32_t flags_; +}; + +class Screen : public RefBase { +public: + Screen(); + ~Screen(); + bool IsGroup() const; + ScreenId GetId() const; + uint32_t GetWidth() const; + uint32_t GetHeight() const; + uint32_t GetVirtualWidth() const; + uint32_t GetVirtualHeight() const; + float GetVirtualPixelRatio() const; + sptr GetParent() const; + +private: + class Impl; + sptr pImpl_; }; } // namespace OHOS::Rosen -#endif // FOUNDATION_DM_MONITOR_H \ No newline at end of file +#endif // FOUNDATION_DM_SCREEN_H \ No newline at end of file diff --git a/dmserver/include/screen.h b/interfaces/innerkits/dm/screen_group.h similarity index 55% rename from dmserver/include/screen.h rename to interfaces/innerkits/dm/screen_group.h index bbe436d55b..df7346d173 100644 --- a/dmserver/include/screen.h +++ b/interfaces/innerkits/dm/screen_group.h @@ -13,13 +13,33 @@ * limitations under the License. */ -#ifndef FOUNDATION_DMSERVER_SCREEN_H -#define FOUNDATION_DMSERVER_SCREEN_H +#ifndef FOUNDATION_DM_SCREEN_GROUP_H +#define FOUNDATION_DM_SCREEN_GROUP_H #include +#include +#include "screen.h" namespace OHOS::Rosen { -class Screen : public RefBase { +enum class ScreenType : uint32_t { + SCREEN_ALONE, + SCREEN_EXPAND, + SCREEN_MIRROR, +}; + +class ScreenGroup : public Screen { +public: + ScreenType GetType() const; + std::vector> GetChildren() const; + std::vector GetChildrenPosition() const; + +private: + ScreenGroup(); + ~ScreenGroup(); + + class Impl; + sptr pImpl_; }; } // namespace OHOS::Rosen -#endif // FOUNDATION_DMSERVER_SCREEN_H \ No newline at end of file + +#endif // FOUNDATION_DM_SCREEN_GROUP_H \ No newline at end of file diff --git a/interfaces/innerkits/dm/screen_manager.h b/interfaces/innerkits/dm/screen_manager.h new file mode 100644 index 0000000000..e6302b5d3a --- /dev/null +++ b/interfaces/innerkits/dm/screen_manager.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2021 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 FOUNDATION_DM_SCREEN_MANAGER_H +#define FOUNDATION_DM_SCREEN_MANAGER_H + +#include +#include "screen.h" +#include "screen_group.h" +#include "single_instance.h" + +namespace OHOS::Rosen { +class IScreenChangeListener : public RefBase { +public: + virtual void OnCreate(ScreenId) = 0; + virtual void OnDestroy(ScreenId) = 0; + virtual void OnChange(std::vector) = 0; +}; + +class ScreenManager : public RefBase { +DECLARE_SINGLE_INSTANCE_BASE(ScreenManager); +public: + sptr GetScreenById(ScreenId id); + std::vector> GetAllScreens(); + sptr makeExpand(std::vector screenId, std::vector startPoint); + sptr makeMirror(ScreenId mainScreenId, std::vector mirrorScreenId); + sptr createVirtualScreen(VirtualScreenOption option); + +private: + ScreenManager(); + ~ScreenManager(); + + class Impl; + sptr pImpl_; +}; +} // namespace OHOS::Rosen + +#endif // FOUNDATION_DM_SCREEN_MANAGER_H \ No newline at end of file diff --git a/wm/BUILD.gn b/wm/BUILD.gn index fa58a7a367..ea06f26e4c 100644 --- a/wm/BUILD.gn +++ b/wm/BUILD.gn @@ -105,7 +105,7 @@ ohos_shared_library("libwm") { "../dm/src/display.cpp", "../dm/src/display_manager.cpp", "../dm/src/display_manager_adapter.cpp", - "../dm/src/monitor.cpp", + "../dm/src/screen.cpp", "../utils/src/static_call.cpp", "src/input_transfer_station.cpp", "src/vsync_station.cpp", diff --git a/wmserver/BUILD.gn b/wmserver/BUILD.gn index 86ce6f97ca..bc675b2b31 100644 --- a/wmserver/BUILD.gn +++ b/wmserver/BUILD.gn @@ -32,13 +32,14 @@ config("libwms_config") { ohos_shared_library("libwms") { sources = [ "../dmserver/src/abstract_display.cpp", - "../dmserver/src/abstract_display_manager.cpp", + "../dmserver/src/abstract_display_controller.cpp", + "../dmserver/src/abstract_screen.cpp", + "../dmserver/src/abstract_screen_controller.cpp", "../dmserver/src/display_manager_service.cpp", "../dmserver/src/display_manager_service_inner.cpp", "../dmserver/src/display_manager_stub.cpp", "../dmserver/src/display_node_control.cpp", "../dmserver/src/display_power_controller.cpp", - "../dmserver/src/screen.cpp", "../wm/src/zidl/window_manager_agent_proxy.cpp", "src/input_window_monitor.cpp", "src/window_controller.cpp", -- Gitee