From 86f827d8ff0fb5571200b4d3cca4d90f4e68f2ae Mon Sep 17 00:00:00 2001 From: huatong Date: Fri, 22 Sep 2023 14:57:14 +0800 Subject: [PATCH 1/2] add foldscreen interface impl code Signed-off-by: huatong --- dm/include/display_manager_adapter.h | 11 + dm/include/display_manager_agent_default.h | 2 + .../zidl/display_manager_agent_interface.h | 6 + dm/include/zidl/display_manager_agent_proxy.h | 2 + dm/src/display_manager.cpp | 241 ++++++++++++++++++ dm/src/display_manager_adapter.cpp | 35 +++ dm/src/zidl/display_manager_agent_proxy.cpp | 36 +++ dm/src/zidl/display_manager_agent_stub.cpp | 18 ++ .../display_manager_agent_controller.h | 2 + dmserver/include/display_manager_interface.h | 16 ++ .../src/display_manager_agent_controller.cpp | 24 ++ interfaces/innerkits/dm/display_manager.h | 88 +++++++ interfaces/innerkits/dm/dm_common.h | 21 ++ .../display_runtime/js_display_listener.cpp | 52 ++++ .../display_runtime/js_display_listener.h | 9 +- .../display_runtime/js_display_manager.cpp | 183 +++++++++++++ utils/include/cutout_info.h | 1 + utils/include/fold_screen_info.h | 106 ++++++++ .../include/screen_session_manager.h | 17 ++ .../zidl/screen_session_manager_interface.h | 10 + .../zidl/screen_session_manager_proxy.h | 10 + .../src/screen_session_manager.cpp | 50 ++++ .../src/zidl/screen_session_manager_proxy.cpp | 117 +++++++++ .../src/zidl/screen_session_manager_stub.cpp | 23 ++ 24 files changed, 1079 insertions(+), 1 deletion(-) create mode 100644 utils/include/fold_screen_info.h diff --git a/dm/include/display_manager_adapter.h b/dm/include/display_manager_adapter.h index d4ce567f56..6b13d6b4a7 100644 --- a/dm/include/display_manager_adapter.h +++ b/dm/include/display_manager_adapter.h @@ -25,6 +25,7 @@ #include "screen_group.h" #include "dm_common.h" #include "display_manager_interface.h" +#include "fold_screen_info.h" #include "singleton_delegator.h" namespace OHOS::Rosen { @@ -73,6 +74,16 @@ public: virtual DMError AddSurfaceNodeToDisplay(DisplayId displayId, std::shared_ptr& surfaceNode); virtual DMError RemoveSurfaceNodeFromDisplay(DisplayId displayId, std::shared_ptr& surfaceNode); + + virtual bool IsFoldable(); + + virtual FoldStatus GetFoldStatus(); + + virtual FoldDisplayMode GetFoldDisplayMode(); + + virtual void SetFoldDisplayMode(const FoldDisplayMode); + + virtual sptr GetCurrentFoldCreaseRegion(); private: static inline SingletonDelegator delegator; }; diff --git a/dm/include/display_manager_agent_default.h b/dm/include/display_manager_agent_default.h index 8f3f1e71a4..18d433a573 100644 --- a/dm/include/display_manager_agent_default.h +++ b/dm/include/display_manager_agent_default.h @@ -37,6 +37,8 @@ public: void OnDisplayChange(const sptr, DisplayChangeEvent) override {}; void OnScreenshot(sptr) override {}; void NotifyPrivateWindowStateChanged(bool hasPrivate) override {}; + void NotifyFoldStatusChanged(FoldStatus foldStatus) override {}; + void NotifyDisplayModeChanged(FoldDisplayMode displayMode) override {}; }; } } diff --git a/dm/include/zidl/display_manager_agent_interface.h b/dm/include/zidl/display_manager_agent_interface.h index 80be6a1138..aa27666814 100644 --- a/dm/include/zidl/display_manager_agent_interface.h +++ b/dm/include/zidl/display_manager_agent_interface.h @@ -31,6 +31,8 @@ enum class DisplayManagerAgentType : uint32_t { DISPLAY_EVENT_LISTENER, SCREENSHOT_EVENT_LISTENER, PRIVATE_WINDOW_LISTENER, + FOLD_STATUS_CHANGED_LISTENER, + DISPLAY_MODE_CHANGED_LISTENER, }; class IDisplayManagerAgent : public IRemoteBroker { @@ -49,6 +51,8 @@ public: TRANS_ID_ON_DISPLAY_CHANGED, TRANS_ID_ON_SCREEN_SHOT, TRANS_ID_ON_PRIVATE_WINDOW, + TRANS_ID_ON_FOLD_STATUS_CHANGED, + TRANS_ID_ON_DISPLAY_MODE_CHANGED, }; virtual void NotifyDisplayPowerEvent(DisplayPowerEvent event, EventStatus status) = 0; virtual void NotifyDisplayStateChanged(DisplayId id, DisplayState state) = 0; @@ -62,6 +66,8 @@ public: virtual void OnDisplayChange(sptr, DisplayChangeEvent) = 0; virtual void OnScreenshot(sptr) = 0; virtual void NotifyPrivateWindowStateChanged(bool hasPrivate) = 0; + virtual void NotifyFoldStatusChanged(FoldStatus) = 0; + virtual void NotifyDisplayModeChanged(FoldDisplayMode) = 0; }; } // namespace Rosen } // namespace OHOS diff --git a/dm/include/zidl/display_manager_agent_proxy.h b/dm/include/zidl/display_manager_agent_proxy.h index 9ef4f926b3..bf463a4c22 100644 --- a/dm/include/zidl/display_manager_agent_proxy.h +++ b/dm/include/zidl/display_manager_agent_proxy.h @@ -38,6 +38,8 @@ public: virtual void OnDisplayChange(sptr, DisplayChangeEvent) override; virtual void OnScreenshot(sptr) override; virtual void NotifyPrivateWindowStateChanged(bool hasPrivate) override; + virtual void NotifyFoldStatusChanged(FoldStatus) override; + virtual void NotifyDisplayModeChanged(FoldDisplayMode) override; private: static inline BrokerDelegator delegator_; }; diff --git a/dm/src/display_manager.cpp b/dm/src/display_manager.cpp index 0fb71cd27e..7f8a852dfb 100644 --- a/dm/src/display_manager.cpp +++ b/dm/src/display_manager.cpp @@ -46,6 +46,17 @@ public: sptr GetDefaultDisplaySync(); sptr GetDisplayById(DisplayId displayId); DMError HasPrivateWindow(DisplayId displayId, bool& hasPrivateWindow); + + bool IsFoldable(); + + FoldStatus GetFoldStatus(); + + FoldDisplayMode GetFoldDisplayMode(); + + void SetFoldDisplayMode(const FoldDisplayMode); + + sptr GetCurrentFoldCreaseRegion(); + DMError RegisterDisplayListener(sptr listener); DMError UnregisterDisplayListener(sptr listener); bool SetDisplayState(DisplayState state, DisplayStateCallback callback); @@ -55,6 +66,10 @@ public: DMError UnregisterScreenshotListener(sptr listener); DMError RegisterPrivateWindowListener(sptr listener); DMError UnregisterPrivateWindowListener(sptr listener); + DMError RegisterFoldStatusListener(sptr listener); + DMError UnregisterFoldStatusListener(sptr listener); + DMError RegisterDisplayModeListener(sptr listener); + DMError UnregisterDisplayModeListener(sptr listener); sptr GetDisplayByScreenId(ScreenId screenId); void OnRemoteDied(); private: @@ -68,6 +83,8 @@ private: void NotifyDisplayDestroy(DisplayId); void NotifyDisplayChange(sptr displayInfo); bool UpdateDisplayInfoLocked(sptr); + void NotifyFoldStatusChanged(FoldStatus foldStatus); + void NotifyDisplayModeChanged(FoldDisplayMode displayMode); void Clear(); DisplayId defaultDisplayId_ = DISPLAY_ID_INVALID; @@ -78,6 +95,8 @@ private: std::set> powerEventListeners_; std::set> screenshotListeners_; std::set> privateWindowListeners_; + std::set> foldStatusListeners_; + std::set> displayModeListeners_; class DisplayManagerListener; sptr displayManagerListener_; class DisplayManagerAgent; @@ -87,6 +106,10 @@ private: sptr screenshotListenerAgent_; class DisplayManagerPrivateWindowAgent; sptr privateWindowListenerAgent_; + class DisplayManagerFoldStatusAgent; + sptr foldStatusListenerAgent_; + class DisplayManagerDisplayModeAgent; + sptr displayModeListenerAgent_; }; class DisplayManager::Impl::DisplayManagerListener : public DisplayManagerAgentDefault { @@ -212,6 +235,36 @@ private: sptr pImpl_; }; +class DisplayManager::Impl::DisplayManagerFoldStatusAgent : public DisplayManagerAgentDefault { +public: + explicit DisplayManagerFoldStatusAgent(sptr impl) : pImpl_(impl) + { + } + ~DisplayManagerFoldStatusAgent() = default; + + virtual void NotifyFoldStatusChanged(FoldStatus foldStatus) override + { + pImpl_->NotifyFoldStatusChanged(foldStatus); + } +private: + sptr pImpl_; +}; + +class DisplayManager::Impl::DisplayManagerDisplayModeAgent : public DisplayManagerAgentDefault { +public: + explicit DisplayManagerDisplayModeAgent(sptr impl) : pImpl_(impl) + { + } + ~DisplayManagerDisplayModeAgent() = default; + + virtual void NotifyDisplayModeChanged(FoldDisplayMode displayMode) override + { + pImpl_->NotifyDisplayModeChanged(displayMode); + } +private: + sptr pImpl_; +}; + bool DisplayManager::Impl::CheckRectValid(const Media::Rect& rect, int32_t oriHeight, int32_t oriWidth) const { if (rect.left < 0) { @@ -508,6 +561,56 @@ DMError DisplayManager::Impl::HasPrivateWindow(DisplayId displayId, bool& hasPri return SingletonContainer::Get().HasPrivateWindow(displayId, hasPrivateWindow); } +bool DisplayManager::IsFoldable() +{ + return pImpl_->IsFoldable(); +} + +bool DisplayManager::Impl::IsFoldable() +{ + return SingletonContainer::Get().IsFoldable(); +} + +FoldStatus DisplayManager::GetFoldStatus() +{ + return pImpl_->GetFoldStatus(); +} + +FoldStatus DisplayManager::Impl::GetFoldStatus() +{ + return SingletonContainer::Get().GetFoldStatus(); +} + +FoldDisplayMode DisplayManager::GetFoldDisplayMode() +{ + return pImpl_->GetFoldDisplayMode(); +} + +FoldDisplayMode DisplayManager::Impl::GetFoldDisplayMode() +{ + return SingletonContainer::Get().GetFoldDisplayMode(); +} + +void DisplayManager::SetFoldDisplayMode(const FoldDisplayMode mode) +{ + pImpl_->SetFoldDisplayMode(mode); +} + +void DisplayManager::Impl::SetFoldDisplayMode(const FoldDisplayMode mode) +{ + SingletonContainer::Get().SetFoldDisplayMode(mode); +} + +sptr DisplayManager::GetCurrentFoldCreaseRegion() +{ + return pImpl_->GetCurrentFoldCreaseRegion(); +} + +sptr DisplayManager::Impl::GetCurrentFoldCreaseRegion() +{ + return SingletonContainer::Get().GetCurrentFoldCreaseRegion(); +} + DMError DisplayManager::Impl::RegisterDisplayListener(sptr listener) { std::lock_guard lock(mutex_); @@ -746,6 +849,144 @@ DMError DisplayManager::UnregisterScreenshotListener(sptr l return pImpl_->UnregisterScreenshotListener(listener); } +void DisplayManager::Impl::NotifyFoldStatusChanged(FoldStatus foldStatus) +{ + std::set> foldStatusListeners; + { + std::lock_guard lock(mutex_); + foldStatusListeners = foldStatusListeners_; + } + for (auto& listener : foldStatusListeners) { + listener->OnFoldStatusChanged(foldStatus); + } +} + +DMError DisplayManager::RegisterFoldStatusListener(sptr listener) +{ + if (listener == nullptr) { + WLOGFE("IFoldStatusListener listener is nullptr."); + return DMError::DM_ERROR_NULLPTR; + } + return pImpl_->RegisterFoldStatusListener(listener); +} + +DMError DisplayManager::Impl::RegisterFoldStatusListener(sptr listener) +{ + std::lock_guard lock(mutex_); + DMError ret = DMError::DM_OK; + if (foldStatusListenerAgent_ == nullptr) { + foldStatusListenerAgent_ = new DisplayManagerFoldStatusAgent(this); + ret = SingletonContainer::Get().RegisterDisplayManagerAgent( + foldStatusListenerAgent_, + DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER); + } + if (ret != DMError::DM_OK) { + WLOGFW("RegisterFoldStatusListener failed !"); + foldStatusListenerAgent_ = nullptr; + } else { + WLOGI("IFoldStatusListener register success"); + foldStatusListeners_.insert(listener); + } + return ret; +} + +DMError DisplayManager::UnregisterFoldStatusListener(sptr listener) +{ + if (listener == nullptr) { + WLOGFE("UnregisterFoldStatusListener listener is nullptr."); + return DMError::DM_ERROR_NULLPTR; + } + return pImpl_->UnregisterFoldStatusListener(listener); +} + +DMError DisplayManager::Impl::UnregisterFoldStatusListener(sptr listener) +{ + std::lock_guard lock(mutex_); + auto iter = std::find(foldStatusListeners_.begin(), foldStatusListeners_.end(), listener); + if (iter == foldStatusListeners_.end()) { + WLOGFE("could not find this listener"); + return DMError::DM_ERROR_NULLPTR; + } + foldStatusListeners_.erase(iter); + DMError ret = DMError::DM_OK; + if (foldStatusListeners_.empty() && foldStatusListenerAgent_ != nullptr) { + ret = SingletonContainer::Get().UnregisterDisplayManagerAgent( + foldStatusListenerAgent_, + DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER); + foldStatusListenerAgent_ = nullptr; + } + return ret; +} + +void DisplayManager::Impl::NotifyDisplayModeChanged(FoldDisplayMode displayMode) +{ + std::set> displayModeListeners; + { + std::lock_guard lock(mutex_); + displayModeListeners = displayModeListeners_; + } + for (auto& listener : displayModeListeners) { + listener->OnDisplayModeChanged(displayMode); + } +} + +DMError DisplayManager::RegisterDisplayModeListener(sptr listener) +{ + if (listener == nullptr) { + WLOGFE("IDisplayModeListener listener is nullptr."); + return DMError::DM_ERROR_NULLPTR; + } + return pImpl_->RegisterDisplayModeListener(listener); +} + +DMError DisplayManager::Impl::RegisterDisplayModeListener(sptr listener) +{ + std::lock_guard lock(mutex_); + DMError ret = DMError::DM_OK; + if (displayModeListenerAgent_ == nullptr) { + displayModeListenerAgent_ = new DisplayManagerDisplayModeAgent(this); + ret = SingletonContainer::Get().RegisterDisplayManagerAgent( + displayModeListenerAgent_, + DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER); + } + if (ret != DMError::DM_OK) { + WLOGFW("RegisterDisplayModeListener failed !"); + displayModeListenerAgent_ = nullptr; + } else { + WLOGI("IDisplayModeListener register success"); + displayModeListeners_.insert(listener); + } + return ret; +} + +DMError DisplayManager::UnregisterDisplayModeListener(sptr listener) +{ + if (listener == nullptr) { + WLOGFE("UnregisterPrivateWindowListener listener is nullptr."); + return DMError::DM_ERROR_NULLPTR; + } + return pImpl_->UnregisterDisplayModeListener(listener); +} + +DMError DisplayManager::Impl::UnregisterDisplayModeListener(sptr listener) +{ + std::lock_guard lock(mutex_); + auto iter = std::find(displayModeListeners_.begin(), displayModeListeners_.end(), listener); + if (iter == displayModeListeners_.end()) { + WLOGFE("could not find this listener"); + return DMError::DM_ERROR_NULLPTR; + } + displayModeListeners_.erase(iter); + DMError ret = DMError::DM_OK; + if (displayModeListeners_.empty() && displayModeListenerAgent_ != nullptr) { + ret = SingletonContainer::Get().UnregisterDisplayManagerAgent( + displayModeListenerAgent_, + DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER); + displayModeListenerAgent_ = nullptr; + } + return ret; +} + void DisplayManager::Impl::NotifyScreenshot(sptr info) { WLOGFD("NotifyScreenshot trigger:[%{public}s] displayId:%{public}" PRIu64" size:%{public}zu", diff --git a/dm/src/display_manager_adapter.cpp b/dm/src/display_manager_adapter.cpp index b257bdfad0..18ff4e9cf7 100644 --- a/dm/src/display_manager_adapter.cpp +++ b/dm/src/display_manager_adapter.cpp @@ -429,6 +429,41 @@ DMError DisplayManagerAdapter::RemoveSurfaceNodeFromDisplay(DisplayId displayId, return displayManagerServiceProxy_->RemoveSurfaceNodeFromDisplay(displayId, surfaceNode); } +bool DisplayManagerAdapter::IsFoldable() +{ + INIT_PROXY_CHECK_RETURN(false); + + return displayManagerServiceProxy_->IsFoldable(); +} + +FoldStatus DisplayManagerAdapter::GetFoldStatus() +{ + INIT_PROXY_CHECK_RETURN(FoldStatus::UNKNOWN); + + return displayManagerServiceProxy_->GetFoldStatus(); +} + +FoldDisplayMode DisplayManagerAdapter::GetFoldDisplayMode() +{ + INIT_PROXY_CHECK_RETURN(FoldDisplayMode::UNKNOWN); + + return displayManagerServiceProxy_->GetFoldDisplayMode(); +} + +void DisplayManagerAdapter::SetFoldDisplayMode(const FoldDisplayMode mode) +{ + INIT_PROXY_CHECK_RETURN(); + + return displayManagerServiceProxy_->SetFoldDisplayMode(mode); +} + +sptr DisplayManagerAdapter::GetCurrentFoldCreaseRegion() +{ + INIT_PROXY_CHECK_RETURN(nullptr); + + return displayManagerServiceProxy_->GetCurrentFoldCreaseRegion(); +} + sptr ScreenManagerAdapter::GetScreenGroupInfoById(ScreenId screenId) { if (screenId == SCREEN_ID_INVALID) { diff --git a/dm/src/zidl/display_manager_agent_proxy.cpp b/dm/src/zidl/display_manager_agent_proxy.cpp index c8c82d6b22..ea978a9ab2 100644 --- a/dm/src/zidl/display_manager_agent_proxy.cpp +++ b/dm/src/zidl/display_manager_agent_proxy.cpp @@ -270,6 +270,42 @@ void DisplayManagerAgentProxy::NotifyPrivateWindowStateChanged(bool hasPrivate) WLOGFE("SendRequest failed"); } } + +void DisplayManagerAgentProxy::NotifyFoldStatusChanged(FoldStatus foldStatus) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option(MessageOption::TF_ASYNC); + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken failed"); + return; + } + if (!data.WriteUint32(static_cast(foldStatus))) { + WLOGFE("Write foldStatus failed"); + return; + } + if (Remote()->SendRequest(TRANS_ID_ON_FOLD_STATUS_CHANGED, data, reply, option) != ERR_NONE) { + WLOGFE("SendRequest failed"); + } +} + +void DisplayManagerAgentProxy::NotifyDisplayModeChanged(FoldDisplayMode displayMode) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option(MessageOption::TF_ASYNC); + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken failed"); + return; + } + if (!data.WriteUint32(static_cast(displayMode))) { + WLOGFE("Write displayMode failed"); + return; + } + if (Remote()->SendRequest(TRANS_ID_ON_DISPLAY_MODE_CHANGED, data, reply, option) != ERR_NONE) { + WLOGFE("SendRequest failed"); + } +} } // namespace Rosen } // namespace OHOS diff --git a/dm/src/zidl/display_manager_agent_stub.cpp b/dm/src/zidl/display_manager_agent_stub.cpp index e1c741b8b5..12db3d4a17 100644 --- a/dm/src/zidl/display_manager_agent_stub.cpp +++ b/dm/src/zidl/display_manager_agent_stub.cpp @@ -125,6 +125,24 @@ int32_t DisplayManagerAgentStub::OnRemoteRequest(uint32_t code, MessageParcel& d NotifyPrivateWindowStateChanged(hasPrivate); break; } + case TRANS_ID_ON_FOLD_STATUS_CHANGED: { + uint32_t foldStatus; + if (!data.ReadUint32(foldStatus)) { + WLOGFE("Read FoldStatus failed"); + return -1; + } + NotifyFoldStatusChanged(static_cast(foldStatus)); + break; + } + case TRANS_ID_ON_DISPLAY_MODE_CHANGED: { + uint32_t displayMode; + if (!data.ReadUint32(displayMode)) { + WLOGFE("Read FoldDisplayMode failed"); + return -1; + } + NotifyDisplayModeChanged(static_cast(displayMode)); + break; + } default: { WLOGFW("unknown transaction code %{public}d", code); return IPCObjectStub::OnRemoteRequest(code, data, reply, option); diff --git a/dmserver/include/display_manager_agent_controller.h b/dmserver/include/display_manager_agent_controller.h index 129fd82c54..b854bb6894 100644 --- a/dmserver/include/display_manager_agent_controller.h +++ b/dmserver/include/display_manager_agent_controller.h @@ -45,6 +45,8 @@ public: void OnDisplayChange(sptr, DisplayChangeEvent); void OnScreenshot(sptr); void NotifyPrivateWindowStateChanged(bool hasPrivate); + void NotifyFoldStatusChanged(FoldStatus); + void NotifyDisplayModeChanged(FoldDisplayMode); private: DisplayManagerAgentController() {} diff --git a/dmserver/include/display_manager_interface.h b/dmserver/include/display_manager_interface.h index 236a2f8de0..b6793d1b68 100644 --- a/dmserver/include/display_manager_interface.h +++ b/dmserver/include/display_manager_interface.h @@ -23,6 +23,7 @@ #include "display_cutout_controller.h" #include "display_info.h" #include "dm_common.h" +#include "fold_screen_info.h" #include "screen.h" #include "screen_info.h" #include "screen_group_info.h" @@ -83,6 +84,11 @@ public: TRANS_ID_SCENE_BOARD_SCREEN_BASE = 2000, TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN, TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN, + TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE, + TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE, + TRANS_ID_SCENE_BOARD_IS_FOLDABLE, + TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS, + TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION, }; virtual sptr GetDefaultDisplayInfo() = 0; @@ -140,6 +146,16 @@ public: std::shared_ptr& surfaceNode, bool onTop = true) = 0; virtual DMError RemoveSurfaceNodeFromDisplay(DisplayId displayId, std::shared_ptr& surfaceNode) = 0; + + virtual bool IsFoldable() { return false; } + + virtual FoldStatus GetFoldStatus() { return FoldStatus::UNKNOWN; } + + virtual FoldDisplayMode GetFoldDisplayMode() { return FoldDisplayMode::UNKNOWN; } + + virtual void SetFoldDisplayMode(const FoldDisplayMode) {} + + virtual sptr GetCurrentFoldCreaseRegion() { return nullptr; } }; } // namespace OHOS::Rosen diff --git a/dmserver/src/display_manager_agent_controller.cpp b/dmserver/src/display_manager_agent_controller.cpp index b28975f3a6..0c7c104caa 100644 --- a/dmserver/src/display_manager_agent_controller.cpp +++ b/dmserver/src/display_manager_agent_controller.cpp @@ -203,5 +203,29 @@ void DisplayManagerAgentController::NotifyPrivateWindowStateChanged(bool hasPriv agent->NotifyPrivateWindowStateChanged(hasPrivate); } } + +void DisplayManagerAgentController::NotifyFoldStatusChanged(FoldStatus foldStatus) +{ + auto agents = dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER); + if (agents.empty()) { + return; + } + WLOGI("FoldStatus is : %{public}u", foldStatus); + for (auto& agent : agents) { + agent->NotifyFoldStatusChanged(foldStatus); + } +} + +void DisplayManagerAgentController::NotifyDisplayModeChanged(FoldDisplayMode displayMode) +{ + auto agents = dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER); + if (agents.empty()) { + return; + } + WLOGI("FoldDisplayMode is : %{public}u", displayMode); + for (auto& agent : agents) { + agent->NotifyDisplayModeChanged(displayMode); + } +} } } \ No newline at end of file diff --git a/interfaces/innerkits/dm/display_manager.h b/interfaces/innerkits/dm/display_manager.h index 3f1b8742db..6521aa09d5 100644 --- a/interfaces/innerkits/dm/display_manager.h +++ b/interfaces/innerkits/dm/display_manager.h @@ -22,6 +22,7 @@ #include "display.h" #include "dm_common.h" +#include "fold_screen_info.h" #include "wm_single_instance.h" #include "screenshot_info.h" @@ -68,6 +69,26 @@ public: virtual void OnPrivateWindow([[maybe_unused]]bool hasPrivate) {} }; + class IFoldStatusListener : public virtual RefBase { + public: + /** + * @brief Notify listeners when screen fold status changed. + * + * @param foldStatus Screen foldStatus. + */ + virtual void OnFoldStatusChanged(FoldStatus foldStatus) {} + }; + + class IDisplayModeListener : public virtual RefBase { + public: + /** + * @brief Notify listeners when display mode changed. + * + * @param displayMode DisplayMode. + */ + virtual void OnDisplayModeChanged(FoldDisplayMode displayMode) {} + }; + /** * @brief Obtain all displays. * @@ -300,6 +321,38 @@ public: */ DMError UnregisterPrivateWindowListener(sptr listener); + /** + * @brief Register a listener for the event of screen fold status changed. + * + * @param listener IFoldStatusListener. + * @return DM_OK means register success, others means register failed. + */ + DMError RegisterFoldStatusListener(sptr listener); + + /** + * @brief Unregister an existed listener for the event of screen fold status changed. + * + * @param listener IFoldStatusListener. + * @return DM_OK means unregister success, others means unregister failed. + */ + DMError UnregisterFoldStatusListener(sptr listener); + + /** + * @brief Register a listener for the event of dispaly mode changed. + * + * @param listener IDisplayModeListener. + * @return DM_OK means register success, others means register failed. + */ + DMError RegisterDisplayModeListener(sptr listener); + + /** + * @brief Unregister an existed listener for the event of dispaly mode changed. + * + * @param listener IDisplayModeListener. + * @return DM_OK means unregister success, others means unregister failed. + */ + DMError UnregisterDisplayModeListener(sptr listener); + /** * @brief Add a surface node to the target display. * @@ -318,6 +371,41 @@ public: */ DMError RemoveSurfaceNodeFromDisplay(DisplayId displayId, std::shared_ptr& surfaceNode); + /** + * @brief Check whether the device is foldable. + * + * @return true means the device is foldable. + */ + bool IsFoldable(); + + /** + * @brief Get the current fold status of the foldable device. + * + * @return fold status of device. + */ + FoldStatus GetFoldStatus(); + + /** + * @brief Get the display mode of the foldable device. + * + * @return display mode of the foldable device. + */ + FoldDisplayMode GetFoldDisplayMode(); + + /** + * @brief Change the display mode of the foldable device. + * + * @param mode target display mode to change. + */ + void SetFoldDisplayMode(const FoldDisplayMode mode); + + /** + * @brief Get the fold crease region in the current display mode. + * + * @return fold crease region in the current display mode. + */ + sptr GetCurrentFoldCreaseRegion(); + constexpr static int32_t MAX_RESOLUTION_SIZE_SCREENSHOT = 3840; // max resolution, 4K private: diff --git a/interfaces/innerkits/dm/dm_common.h b/interfaces/innerkits/dm/dm_common.h index 880f1611d1..4fe2e61cb6 100644 --- a/interfaces/innerkits/dm/dm_common.h +++ b/interfaces/innerkits/dm/dm_common.h @@ -245,6 +245,27 @@ enum class ScreenSourceMode: uint32_t { SCREEN_EXTEND = 2, SCREEN_ALONE = 3, }; + +/** + * @brief Enumerates the fold status. + */ +enum class FoldStatus: uint32_t { + UNKNOWN = 0, + EXPAND = 1, + FOLDED = 2, + HALF_FOLD = 3, +}; + +/** + * @brief Enumerates the fold display mode. + */ +enum class FoldDisplayMode: uint32_t { + UNKNOWN = 0, + FULL = 1, + MAIN = 2, + SUB = 3, + COORDINATION = 4, +}; } } #endif // OHOS_ROSEN_DM_COMMON_H \ No newline at end of file diff --git a/interfaces/kits/napi/display_runtime/js_display_listener.cpp b/interfaces/kits/napi/display_runtime/js_display_listener.cpp index ca740f348e..98bd06e580 100644 --- a/interfaces/kits/napi/display_runtime/js_display_listener.cpp +++ b/interfaces/kits/napi/display_runtime/js_display_listener.cpp @@ -187,5 +187,57 @@ void JsDisplayListener::OnPrivateWindow(bool hasPrivate) AsyncTask::Schedule("JsDisplayListener::OnPrivateWindow", *engine_, std::make_unique( callback, std::move(execute), std::move(complete))); } + +void JsDisplayListener::OnFoldStatusChanged(FoldStatus foldStatus) +{ + std::lock_guard lock(mtx_); + WLOGI("OnFoldStatusChanged is called, foldStatus: %{public}u", static_cast(foldStatus)); + if (jsCallBack_.empty()) { + WLOGFE("OnFoldStatusChanged not register!"); + return; + } + if (jsCallBack_.find(EVENT_FOLD_STATUS_CHANGED) == jsCallBack_.end()) { + WLOGE("OnFoldStatusChanged not this event, return"); + return; + } + sptr listener = this; // Avoid this be destroyed when using. + std::unique_ptr complete = std::make_unique ( + [this, listener, foldStatus] (NativeEngine &engine, AsyncTask &task, int32_t status) { + NativeValue* argv[] = {CreateJsValue(*engine_, foldStatus)}; + CallJsMethod(EVENT_FOLD_STATUS_CHANGED, argv, ArraySize(argv)); + } + ); + + NativeReference* callback = nullptr; + std::unique_ptr execute = nullptr; + AsyncTask::Schedule("JsDisplayListener::OnFoldStatusChanged", *engine_, std::make_unique( + callback, std::move(execute), std::move(complete))); +} + +void JsDisplayListener::OnDisplayModeChanged(FoldDisplayMode displayMode) +{ + std::lock_guard lock(mtx_); + WLOGI("OnDisplayModeChanged is called, displayMode: %{public}u", static_cast(displayMode)); + if (jsCallBack_.empty()) { + WLOGFE("OnDisplayModeChanged not register!"); + return; + } + if (jsCallBack_.find(EVENT_DISPLAY_MODE_CHANGED) == jsCallBack_.end()) { + WLOGE("OnDisplayModeChanged not this event, return"); + return; + } + sptr listener = this; // Avoid this be destroyed when using. + std::unique_ptr complete = std::make_unique ( + [this, listener, displayMode] (NativeEngine &engine, AsyncTask &task, int32_t status) { + NativeValue* argv[] = {CreateJsValue(*engine_, displayMode)}; + CallJsMethod(EVENT_DISPLAY_MODE_CHANGED, argv, ArraySize(argv)); + } + ); + + NativeReference* callback = nullptr; + std::unique_ptr execute = nullptr; + AsyncTask::Schedule("JsDisplayListener::OnDisplayModeChanged", *engine_, std::make_unique( + callback, std::move(execute), std::move(complete))); +} } // namespace Rosen } // namespace OHOS diff --git a/interfaces/kits/napi/display_runtime/js_display_listener.h b/interfaces/kits/napi/display_runtime/js_display_listener.h index f5a72eda06..35ac6b612e 100644 --- a/interfaces/kits/napi/display_runtime/js_display_listener.h +++ b/interfaces/kits/napi/display_runtime/js_display_listener.h @@ -25,7 +25,9 @@ namespace OHOS { namespace Rosen { class JsDisplayListener : public DisplayManager::IDisplayListener, - public DisplayManager::IPrivateWindowListener { + public DisplayManager::IPrivateWindowListener, + public DisplayManager::IFoldStatusListener, + public DisplayManager::IDisplayModeListener { public: explicit JsDisplayListener(NativeEngine* engine) : engine_(engine) {} ~JsDisplayListener() override = default; @@ -36,6 +38,8 @@ public: void OnDestroy(DisplayId id) override; void OnChange(DisplayId id) override; void OnPrivateWindow(bool hasPrivate) override; + void OnFoldStatusChanged(FoldStatus foldStatus) override; + void OnDisplayModeChanged(FoldDisplayMode displayMode) override; private: void CallJsMethod(const std::string& methodName, NativeValue* const* argv = nullptr, size_t argc = 0); @@ -48,6 +52,9 @@ const std::string EVENT_ADD = "add"; const std::string EVENT_REMOVE = "remove"; const std::string EVENT_CHANGE = "change"; const std::string EVENT_PRIVATE_MODE_CHANGE = "privateModeChange"; +const std::string +EVENT_FOLD_STATUS_CHANGED = "foldStatusChange"; +const std::string EVENT_DISPLAY_MODE_CHANGED = "foldDisplayModeChange"; } // namespace Rosen } // namespace OHOS #endif /* OHOS_JS_DISPLAY_LISTENER_H */ \ No newline at end of file diff --git a/interfaces/kits/napi/display_runtime/js_display_manager.cpp b/interfaces/kits/napi/display_runtime/js_display_manager.cpp index 91deced8b3..5601c6e0b4 100644 --- a/interfaces/kits/napi/display_runtime/js_display_manager.cpp +++ b/interfaces/kits/napi/display_runtime/js_display_manager.cpp @@ -91,6 +91,36 @@ static NativeValue* HasPrivateWindow(NativeEngine* engine, NativeCallbackInfo* i return (me != nullptr) ? me->OnHasPrivateWindow(*engine, *info) : nullptr; } +static NativeValue* IsFoldable(NativeEngine* engine, NativeCallbackInfo* info) +{ + auto* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnIsFoldable(*engine, *info) : nullptr; +} + +static NativeValue* GetFoldStatus(NativeEngine* engine, NativeCallbackInfo* info) +{ + auto* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnGetFoldStatus(*engine, *info) : nullptr; +} + +static NativeValue* GetFoldDisplayMode(NativeEngine* engine, NativeCallbackInfo* info) +{ + auto* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnGetFoldDisplayMode(*engine, *info) : nullptr; +} + +static NativeValue* SetFoldDisplayMode(NativeEngine* engine, NativeCallbackInfo* info) +{ + auto* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnSetFoldDisplayMode(*engine, *info) : nullptr; +} + +static NativeValue* GetCurrentFoldCreaseRegion(NativeEngine* engine, NativeCallbackInfo* info) +{ + auto* me = CheckParamsAndGetThis(engine, info); + return (me != nullptr) ? me->OnGetCurrentFoldCreaseRegion(*engine, *info) : nullptr; +} + private: std::map, sptr>> jsCbMap_; std::mutex mtx_; @@ -224,6 +254,10 @@ DMError RegisterDisplayListenerWithType(NativeEngine& engine, const std::string& ret = SingletonContainer::Get().RegisterDisplayListener(displayListener); } else if (type == EVENT_PRIVATE_MODE_CHANGE) { ret = SingletonContainer::Get().RegisterPrivateWindowListener(displayListener); + } else if (type == EVENT_FOLD_STATUS_CHANGED) { + ret = SingletonContainer::Get().RegisterFoldStatusListener(displayListener); + } else if (type == EVENT_DISPLAY_MODE_CHANGED) { + ret = SingletonContainer::Get().RegisterDisplayModeListener(displayListener); } else { WLOGFE("RegisterDisplayListenerWithType failed, %{public}s not support", type.c_str()); return DMError::DM_ERROR_INVALID_PARAM; @@ -428,6 +462,98 @@ NativeValue* CreateJsDisplayArrayObject(NativeEngine& engine, std::vector= ARGC_ONE) { + engine.Throw(CreateJsError(engine, static_cast(DmErrorCode::DM_ERROR_INVALID_PARAM))); + return engine.CreateUndefined(); + } + bool foldable = SingletonContainer::Get().IsFoldable(); + WLOGI("[NAPI]" PRIu64", isFoldable = %{public}u", foldable); + return engine.CreateBoolean(foldable); +} + +NativeValue* OnGetFoldStatus(NativeEngine& engine, NativeCallbackInfo& info) +{ + if (info.argc >= ARGC_ONE) { + engine.Throw(CreateJsError(engine, static_cast(DmErrorCode::DM_ERROR_INVALID_PARAM))); + return engine.CreateUndefined(); + } + FoldStatus status = SingletonContainer::Get().GetFoldStatus(); + WLOGI("[NAPI]" PRIu64", getFoldStatus = %{public}u", status); + return CreateJsValue(engine, status); +} + +NativeValue* OnGetFoldDisplayMode(NativeEngine& engine, NativeCallbackInfo& info) +{ + if (info.argc >= ARGC_ONE) { + engine.Throw(CreateJsError(engine, static_cast(DmErrorCode::DM_ERROR_INVALID_PARAM))); + return engine.CreateUndefined(); + } + FoldDisplayMode mode = SingletonContainer::Get().GetFoldDisplayMode(); + WLOGI("[NAPI]" PRIu64", getFoldDisplayMode = %{public}u", mode); + return CreateJsValue(engine, mode); +} + +NativeValue* OnSetFoldDisplayMode(NativeEngine& engine, NativeCallbackInfo& info) +{ + if (info.argc < ARGC_ONE) { + engine.Throw(CreateJsError(engine, static_cast(DmErrorCode::DM_ERROR_INVALID_PARAM))); + return engine.CreateUndefined(); + } + FoldDisplayMode mode = FoldDisplayMode::UNKNOWN; + if (!ConvertFromJsValue(engine, info.argv[0], mode)) { + WLOGFE("[NAPI]Failed to convert parameter to FoldDisplayMode"); + engine.Throw(CreateJsError(engine, static_cast(DmErrorCode::DM_ERROR_INVALID_PARAM))); + return engine.CreateUndefined(); + } + SingletonContainer::Get().SetFoldDisplayMode(mode); + WLOGI("[NAPI]" PRIu64", setFoldDisplayMode"); + return engine.CreateUndefined(); +} + +NativeValue* OnGetCurrentFoldCreaseRegion(NativeEngine& engine, NativeCallbackInfo& info) +{ + if (info.argc >= ARGC_ONE) { + engine.Throw(CreateJsError(engine, static_cast(DmErrorCode::DM_ERROR_INVALID_PARAM))); + return engine.CreateUndefined(); + } + sptr region = SingletonContainer::Get().GetCurrentFoldCreaseRegion(); + WLOGI("[NAPI]" PRIu64", getCurrentFoldCreaseRegion"); + return CreateJsFoldCreaseRegionObject(engine, region); +} + +NativeValue* CreateJsFoldCreaseRegionObject(NativeEngine& engine, sptr region) +{ + WLOGI("JsDisplay::CreateJsFoldCreaseRegionObject is called"); + NativeValue* objValue = engine.CreateObject(); + auto* object = ConvertNativeValueTo(objValue); + if (object == nullptr) { + WLOGFE("Failed to convert prop to jsObject"); + return engine.CreateUndefined(); + } + if (region == nullptr) { + WLOGFE("Get null fold crease region"); + return engine.CreateUndefined(); + } + DisplayId displayId = region->GetDisplayId(); + std::vector creaseRects = region->GetCreaseRects(); + object->SetProperty("displayId", CreateJsValue(engine, static_cast(displayId))); + object->SetProperty("creaseRects", CreateJsCreaseRectsArrayObject(engine, creaseRects)); + return objValue; +} + +NativeValue* CreateJsCreaseRectsArrayObject(NativeEngine& engine, std::vector creaseRects) +{ + NativeValue* arrayValue = engine.CreateArray(creaseRects.size()); + auto* array = ConvertNativeValueTo(arrayValue); + size_t i = 0; + for (const auto& rect : creaseRects) { + array->SetElement(i++, CreateJsRectObject(engine, rect)); + } + return arrayValue; +} }; NativeValue* InitDisplayState(NativeEngine* engine) @@ -563,6 +689,55 @@ NativeValue* InitDisplayError(NativeEngine* engine) return objValue; } +NativeValue* InitFoldStatus(NativeEngine* engine) +{ + WLOGI("InitFoldStatus called"); + + if (engine == nullptr) { + WLOGFE("engine is nullptr"); + return nullptr; + } + + NativeValue* objValue = engine->CreateObject(); + auto* object = ConvertNativeValueTo(objValue); + if (object == nullptr) { + WLOGFE("Failed to get object"); + return nullptr; + } + object->SetProperty("FOLD_STATUS_UNKNOWN", CreateJsValue(*engine, static_cast(FoldStatus::UNKNOWN))); + object->SetProperty("FOLD_STATUS_EXPANDED", CreateJsValue(*engine, static_cast(FoldStatus::EXPAND))); + object->SetProperty("FOLD_STATUS_FOLDED", CreateJsValue(*engine, static_cast(FoldStatus::FOLDED))); + object->SetProperty("FOLD_STATUS_HALF_FOLDED", + CreateJsValue(*engine, static_cast(FoldStatus::HALF_FOLD))); + return objValue; +} + +NativeValue* InitFoldDisplayMode(NativeEngine* engine) +{ + WLOGI("IniFoldDisplayMode called"); + + if (engine == nullptr) { + WLOGFE("engine is nullptr"); + return nullptr; + } + + NativeValue* objValue = engine->CreateObject(); + auto* object = ConvertNativeValueTo(objValue); + if (object == nullptr) { + WLOGFE("Failed to get object"); + return nullptr; + } + + object->SetProperty("FOLD_DISPLAY_MODE_UNKNOWN", + CreateJsValue(*engine, static_cast(FoldDisplayMode::UNKNOWN))); + object->SetProperty("FOLD_DISPLAY_MODE_FULL", CreateJsValue(*engine, static_cast(FoldDisplayMode::FULL))); + object->SetProperty("FOLD_DISPLAY_MODE_MAIN", CreateJsValue(*engine, static_cast(FoldDisplayMode::MAIN))); + object->SetProperty("FOLD_DISPLAY_MODE_SUB", CreateJsValue(*engine, static_cast(FoldDisplayMode::SUB))); + object->SetProperty("FOLD_DISPLAY_MODE_COORDINATION", + CreateJsValue(*engine, static_cast(FoldDisplayMode::COORDINATION))); + return objValue; +} + NativeValue* JsDisplayManagerInit(NativeEngine* engine, NativeValue* exportObj) { WLOGI("JsDisplayManagerInit is called"); @@ -585,6 +760,8 @@ NativeValue* JsDisplayManagerInit(NativeEngine* engine, NativeValue* exportObj) object->SetProperty("Orientation", InitOrientation(engine)); object->SetProperty("DmErrorCode", InitDisplayErrorCode(engine)); object->SetProperty("DMError", InitDisplayError(engine)); + object->SetProperty("FoldStatus", InitFoldStatus(engine)); + object->SetProperty("FoldDisplayMode", InitFoldDisplayMode(engine)); const char *moduleName = "JsDisplayManager"; BindNativeFunction(*engine, *object, "getDefaultDisplay", moduleName, JsDisplayManager::GetDefaultDisplay); @@ -592,6 +769,12 @@ NativeValue* JsDisplayManagerInit(NativeEngine* engine, NativeValue* exportObj) BindNativeFunction(*engine, *object, "getAllDisplay", moduleName, JsDisplayManager::GetAllDisplay); BindNativeFunction(*engine, *object, "getAllDisplays", moduleName, JsDisplayManager::GetAllDisplays); BindNativeFunction(*engine, *object, "hasPrivateWindow", moduleName, JsDisplayManager::HasPrivateWindow); + BindNativeFunction(*engine, *object, "isFoldable", moduleName, JsDisplayManager::IsFoldable); + BindNativeFunction(*engine, *object, "getFoldStatus", moduleName, JsDisplayManager::GetFoldStatus); + BindNativeFunction(*engine, *object, "getFoldDisplayMode", moduleName, JsDisplayManager::GetFoldDisplayMode); + BindNativeFunction(*engine, *object, "setFoldDisplayMode", moduleName, JsDisplayManager::SetFoldDisplayMode); + BindNativeFunction(*engine, *object, "getCurrentFoldCreaseRegion", moduleName, + JsDisplayManager::GetCurrentFoldCreaseRegion); BindNativeFunction(*engine, *object, "on", moduleName, JsDisplayManager::RegisterDisplayManagerCallback); BindNativeFunction(*engine, *object, "off", moduleName, JsDisplayManager::UnregisterDisplayManagerCallback); return engine->CreateUndefined(); diff --git a/utils/include/cutout_info.h b/utils/include/cutout_info.h index d72bff6687..5eeb2d9f5a 100644 --- a/utils/include/cutout_info.h +++ b/utils/include/cutout_info.h @@ -21,6 +21,7 @@ #include "class_var_definition.h" #include "display.h" #include "dm_common.h" +#include "noncopyable.h" namespace OHOS::Rosen { struct DMRect { diff --git a/utils/include/fold_screen_info.h b/utils/include/fold_screen_info.h new file mode 100644 index 0000000000..03d77614c0 --- /dev/null +++ b/utils/include/fold_screen_info.h @@ -0,0 +1,106 @@ +/* + * 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 FOUNDATION_DMSERVER_FOLD_SCREEN_INFO_H +#define FOUNDATION_DMSERVER_FOLD_SCREEN_INFO_H + +#include + +#include "class_var_definition.h" +#include "cutout_info.h" +#include "dm_common.h" + +namespace OHOS::Rosen { +/** + * @brief Fold Crease Region + */ +class FoldCreaseRegion : public Parcelable { +public: + FoldCreaseRegion() = default; + + FoldCreaseRegion(DisplayId displayId, const std::vector& creaseRects) + : displayId_(displayId), creaseRects_(creaseRects) {} + + ~FoldCreaseRegion() override = default; + + bool Marshalling(Parcel& parcel) const override + { + return parcel.WriteUint64(displayId_) && + WriteCreaseRectVector(creaseRects_, parcel); + } + + static FoldCreaseRegion *Unmarshalling(Parcel& parcel) + { + DisplayId displayId = DISPLAY_ID_INVALID; + std::vector creaseRects; + parcel.ReadUint64(displayId); + ReadCreaseRectVector(creaseRects, parcel); + auto* region = new FoldCreaseRegion(displayId, creaseRects); + return region; + } + +DEFINE_VAR_DEFAULT_FUNC_GET_SET(DisplayId, DisplayId, displayId, DISPLAY_ID_INVALID) + +DEFINE_VAR_FUNC_GET(std::vector, CreaseRects, creaseRects) + + void SetCreaseRects(std::vector value) + { creaseRects_ = std::move(value); } +private: + const static uint32_t MAX_CREASE_REGION_SIZE = 20; + + static bool WriteCreaseRectVector(const std::vector& creaseRects, Parcel& parcel) + { + auto size = static_cast(creaseRects.size()); + if (!parcel.WriteUint32(size)) { + return false; + } + if (size > MAX_CREASE_REGION_SIZE) { + return false; + } + for (auto rect : creaseRects) { + if (!(parcel.WriteInt32(rect.posX_) && parcel.WriteInt32(rect.posY_) && + parcel.WriteUint32(rect.width_) && parcel.WriteUint32(rect.height_))) { + return false; + } + } + return true; + } + + static bool ReadCreaseRectVector(std::vector& creaseRects, Parcel& parcel) + { + uint32_t size; + if (!parcel.ReadUint32(size)) { + return false; + } + if (size > MAX_CREASE_REGION_SIZE) { + return false; + } + for (uint32_t index = 0; index < size; index++) { + int32_t posX; + int32_t posY; + uint32_t width; + uint32_t height; + if (!(parcel.ReadInt32(posX) && parcel.ReadInt32(posY) && + parcel.ReadUint32(width) && parcel.ReadUint32(height))) { + return false; + } + DMRect rect = {posX, posY, width, height}; + creaseRects.push_back(rect); + } + return true; + } +}; +} // namespace OHOS::Rosen +#endif // FOUNDATION_DMSERVER_FOLD_SCREEN_INFO_H \ No newline at end of file diff --git a/window_scene/session_manager/include/screen_session_manager.h b/window_scene/session_manager/include/screen_session_manager.h index f62d017350..e714c0acd8 100644 --- a/window_scene/session_manager/include/screen_session_manager.h +++ b/window_scene/session_manager/include/screen_session_manager.h @@ -157,6 +157,23 @@ public: sptr GetCutoutInfo(DisplayId displayId) override; void SetDisplayBoundary(const sptr screenSession); + //Fold Screen + void SetFoldDisplayMode(const FoldDisplayMode displayMode) override; + + FoldDisplayMode GetFoldDisplayMode() override; + + bool IsFoldable() override; + + FoldStatus GetFoldStatus() override; + + sptr GetCurrentFoldCreaseRegion() override; + + ScreenProperty GetPhyScreenProperty(ScreenId screenId); + uint32_t GetCurvedCompressionArea() const; + + void NotifyFoldStatusChanged(FoldStatus foldStatus); + void NotifyDisplayModeChanged(FoldDisplayMode displayMode); + protected: ScreenSessionManager(); virtual ~ScreenSessionManager() = default; diff --git a/window_scene/session_manager/include/zidl/screen_session_manager_interface.h b/window_scene/session_manager/include/zidl/screen_session_manager_interface.h index 588c3c1ec2..970a677b1f 100644 --- a/window_scene/session_manager/include/zidl/screen_session_manager_interface.h +++ b/window_scene/session_manager/include/zidl/screen_session_manager_interface.h @@ -93,6 +93,16 @@ public: std::shared_ptr& surfaceNode) override { return DMError::DM_OK; } virtual void DumpAllScreensInfo(std::string& dumpInfo) {} virtual void DumpSpecialScreenInfo(ScreenId id, std::string& dumpInfo) {} + // Fold Screen + void SetFoldDisplayMode(const FoldDisplayMode displayMode) override {} + + FoldDisplayMode GetFoldDisplayMode() override { return FoldDisplayMode::UNKNOWN; } + + bool IsFoldable() override { return false; }; + + FoldStatus GetFoldStatus() override { return FoldStatus::UNKNOWN; }; + + sptr GetCurrentFoldCreaseRegion() override { return nullptr; }; }; } // namespace Rosen diff --git a/window_scene/session_manager/include/zidl/screen_session_manager_proxy.h b/window_scene/session_manager/include/zidl/screen_session_manager_proxy.h index acacdd1b5e..9ba3e73a9c 100644 --- a/window_scene/session_manager/include/zidl/screen_session_manager_proxy.h +++ b/window_scene/session_manager/include/zidl/screen_session_manager_proxy.h @@ -90,6 +90,16 @@ public: virtual void DumpAllScreensInfo(std::string& dumpInfo) override; virtual void DumpSpecialScreenInfo(ScreenId id, std::string& dumpInfo) override; + //Fold Screen + void SetFoldDisplayMode(const FoldDisplayMode displayMode) override; + + FoldDisplayMode GetFoldDisplayMode() override; + + bool IsFoldable() override; + + FoldStatus GetFoldStatus() override; + + sptr GetCurrentFoldCreaseRegion() override; private: static inline BrokerDelegator delegator_; }; diff --git a/window_scene/session_manager/src/screen_session_manager.cpp b/window_scene/session_manager/src/screen_session_manager.cpp index 05f7f85892..0561293301 100644 --- a/window_scene/session_manager/src/screen_session_manager.cpp +++ b/window_scene/session_manager/src/screen_session_manager.cpp @@ -1814,4 +1814,54 @@ void ScreenSessionManager::DumpSpecialScreenInfo(ScreenId id, std::string& dumpI oss << "NodeId: " << nodeId << std::endl; dumpInfo.append(oss.str()); } + +// --- Fold Screen --- +void ScreenSessionManager::SetFoldDisplayMode(const FoldDisplayMode displayMode) +{ + WLOGFI("ScreenSessionManager::SetFoldDisplayMode"); +} + +FoldDisplayMode ScreenSessionManager::GetFoldDisplayMode() +{ + return FoldDisplayMode::UNKNOWN; +} + +bool ScreenSessionManager::IsFoldable() +{ + return false; +} + +FoldStatus ScreenSessionManager::GetFoldStatus() +{ + return FoldStatus::UNKNOWN; +} + +sptr ScreenSessionManager::GetCurrentFoldCreaseRegion() +{ + return nullptr; +} + +void ScreenSessionManager::NotifyFoldStatusChanged(FoldStatus foldStatus) +{ + WLOGI("NotifyFoldStatusChanged foldStatus:%{public}d", foldStatus); + auto agents = dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER); + if (agents.empty()) { + return; + } + for (auto& agent: agents) { + agent->NotifyFoldStatusChanged(foldStatus); + } +} + +void ScreenSessionManager::NotifyDisplayModeChanged(FoldDisplayMode displayMode) +{ + WLOGI("NotifyDisplayModeChanged displayMode:%{public}d", displayMode); + auto agents = dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER); + if (agents.empty()) { + return; + } + for (auto& agent: agents) { + agent->NotifyDisplayModeChanged(displayMode); + } +} } // namespace OHOS::Rosen diff --git a/window_scene/session_manager/src/zidl/screen_session_manager_proxy.cpp b/window_scene/session_manager/src/zidl/screen_session_manager_proxy.cpp index b04f8212d4..b8dcc218d7 100644 --- a/window_scene/session_manager/src/zidl/screen_session_manager_proxy.cpp +++ b/window_scene/session_manager/src/zidl/screen_session_manager_proxy.cpp @@ -1145,4 +1145,121 @@ void ScreenSessionManagerProxy::DumpSpecialScreenInfo(ScreenId id, std::string& } dumpInfo = reply.ReadString(); } + +//Fold Screen +void ScreenSessionManagerProxy::SetFoldDisplayMode(const FoldDisplayMode displayMode) +{ + sptr remote = Remote(); + if (remote == nullptr) { + WLOGFW("remote is null"); + return; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken Failed"); + return; + } + if (!data.WriteUint32(static_cast(displayMode))) { + WLOGFE("Write displayMode failed"); + return; + } + if (remote->SendRequest(static_cast(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE), + data, reply, option) != ERR_NONE) { + WLOGFE("Send TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE request failed"); + } +} + +FoldDisplayMode ScreenSessionManagerProxy::GetFoldDisplayMode() +{ + sptr remote = Remote(); + if (remote == nullptr) { + WLOGFW("remote is null"); + return FoldDisplayMode::UNKNOWN; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken Failed"); + return FoldDisplayMode::UNKNOWN; + } + if (remote->SendRequest(static_cast(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE), + data, reply, option) != ERR_NONE) { + WLOGFE("Send TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE request failed"); + return FoldDisplayMode::UNKNOWN; + } + return static_cast(reply.ReadUint32()); +} + +bool ScreenSessionManagerProxy::IsFoldable() +{ + sptr remote = Remote(); + if (remote == nullptr) { + WLOGFW("remote is null"); + return false; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken failed"); + return false; + } + if (remote->SendRequest(static_cast(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE), + data, reply, option) != ERR_NONE) { + WLOGFE("SendRequest failed"); + return false; + } + return reply.ReadBool(); +} + +FoldStatus ScreenSessionManagerProxy::GetFoldStatus() +{ + sptr remote = Remote(); + if (remote == nullptr) { + WLOGFW("remote is null"); + return FoldStatus::UNKNOWN; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken failed"); + return FoldStatus::UNKNOWN; + } + if (remote->SendRequest(static_cast(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS), + data, reply, option) != ERR_NONE) { + WLOGFE("SendRequest failed"); + return FoldStatus::UNKNOWN; + } + return static_cast(reply.ReadUint32()); +} + +sptr ScreenSessionManagerProxy::GetCurrentFoldCreaseRegion() +{ + sptr remote = Remote(); + if (remote == nullptr) { + WLOGFW("remote is null"); + return nullptr; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + WLOGFE("WriteInterfaceToken failed"); + return nullptr; + } + if (remote->SendRequest( + static_cast(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION), + data, reply, option) != ERR_NONE) { + WLOGFE("SendRequest failed"); + return nullptr; + } + return reply.ReadStrongParcelable(); +} } // namespace OHOS::Rosen diff --git a/window_scene/session_manager/src/zidl/screen_session_manager_stub.cpp b/window_scene/session_manager/src/zidl/screen_session_manager_stub.cpp index ea8dca2008..9d6e959c2b 100644 --- a/window_scene/session_manager/src/zidl/screen_session_manager_stub.cpp +++ b/window_scene/session_manager/src/zidl/screen_session_manager_stub.cpp @@ -330,6 +330,29 @@ int32_t ScreenSessionManagerStub::OnRemoteRequest(uint32_t code, MessageParcel& reply.WriteString(dumpInfo); break; } + //Fold Screen + case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE: { + FoldDisplayMode displayMode = static_cast(data.ReadUint32()); + SetFoldDisplayMode(displayMode); + break; + } + case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE: { + FoldDisplayMode displayMode = GetFoldDisplayMode(); + reply.WriteUint32(static_cast(displayMode)); + break; + } + case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE: { + reply.WriteBool(IsFoldable()); + break; + } + case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS: { + reply.WriteUint32(static_cast(GetFoldStatus())); + break; + } + case DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION: { + reply.WriteStrongParcelable(GetCurrentFoldCreaseRegion()); + break; + } default: WLOGFW("unknown transaction code"); return IPCObjectStub::OnRemoteRequest(code, data, reply, option); -- Gitee From 3c061ed48b9a9e9bedbc589068f939d42048e049 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8A=B1=E4=B8=B8?= Date: Sat, 23 Sep 2023 07:45:10 +0000 Subject: [PATCH 2/2] update window_scene/session_manager/src/screen_session_manager.cpp. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 花丸 --- window_scene/session_manager/src/screen_session_manager.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/window_scene/session_manager/src/screen_session_manager.cpp b/window_scene/session_manager/src/screen_session_manager.cpp index 0561293301..2f4fe33e46 100644 --- a/window_scene/session_manager/src/screen_session_manager.cpp +++ b/window_scene/session_manager/src/screen_session_manager.cpp @@ -1823,17 +1823,17 @@ void ScreenSessionManager::SetFoldDisplayMode(const FoldDisplayMode displayMode) FoldDisplayMode ScreenSessionManager::GetFoldDisplayMode() { - return FoldDisplayMode::UNKNOWN; + return FoldDisplayMode::UNKNOWN; } bool ScreenSessionManager::IsFoldable() { - return false; + return false; } FoldStatus ScreenSessionManager::GetFoldStatus() { - return FoldStatus::UNKNOWN; + return FoldStatus::UNKNOWN; } sptr ScreenSessionManager::GetCurrentFoldCreaseRegion() -- Gitee