Add 'DisplayMove' interface to Window

Signed-off-by: lu <zhaolu2@huawei.com>
Change-Id: Ieaf19363ba09d3602a0239f10ed411d7134a7f45

dm/include/display_manager_adapter.h

@@ -55,6 +55,7 @@ WM_DECLARE_SINGLE_INSTANCE(DisplayManagerAdapter);
 public:
     virtual DisplayId GetDefaultDisplayId();
     virtual sptr<Display> GetDisplayById(DisplayId displayId);
+    virtual sptr<Display> GetDisplayByScreen(ScreenId screenId);
     virtual std::shared_ptr<Media::PixelMap> GetDisplaySnapshot(DisplayId displayId);
     virtual bool WakeUpBegin(PowerStateChangeReason reason);
     virtual bool WakeUpEnd();

dm/src/display_manager.cpp

@@ -169,7 +169,11 @@ const sptr<Display> DisplayManager::GetDisplayById(DisplayId displayId)
 
 const sptr<Display> DisplayManager::GetDisplayByScreen(ScreenId screenId)
 {
-    return nullptr;
+    sptr<Display> display = SingletonContainer::Get<DisplayManagerAdapter>().GetDisplayByScreen(screenId);
+    if (display == nullptr) {
+        WLOGFE("get display by screenId failed. screen %{public}" PRIu64"", screenId);
+    }
+    return display;
 }
 
 std::shared_ptr<Media::PixelMap> DisplayManager::GetScreenshot(DisplayId displayId)

dm/src/display_manager_adapter.cpp

@@ -88,6 +88,43 @@ sptr<Display> DisplayManagerAdapter::GetDisplayById(DisplayId displayId)
     return display;
 }
 
+sptr<Display> DisplayManagerAdapter::GetDisplayByScreen(ScreenId screenId)
+{
+    if (!InitDMSProxy()) {
+        WLOGFE("get display by screenId: init dms proxy failed!");
+        return nullptr;
+    }
+    
+    auto displayInfo = displayManagerServiceProxy_->GetDisplayInfoByScreen(screenId);
+    if (displayInfo == nullptr) {
+        WLOGFE("get display by screenId: displayInfo is null");
+        return nullptr;
+    }
+    DisplayId displayId = displayInfo->GetDisplayId();
+    if (displayId == DISPLAY_ID_INVALD) {
+        WLOGFE("get display by screenId: invalid displayInfo");
+        return nullptr;
+    }
+
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    auto iter = displayMap_.find(displayId);
+    sptr<Display> display;
+    if (iter != displayMap_.end()) {
+        display = iter->second;
+        if (display == nullptr) {
+            WLOGFE("get display by screenId: display in iterator is null");
+            return nullptr;
+        }
+        display->UpdateDisplayInfo(displayInfo);
+    } else {
+        display = new Display("", displayInfo);
+        if (display->GetId() != DISPLAY_ID_INVALD) {
+            displayMap_[display->GetId()] = display;
+        }
+    }
+    return display;
+}
+
 bool ScreenManagerAdapter::RequestRotation(ScreenId screenId, Rotation rotation)
 {
     if (!InitDMSProxy()) {

dmserver/include/abstract_display_controller.h

@@ -40,6 +40,7 @@ public:
 
     std::shared_ptr<Media::PixelMap> GetScreenSnapshot(DisplayId displayId);
     sptr<AbstractDisplay> GetAbstractDisplay(DisplayId displayId) const;
+    sptr<AbstractDisplay> GetAbstractDisplayByScreen(ScreenId screenId) const;
     void AddDisplayForExpandScreen(sptr<AbstractScreen> absScreen);
 
 private:

dmserver/include/display_manager_interface.h

@@ -35,6 +35,7 @@ public:
     enum {
         TRANS_ID_GET_DEFAULT_DISPLAY_ID = 0,
         TRANS_ID_GET_DISPLAY_BY_ID,
+        TRANS_ID_GET_DISPLAY_BY_SCREEN,
         TRANS_ID_GET_DISPLAY_SNAPSHOT,
         TRANS_ID_REGISTER_DISPLAY_MANAGER_AGENT,
         TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT,
@@ -69,6 +70,7 @@ public:
 
     virtual DisplayId GetDefaultDisplayId() = 0;
     virtual sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) = 0;
+    virtual sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) = 0;
 
     virtual ScreenId CreateVirtualScreen(VirtualScreenOption option) = 0;
     virtual DMError DestroyVirtualScreen(ScreenId screenId) = 0;

dmserver/include/display_manager_proxy.h

@@ -33,6 +33,7 @@ public:
 
     DisplayId GetDefaultDisplayId() override;
     sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) override;
+    sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) override;
 
     ScreenId CreateVirtualScreen(VirtualScreenOption option) override;
     DMError DestroyVirtualScreen(ScreenId screenId) override;

dmserver/include/display_manager_service.h

@@ -52,6 +52,7 @@ public:
 
     DisplayId GetDefaultDisplayId() override;
     sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) override;
+    sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) override;
     bool RequestRotation(ScreenId screenId, Rotation rotation) override;
     std::shared_ptr<Media::PixelMap> GetDispalySnapshot(DisplayId displayId) override;
     ScreenId GetRSScreenId(DisplayId displayId) const;
@@ -82,11 +83,12 @@ public:
     sptr<AbstractDisplay> GetAbstractDisplay(DisplayId displayId);
     sptr<AbstractScreenController> GetAbstractScreenController();
     sptr<AbstractDisplay> GetDisplayByDisplayId(DisplayId displayId) const;
+    sptr<AbstractDisplay> GetDisplayByScreen(ScreenId screenId) const;
     ScreenId MakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenId) override;
+    ScreenId MakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint) override;
     sptr<ScreenInfo> GetScreenInfoById(ScreenId screenId) override;
     sptr<ScreenGroupInfo> GetScreenGroupInfoById(ScreenId screenId) override;
     std::vector<sptr<ScreenInfo>> GetAllScreenInfos() override;
-    ScreenId MakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint) override;
     bool SetScreenActiveMode(ScreenId screenId, uint32_t modeId) override;
 
 private:

dmserver/src/abstract_display_controller.cpp

@@ -86,6 +86,19 @@ sptr<AbstractDisplay> AbstractDisplayController::GetAbstractDisplay(DisplayId di
     return iter->second;
 }
 
+sptr<AbstractDisplay> AbstractDisplayController::GetAbstractDisplayByScreen(ScreenId screenId) const
+{
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    for (auto iter : abstractDisplayMap_) {
+        sptr<AbstractDisplay> display = iter.second;
+        if (display->GetAbstractScreenId() == screenId) {
+            return display;
+        }
+    }
+    WLOGFE("fail to get AbstractDisplay %{public}" PRIu64"", screenId);
+    return nullptr;
+}
+
 std::shared_ptr<Media::PixelMap> AbstractDisplayController::GetScreenSnapshot(DisplayId displayId)
 {
     sptr<AbstractDisplay> abstractDisplay = GetAbstractDisplay(displayId);

dmserver/src/display_manager_proxy.cpp

@@ -84,6 +84,38 @@ sptr<DisplayInfo> DisplayManagerProxy::GetDisplayInfoById(DisplayId displayId)
     return info;
 }
 
+sptr<DisplayInfo> DisplayManagerProxy::GetDisplayInfoByScreen(ScreenId screenId)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        WLOGFE("fail to get displayInfo by screenId: remote is null");
+        return nullptr;
+    }
+
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        WLOGFE("fail to get displayInfo by screenId: WriteInterfaceToken failed");
+        return nullptr;
+    }
+    if (!data.WriteUint64(screenId)) {
+        WLOGFW("fail to get displayInfo by screenId: WriteUint64 displayId failed");
+        return nullptr;
+    }
+    if (remote->SendRequest(TRANS_ID_GET_DISPLAY_BY_SCREEN, data, reply, option) != ERR_NONE) {
+        WLOGFW("fail to get displayInfo by screenId: SendRequest failed");
+        return nullptr;
+    }
+
+    sptr<DisplayInfo> info = reply.ReadParcelable<DisplayInfo>();
+    if (info == nullptr) {
+        WLOGFW("fail to get displayInfo by screenId: SendRequest null");
+        return nullptr;
+    }
+    return info;
+}
+
 ScreenId DisplayManagerProxy::CreateVirtualScreen(VirtualScreenOption virtualOption)
 {
     sptr<IRemoteObject> remote = Remote();

dmserver/src/display_manager_service.cpp

@@ -94,7 +94,17 @@ sptr<DisplayInfo> DisplayManagerService::GetDisplayInfoById(DisplayId displayId)
 {
     sptr<AbstractDisplay> display = GetDisplayByDisplayId(displayId);
     if (display == nullptr) {
-        WLOGFE("GetDisplayById: Get invalid display!");
+        WLOGFE("fail to get displayInfo by id: invalid display");
+        return nullptr;
+    }
+    return display->ConvertToDisplayInfo();
+}
+
+sptr<DisplayInfo> DisplayManagerService::GetDisplayInfoByScreen(ScreenId screenId)
+{
+    sptr<AbstractDisplay> display = GetDisplayByScreen(screenId);
+    if (display == nullptr) {
+        WLOGFE("fail to get displayInfo by screenId: invalid display");
         return nullptr;
     }
     return display->ConvertToDisplayInfo();
@@ -330,6 +340,11 @@ sptr<AbstractDisplay> DisplayManagerService::GetDisplayByDisplayId(DisplayId dis
     return abstractDisplayController_->GetAbstractDisplay(displayId);
 }
 
+sptr<AbstractDisplay> DisplayManagerService::GetDisplayByScreen(ScreenId screenId) const
+{
+    return abstractDisplayController_->GetAbstractDisplayByScreen(screenId);
+}
+
 sptr<AbstractScreenController> DisplayManagerService::GetAbstractScreenController()
 {
     return abstractScreenController_;

dmserver/src/display_manager_stub.cpp

@@ -48,6 +48,12 @@ int32_t DisplayManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
             reply.WriteParcelable(info);
             break;
         }
+        case TRANS_ID_GET_DISPLAY_BY_SCREEN: {
+            ScreenId screenId = data.ReadUint64();
+            auto info = GetDisplayInfoByScreen(screenId);
+            reply.WriteParcelable(info);
+            break;
+        }
         case TRANS_ID_CREATE_VIRTUAL_SCREEN: {
             std::string name = data.ReadString();
             uint32_t width = data.ReadUint32();

interfaces/innerkits/wm/window.h

@@ -57,6 +57,12 @@ public:
     virtual void OnDrag(int32_t x, int32_t y, DragEvent event) = 0;
 };
 
+class IDisplayMoveListener : virtual public RefBase {
+public:
+    virtual void OnDisplayMove(DisplayId from, DisplayId to) = 0;
+};
+
+
 class Window : public RefBase {
 public:
     static sptr<Window> Create(const std::string& windowName,
@@ -114,6 +120,8 @@ public:
     virtual void UnregisterAvoidAreaChangeListener() = 0;
     virtual void RegisterDragListener(sptr<IWindowDragListener>& listener) = 0;
     virtual void UnregisterDragListener(sptr<IWindowDragListener>& listener) = 0;
+    virtual void RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) = 0;
+    virtual void UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) = 0;
     virtual WMError SetUIContent(const std::string& contentInfo, NativeEngine* engine,
         NativeValue* storage, bool isdistributed = false) = 0;
     virtual std::string GetContentInfo() = 0;

wm/include/window_agent.h

@@ -33,6 +33,7 @@ public:
     void UpdateAvoidArea(const std::vector<Rect>& avoidAreas) override;
     void UpdateWindowState(WindowState state) override;
     void UpdateWindowDragInfo(const PointInfo& point, DragEvent event) override;
+    void UpdateDisplayId(DisplayId from, DisplayId to) override;
 private:
     sptr<WindowImpl> window_;
 };

wm/include/window_impl.h

@@ -107,6 +107,8 @@ public:
     virtual void UnregisterAvoidAreaChangeListener() override;
     virtual void RegisterDragListener(sptr<IWindowDragListener>& listener) override;
     virtual void UnregisterDragListener(sptr<IWindowDragListener>& listener) override;
+    virtual void RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override;
+    virtual void UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener) override;
 
     void UpdateRect(const struct Rect& rect, WindowSizeChangeReason reason);
     void UpdateMode(WindowMode mode);
@@ -118,6 +120,7 @@ public:
     void UpdateAvoidArea(const std::vector<Rect>& avoidAreas);
     void UpdateWindowState(WindowState state);
     void UpdateDragEvent(const PointInfo& point, DragEvent event);
+    void UpdateDisplayId(DisplayId from, DisplayId to);
 
     virtual WMError SetUIContent(const std::string& contentInfo, NativeEngine* engine,
         NativeValue* storage, bool isdistributed) override;
@@ -179,6 +182,7 @@ private:
     std::vector<sptr<IWindowChangeListener>> windowChangeListeners_;
     sptr<IAvoidAreaChangedListener> avoidAreaChangeListener_;
     std::vector<sptr<IWindowDragListener>> windowDragListeners_;
+    std::vector<sptr<IDisplayMoveListener>> displayMoveListeners_;
     std::shared_ptr<RSSurfaceNode> surfaceNode_;
     std::string name_;
     std::unique_ptr<Ace::UIContent> uiContent_;

wm/include/window_interface.h

@@ -34,6 +34,7 @@ public:
         TRANS_ID_UPDATE_AVOID_AREA,
         TRANS_ID_UPDATE_WINDOW_STATE,
         TRANS_ID_UPDATE_DRAG_EVENT,
+        TRANS_ID_UPDATE_DISPLAY_ID,
     };
 
     virtual void UpdateWindowRect(const struct Rect& rect, WindowSizeChangeReason reason) = 0;
@@ -42,6 +43,7 @@ public:
     virtual void UpdateAvoidArea(const std::vector<Rect>& avoidAreas) = 0;
     virtual void UpdateWindowState(WindowState state) = 0;
     virtual void UpdateWindowDragInfo(const PointInfo& point, DragEvent event) = 0;
+    virtual void UpdateDisplayId(DisplayId from, DisplayId to) = 0;
 };
 } // namespace Rosen
 } // namespace OHOS

wm/include/window_proxy.h

@@ -34,6 +34,7 @@ public:
     void UpdateAvoidArea(const std::vector<Rect>& avoidAreas) override;
     void UpdateWindowState(WindowState state) override;
     void UpdateWindowDragInfo(const PointInfo& point, DragEvent event) override;
+    void UpdateDisplayId(DisplayId from, DisplayId to) override;
 private:
     static inline BrokerDelegator<WindowProxy> delegator_;
 };

wm/src/window_agent.cpp

@@ -73,13 +73,22 @@ void WindowAgent::UpdateWindowState(WindowState state)
     window_->UpdateWindowState(state);
 }
 
-void WindowAgent::UpdateWindowDragInfo(const PointInfo& piont, DragEvent event)
+void WindowAgent::UpdateWindowDragInfo(const PointInfo& point, DragEvent event)
 {
     if (window_ == nullptr) {
-        WLOGFE("window is nullptr");
+        WLOGFE("window is null");
         return;
     }
-    window_->UpdateDragEvent(piont, event);
+    window_->UpdateDragEvent(point, event);
+}
+
+void WindowAgent::UpdateDisplayId(DisplayId from, DisplayId to)
+{
+    if (window_ == nullptr) {
+        WLOGFE("window is null");
+        return;
+    }
+    window_->UpdateDisplayId(from, to);
 }
 } // namespace Rosen
 } // namespace OHOS

wm/src/window_impl.cpp

@@ -844,6 +844,26 @@ void WindowImpl::UnregisterDragListener(sptr<IWindowDragListener>& listener)
     windowDragListeners_.erase(iter);
 }
 
+void WindowImpl::RegisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener)
+{
+    if (listener == nullptr) {
+        return;
+    }
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    displayMoveListeners_.emplace_back(listener);
+}
+
+void WindowImpl::UnregisterDisplayMoveListener(sptr<IDisplayMoveListener>& listener)
+{
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    auto iter = std::find(displayMoveListeners_.begin(), displayMoveListeners_.end(), listener);
+    if (iter == displayMoveListeners_.end()) {
+        WLOGFE("could not find the listener");
+        return;
+    }
+    displayMoveListeners_.erase(iter);
+}
+
 void WindowImpl::UpdateRect(const struct Rect& rect, WindowSizeChangeReason reason)
 {
     auto display = DisplayManager::GetInstance().GetDisplayById(property_->GetDisplayId());
@@ -1158,6 +1178,16 @@ void WindowImpl::UpdateDragEvent(const PointInfo& point, DragEvent event)
     }
 }
 
+void WindowImpl::UpdateDisplayId(DisplayId from, DisplayId to)
+{
+    WLOGFD("update displayId. win %{public}d", GetWindowId());
+    for (auto& listener : displayMoveListeners_) {
+        if (listener != nullptr) {
+            listener->OnDisplayMove(from, to);
+        }
+    }
+}
+
 void WindowImpl::SetDefaultOption()
 {
     auto display = DisplayManager::GetInstance().GetDisplayById(property_->GetDisplayId());

wm/src/window_proxy.cpp

@@ -163,6 +163,24 @@ void WindowProxy::UpdateWindowDragInfo(const PointInfo& point, DragEvent event)
         WLOGFE("SendRequest TRANS_ID_UPDATE_DRAG_EVENT failed");
     }
 }
+    
+void WindowProxy::UpdateDisplayId(DisplayId from, DisplayId to)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option(MessageOption::TF_ASYNC);
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        WLOGFE("WriteInterfaceToken failed");
+        return;
+    }
+    if (!(data.WriteUint64(from) and data.WriteUint64(to))) {
+        WLOGFE("Write displayid failed");
+        return;
+    }
+    if (Remote()->SendRequest(TRANS_ID_UPDATE_DISPLAY_ID, data, reply, option) != ERR_NONE) {
+        WLOGFE("SendRequest TRANS_ID_UPDATE_DISPLAY_ID failed");
+    }
+}
 } // namespace Rosen
 } // namespace OHOS
 

wm/src/window_stub.cpp

@@ -70,6 +70,10 @@ int WindowStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParce
             UpdateWindowDragInfo(point, event);
             break;
         }
+        case TRANS_ID_UPDATE_DISPLAY_ID: {
+            UpdateDisplayId(data.ReadUint64(), data.ReadUint64());
+            break;
+        }
         default:
             break;
     }

wmserver/src/window_node_container.cpp

@@ -1004,22 +1004,26 @@ void WindowNodeContainer::RaiseInputMethodWindowPriorityIfNeeded(const sptr<Wind
 
 void WindowNodeContainer::MoveWindowNode(sptr<WindowNodeContainer>& container)
 {
-    WLOGFI("MoveWindowNode: disconnect expand display: %{public}" PRId64 ", move window node to display: "
-        "%{public}" PRId64 "", container->GetDisplayId(), displayId_);
+    DisplayId from = container->GetDisplayId();
+    WLOGFI("disconnect expand display: %{public}" PRId64 ", move window node to display: "
+        "%{public}" PRId64 "", from, displayId_);
     for (auto& node : container->belowAppWindowNode_->children_) {
         WLOGFI("belowAppWindowNode_: move windowNode: {public}%d", node->GetWindowId());
         node->SetDisplayId(displayId_);
         belowAppWindowNode_->children_.push_back(node);
+        node->GetWindowToken()->UpdateDisplayId(from, displayId_);
     }
     for (auto& node : container->appWindowNode_->children_) {
         WLOGFI("appWindowNode_: move windowNode: {public}%d", node->GetWindowId());
         node->SetDisplayId(displayId_);
         appWindowNode_->children_.push_back(node);
+        node->GetWindowToken()->UpdateDisplayId(from, displayId_);
     }
     for (auto& node : container->aboveAppWindowNode_->children_) {
         WLOGFI("aboveAppWindowNode_: move windowNode: {public}%d", node->GetWindowId());
         node->SetDisplayId(displayId_);
         aboveAppWindowNode_->children_.push_back(node);
+        node->GetWindowToken()->UpdateDisplayId(from, displayId_);
     }
 }