add split ratio function

Signed-off-by: wlj <wangliangjiang1@huawei.com>
Change-Id: I20f0aa2d69ece76735c9652510a3c9a6ed610f7b

resources/config/other/window_manager_config.xml

@@ -18,4 +18,8 @@
     <decor enable="true"></decor>
     <!--minimizeByOther enable is true means fullscreen window will be minmized by other fullscreen window-->
     <minimizeByOther enable="true"></minimizeByOther>
+    <!--exit split screen mode ratio config-->
+    <exitSplitRatio>0.1</exitSplitRatio>
+    <!--split screen ratios config-->
+    <splitRatios>0.5 0.33 0.67</splitRatios>
  </Configs>

resources/config/rk3568/window_manager_config.xml

@@ -24,4 +24,8 @@
     <modeChangeHotZones>50 50 50</modeChangeHotZones>
     <!--stretchable enable is true means all window be stretchable-->
     <stretchable enable="false"></stretchable>
+    <!--exit split screen mode ratio config-->
+    <exitSplitRatio>0.1</exitSplitRatio>
+    <!--split screen ratios config-->
+    <splitRatios>0.5 0.33 0.67</splitRatios>
  </Configs>

utils/include/wm_common_inner.h

@@ -103,6 +103,11 @@ struct ModeChangeHotZones {
     Rect secondary_;
 };
 
+struct SplitRatioConfig {
+    float exitSplitRatio;
+    std::vector<float> splitRatios;
+};
+
 enum class DragType : uint32_t {
     DRAG_UNDEFINED,
     DRAG_WIDTH,

wm/test/systemtest/window_split_test.cpp

@@ -206,11 +206,11 @@ HWTEST_F(WindowSplitTest, SplitScreen04, Function | MediumTest | Level3)
 }
 
 /**
- * @tc.name: SplitCreen05
- * @tc.desc: forbid dock slive to move test
+ * @tc.name: SplitScreen05
+ * @tc.desc: forbid dock slice to move test
  * @tc.type: FUNC
  */
-HWTEST_F(WindowSplitTest, SplitCreen05, Function | MediumTest | Level3)
+HWTEST_F(WindowSplitTest, SplitScreen05, Function | MediumTest | Level3)
 {
     fullInfo_.name  = "fullscreen.5";
     splitInfo_.name = "primary.5";

wmserver/include/minimize_app.h

@@ -31,6 +31,7 @@ enum class MinimizeReason : uint32_t {
     LAYOUT_TILE,
     MAX_APP_COUNT,
     SPLIT_REPLACE,
+    SPLIT_QUIT,
     OTHER_WINDOW,
 };
 
@@ -50,7 +51,7 @@ private:
     {
         return (reason == MinimizeReason::MINIMIZE_ALL || reason == MinimizeReason::MINIMIZE_BUTTOM ||
             reason == MinimizeReason::MAX_APP_COUNT || reason == MinimizeReason::LAYOUT_TILE ||
-            reason == MinimizeReason::SPLIT_REPLACE);
+            reason == MinimizeReason::SPLIT_REPLACE || reason == MinimizeReason::SPLIT_QUIT);
     }
 
     static std::map<MinimizeReason, std::vector<wptr<WindowNode>>> needMinimizeAppNodes_;

wmserver/include/window_layout_policy.h

@@ -53,6 +53,7 @@ public:
     virtual void UpdateLayoutRect(const sptr<WindowNode>& node) = 0;
     virtual void SetSplitDividerWindowRects(std::map<DisplayId, Rect> dividerWindowRects) {};
     virtual Rect GetInitalDividerRect(DisplayId displayId) const;
+    virtual std::vector<int32_t> GetExitSplitPoints(DisplayId displayId) const;
     float GetVirtualPixelRatio(DisplayId displayId) const;
     void UpdateClientRectAndResetReason(const sptr<WindowNode>& node, const Rect& lastLayoutRect, const Rect& winRect);
     Rect GetDisplayGroupRect() const;
@@ -61,6 +62,7 @@ public:
     void ProcessDisplayDestroy(DisplayId displayId, const std::map<DisplayId, Rect>& displayRectMap);
     void ProcessDisplaySizeChangeOrRotation(DisplayId displayId, const std::map<DisplayId, Rect>& displayRectMap);
     void SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig);
+    void SetSplitRatioConfig(SplitRatioConfig splitRatioConfig);
 
 protected:
     void UpdateFloatingLayoutRect(Rect& limitRect, Rect& winRect);
@@ -111,6 +113,8 @@ protected:
         Rect secondaryLimitRect_;
         Rect dividerRect_;
         Rect firstCascadeRect_;
+        std::vector<int32_t> exitSplitPoints_; // 2 element, first elment < second element
+        std::vector<int32_t> splitRatioPoints_;
     };
     sptr<DisplayGroupInfo> displayGroupInfo_;
     mutable std::map<DisplayId, Rect> limitRectMap_;
@@ -119,6 +123,7 @@ protected:
     Rect displayGroupLimitRect_;
     bool isMultiDisplay_ = false;
     FloatingWindowLimitsConfig floatingWindowLimitsConfig_;
+    SplitRatioConfig splitRatioConfig_;
 };
 }
 }

wmserver/include/window_layout_policy_cascade.h

@@ -42,13 +42,16 @@ public:
     void SetSplitDividerWindowRects(std::map<DisplayId, Rect> dividerWindowRects) override;
     void RemoveWindowNode(const sptr<WindowNode>& node) override;
     Rect GetInitalDividerRect(DisplayId displayId) const override;
+    std::vector<int32_t> GetExitSplitPoints(DisplayId displayId) const override;
 
 private:
     void InitAllRects();
     void InitSplitRects(DisplayId displayId);
-    void SetSplitRectByRatio(float ratio, DisplayId displayId);
+    int32_t GetSplitRatioPoint(float ratio, DisplayId displayId);
     void SetSplitRect(const Rect& rect, DisplayId displayId);
     void UpdateSplitLimitRect(const Rect& limitRect, Rect& limitSplitRect);
+    void UpdateSplitRatioPoints(DisplayId displayId);
+    void UpdateDockSlicePosition(DisplayId displayId, int32_t& origin) const;
     void LayoutWindowNode(const sptr<WindowNode>& node) override;
     void LayoutWindowTree(DisplayId displayId) override;
     void InitLimitRects(DisplayId displayId);

wmserver/include/window_manager_service.h

@@ -109,6 +109,7 @@ private:
     void NotifyDisplayStateChange(DisplayId id, DisplayStateChangeType type);
     WMError GetFocusWindowInfo(sptr<IRemoteObject>& abilityToken);
     void ConfigureWindowManagerService();
+    void ConfigFloatWindowLimits();
 
     static inline SingletonDelegator<WindowManagerService> delegator;
     sptr<WindowRoot> windowRoot_;

wmserver/include/window_node_container.h

@@ -65,6 +65,8 @@ public:
     void NotifyAccessibilityWindowInfo(const sptr<WindowNode>& windowId, WindowUpdateType type) const;
     int GetWindowCountByType(WindowType windowType);
     bool IsForbidDockSliceMove(DisplayId displayId) const;
+    bool IsDockSliceInExitSplitModeArea(DisplayId displayId) const;
+    void ExitSplitMode(DisplayId displayId);
 
     void OnAvoidAreaChange(const std::vector<Rect>& avoidAreas, DisplayId displayId);
     bool isVerticalDisplay(DisplayId displayId) const;

wmserver/include/window_pair.h

@@ -160,6 +160,17 @@ public:
      */
     bool IsForbidDockSliceMove() const;
 
+    /**
+     * when dock slice in exit split screen mode area,
+     * exit split screen mode.
+     */
+    void ExitSplitMode();
+
+    /**
+     * whether dock slice in exit split screen mode area
+     */
+    bool IsDockSliceInExitSplitModeArea(const std::vector<int32_t>& exitSplitPoints);
+
     /**
      * Set all app windows are restoring.
      *

wmserver/include/window_root.h

@@ -49,6 +49,8 @@ public:
     WMError UpdateWindowNode(uint32_t windowId, WindowUpdateReason reason);
     bool isVerticalDisplay(sptr<WindowNode>& node) const;
     bool IsForbidDockSliceMove(DisplayId displayId) const;
+    bool IsDockSliceInExitSplitModeArea(DisplayId displayId) const;
+    void ExitSplitMode(DisplayId displayId);
 
     WMError RequestFocus(uint32_t windowId);
     WMError RequestActiveWindow(uint32_t windowId);
@@ -86,6 +88,8 @@ public:
     sptr<WindowNode> GetWindowForDumpAceHelpInfo() const;
     void DestroyLeakStartingWindow();
     void SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig);
+    void SetSplitRatios(const std::vector<float>& splitRatioNumbers);
+    void SetExitSplitRatio(float exitSplitRatio);
 private:
     void OnRemoteDied(const sptr<IRemoteObject>& remoteObject);
     WMError DestroyWindowInner(sptr<WindowNode>& node);
@@ -119,6 +123,7 @@ private:
     Callback callback_;
     int maxAppWindowNumber_ = 100;
     FloatingWindowLimitsConfig floatingWindowLimitsConfig_;
+    SplitRatioConfig splitRatioConfig_ = {0.1, {}};
 };
 }
 }

wmserver/src/window_controller.cpp

@@ -616,6 +616,20 @@ WMError WindowController::ProcessPointUp(uint32_t windowId)
         WLOGFW("could not find window");
         return WMError::WM_ERROR_NULLPTR;
     }
+    if (node->GetWindowType() == WindowType::WINDOW_TYPE_DOCK_SLICE) {
+        DisplayId displayId = node->GetDisplayId();
+        if (windowRoot_->IsDockSliceInExitSplitModeArea(displayId)) {
+            windowRoot_->ExitSplitMode(displayId);
+        } else {
+            auto property = node->GetWindowProperty();
+            node->SetWindowSizeChangeReason(WindowSizeChangeReason::DRAG_END);
+            property->SetRequestRect(property->GetWindowRect());
+            WMError res = windowRoot_->UpdateWindowNode(windowId, WindowUpdateReason::UPDATE_RECT);
+            if (res == WMError::WM_OK) {
+                FlushWindowInfo(windowId);
+            }
+        }
+    }
     WMError res = windowRoot_->UpdateSizeChangeReason(windowId, WindowSizeChangeReason::DRAG_END);
     if (res != WMError::WM_OK) {
         return res;

wmserver/src/window_layout_policy.cpp

@@ -47,6 +47,11 @@ void WindowLayoutPolicy::Reorder()
     WLOGFI("WindowLayoutPolicy::Reorder");
 }
 
+std::vector<int32_t> WindowLayoutPolicy::GetExitSplitPoints(DisplayId displayId) const
+{
+    return {};
+}
+
 void WindowLayoutPolicy::LimitWindowToBottomRightCorner(const sptr<WindowNode>& node)
 {
     Rect windowRect = node->GetRequestRect();
@@ -342,7 +347,8 @@ void WindowLayoutPolicy::UpdateClientRectAndResetReason(const sptr<WindowNode>&
             "%{public}u", node->GetWindowId(), winRect.posX_, winRect.posY_, winRect.width_, winRect.height_, reason);
         node->GetWindowToken()->UpdateWindowRect(winRect, node->GetDecoStatus(), reason);
     }
-    if (reason == WindowSizeChangeReason::DRAG || reason == WindowSizeChangeReason::DRAG_END) {
+    if ((reason == WindowSizeChangeReason::DRAG || reason == WindowSizeChangeReason::DRAG_END) &&
+        (node->GetWindowType() != WindowType::WINDOW_TYPE_DOCK_SLICE)) {
         node->ResetWindowSizeChangeReason();
     }
 }
@@ -968,6 +974,11 @@ Rect WindowLayoutPolicy::GetDisplayGroupRect() const
     return displayGroupRect_;
 }
 
+void WindowLayoutPolicy::SetSplitRatioConfig(SplitRatioConfig splitRatioConfig)
+{
+    splitRatioConfig_ = splitRatioConfig;
+}
+
 void WindowLayoutPolicy::SetFloatingWindowLimitsConfig(const FloatingWindowLimitsConfig& floatingWindowLimitsConfig)
 {
     floatingWindowLimitsConfig_ = floatingWindowLimitsConfig;

wmserver/src/window_layout_policy_cascade.cpp

@@ -99,6 +99,7 @@ void WindowLayoutPolicyCascade::LayoutWindowNode(const sptr<WindowNode>& node)
             UpdateLimitRect(node, limitRectMap_[displayId]);
             UpdateSplitLimitRect(limitRectMap_[displayId], primaryLimitRect);
             UpdateSplitLimitRect(limitRectMap_[displayId], secondaryLimitRect);
+            UpdateSplitRatioPoints(displayId);
             UpdateDisplayGroupLimitRect_();
             WLOGFI("priLimitRect: %{public}d %{public}d %{public}u %{public}u, " \
                 "secLimitRect: %{public}d %{public}d %{public}u %{public}u", primaryLimitRect.posX_,
@@ -134,6 +135,11 @@ void WindowLayoutPolicyCascade::RemoveWindowNode(const sptr<WindowNode>& node)
     }
 }
 
+std::vector<int32_t> WindowLayoutPolicyCascade::GetExitSplitPoints(DisplayId displayId) const
+{
+    return cascadeRectsMap_[displayId].exitSplitPoints_;
+}
+
 void WindowLayoutPolicyCascade::UpdateWindowNode(const sptr<WindowNode>& node, bool isAddWindow)
 {
     WM_FUNCTION_TRACE();
@@ -247,10 +253,16 @@ void WindowLayoutPolicyCascade::ApplyWindowRectConstraints(const sptr<WindowNode
 {
     WLOGFI("Before apply constraints winRect:[%{public}d, %{public}d, %{public}u, %{public}u]",
         winRect.posX_, winRect.posY_, winRect.width_, winRect.height_);
-    if (node->GetWindowType() == WindowType::WINDOW_TYPE_DOCK_SLICE) { // if divider, limit position
-        LimitMoveBounds(winRect, node->GetDisplayId());
+    auto reason = node->GetWindowSizeChangeReason();
+    if (node->GetWindowType() == WindowType::WINDOW_TYPE_DOCK_SLICE &&
+        reason == WindowSizeChangeReason::DRAG_END) {
+        DisplayId displayId = node->GetDisplayId();
+        if (!IsVerticalDisplay(displayId)) {
+            UpdateDockSlicePosition(displayId, winRect.posX_);
+        } else {
+            UpdateDockSlicePosition(displayId, winRect.posY_);
+        }
     }
-
     LimitFloatingWindowSize(node, displayGroupInfo_->GetDisplayRect(node->GetDisplayId()), winRect);
     LimitMainFloatingWindowPosition(node, winRect);
 
@@ -309,6 +321,7 @@ void WindowLayoutPolicyCascade::InitLimitRects(DisplayId displayId)
     limitRectMap_[displayId] = displayGroupInfo_->GetDisplayRect(displayId);
     cascadeRectsMap_[displayId].primaryLimitRect_ = cascadeRectsMap_[displayId].primaryRect_;
     cascadeRectsMap_[displayId].secondaryLimitRect_ = cascadeRectsMap_[displayId].secondaryRect_;
+    UpdateSplitRatioPoints(displayId);
 }
 
 Rect WindowLayoutPolicyCascade::GetLimitRect(const WindowMode mode, DisplayId displayId) const
@@ -333,6 +346,36 @@ Rect WindowLayoutPolicyCascade::GetDisplayRect(const WindowMode mode, DisplayId
     }
 }
 
+void WindowLayoutPolicyCascade::UpdateSplitRatioPoints(DisplayId displayId)
+{
+    LayoutRects& cascadeRects = cascadeRectsMap_[displayId];
+    cascadeRects.exitSplitPoints_.clear();
+    cascadeRects.splitRatioPoints_.clear();
+    cascadeRects.exitSplitPoints_.push_back(GetSplitRatioPoint(splitRatioConfig_.exitSplitRatio, displayId));
+    cascadeRects.exitSplitPoints_.push_back(GetSplitRatioPoint(1 - splitRatioConfig_.exitSplitRatio, displayId));
+    for (const auto& ratio : splitRatioConfig_.splitRatios) {
+        cascadeRects.splitRatioPoints_.push_back(GetSplitRatioPoint(ratio, displayId));
+    }
+}
+
+void WindowLayoutPolicyCascade::UpdateDockSlicePosition(DisplayId displayId, int32_t& origin) const
+{
+    const LayoutRects& cascadeRects = cascadeRectsMap_[displayId];
+    if (cascadeRects.splitRatioPoints_.size() == 0) {
+        return;
+    }
+    uint32_t minDiff = std::max(limitRectMap_[displayId].width_, limitRectMap_[displayId].height_);
+    int32_t closestPoint = origin;
+    for (const auto& elem : cascadeRects.splitRatioPoints_) {
+        uint32_t diff = (origin > elem) ? (origin - elem) : (elem - origin);
+        if (diff < minDiff) {
+            closestPoint = elem;
+            minDiff = diff;
+        }
+    }
+    origin = closestPoint;
+}
+
 void WindowLayoutPolicyCascade::UpdateSplitLimitRect(const Rect& limitRect, Rect& limitSplitRect)
 {
     Rect curLimitRect = limitSplitRect;
@@ -364,20 +407,17 @@ void WindowLayoutPolicyCascade::InitSplitRects(DisplayId displayId)
     SetSplitRect(dividerRect, displayId);
 }
 
-void WindowLayoutPolicyCascade::SetSplitRectByRatio(float ratio, DisplayId displayId)
+int32_t WindowLayoutPolicyCascade::GetSplitRatioPoint(float ratio, DisplayId displayId)
 {
-    auto& dividerRect = cascadeRectsMap_[displayId].dividerRect_;
-    const Rect& limitRect = limitRectMap_[displayId];
+    const auto& dividerRect = cascadeRectsMap_[displayId].dividerRect_;
+    const auto& limitRect = limitRectMap_[displayId];
     if (!IsVerticalDisplay(displayId)) {
-        dividerRect.posX_ = limitRect.posX_ +
+        return limitRect.posX_ +
             static_cast<uint32_t>((limitRect.width_ - dividerRect.width_) * ratio);
     } else {
-        dividerRect.posY_ = limitRect.posY_ +
+        return limitRect.posY_ +
             static_cast<uint32_t>((limitRect.height_ - dividerRect.height_) * ratio);
     }
-    WLOGFI("set dividerRect :[%{public}d, %{public}d, %{public}u, %{public}u]",
-        dividerRect.posX_, dividerRect.posY_, dividerRect.width_, dividerRect.height_);
-    SetSplitRect(dividerRect, displayId);
 }
 
 void WindowLayoutPolicyCascade::SetSplitRect(const Rect& divRect, DisplayId displayId)

wmserver/src/window_manager_config.cpp

@@ -64,7 +64,9 @@ bool WindowManagerConfig::LoadConfigXml(const std::string& configFilePath)
             continue;
         }
 
-        if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("floatingWindowLimitRatio"))) {
+        if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("floatingWindowLimitRatio")) ||
+            !xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("splitRatios")) ||
+            !xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("exitSplitRatio"))) {
             ReadFloatNumbersConfigInfo(curNodePtr);
             continue;
         }

wmserver/src/window_manager_service.cpp

@@ -192,6 +192,33 @@ int WindowManagerService::Dump(int fd, const std::vector<std::u16string>& args)
     }).get();
 }
 
+void WindowManagerService::ConfigFloatWindowLimits()
+{
+    const auto& intNumbersConfig = WindowManagerConfig::GetIntNumbersConfig();
+    const auto& floatNumbersConfig = WindowManagerConfig::GetFloatNumbersConfig();
+
+    FloatingWindowLimitsConfig floatingWindowLimitsConfig;
+    if (intNumbersConfig.count("floatingWindowLimitSize") != 0) {
+        auto numbers = intNumbersConfig.at("floatingWindowLimitSize");
+        if (numbers.size() == 4) { // 4, limitSize
+            floatingWindowLimitsConfig.maxWidth_ = static_cast<uint32_t>(numbers[0]);  // 0 max width
+            floatingWindowLimitsConfig.maxHeight_ = static_cast<uint32_t>(numbers[1]); // 1 max height
+            floatingWindowLimitsConfig.minWidth_ = static_cast<uint32_t>(numbers[2]);  // 2 min width
+            floatingWindowLimitsConfig.minHeight_ = static_cast<uint32_t>(numbers[3]); // 3 min height
+            floatingWindowLimitsConfig.isFloatingWindowLimitsConfigured_ = true;
+        }
+    }
+    if (floatNumbersConfig.count("floatingWindowLimitRatio") != 0) {
+        auto numbers = floatNumbersConfig.at("floatingWindowLimitRatio");
+        if (numbers.size() == 2) { // 2, limitRatio
+            floatingWindowLimitsConfig.maxRatio_ = static_cast<float>(numbers[0]); // 0 max ratio
+            floatingWindowLimitsConfig.minRatio_ = static_cast<float>(numbers[1]); // 1 min ratio
+            floatingWindowLimitsConfig.isFloatingWindowLimitsConfigured_ = true;
+        }
+    }
+    windowRoot_->SetFloatingWindowLimitsConfig(floatingWindowLimitsConfig);
+}
+
 void WindowManagerService::ConfigureWindowManagerService()
 {
     const auto& enableConfig = WindowManagerConfig::GetEnableConfig();
@@ -227,29 +254,18 @@ void WindowManagerService::ConfigureWindowManagerService()
         }
     }
 
-    FloatingWindowLimitsConfig floatingWindowLimitsConfig;
+    ConfigFloatWindowLimits();
 
-    if (intNumbersConfig.count("floatingWindowLimitSize") != 0) {
-        auto numbers = intNumbersConfig.at("floatingWindowLimitSize");
-        if (numbers.size() == 4) { // 4, limitSize
-            floatingWindowLimitsConfig.maxWidth_ = static_cast<uint32_t>(numbers[0]);  // 0 max width
-            floatingWindowLimitsConfig.maxHeight_ = static_cast<uint32_t>(numbers[1]); // 1 max height
-            floatingWindowLimitsConfig.minWidth_ = static_cast<uint32_t>(numbers[2]);  // 2 min width
-            floatingWindowLimitsConfig.minHeight_ = static_cast<uint32_t>(numbers[3]); // 3 min height
-            floatingWindowLimitsConfig.isFloatingWindowLimitsConfigured_ = true;
-        }
+    if (floatNumbersConfig.count("splitRatios") != 0) {
+        windowRoot_->SetSplitRatios(floatNumbersConfig.at("splitRatios"));
     }
 
-    if (floatNumbersConfig.count("floatingWindowLimitRatio") != 0) {
-        auto numbers = floatNumbersConfig.at("floatingWindowLimitRatio");
-        if (numbers.size() == 2) { // 2, limitRatio
-            floatingWindowLimitsConfig.maxRatio_ = static_cast<float>(numbers[0]); // 0 max ratio
-            floatingWindowLimitsConfig.minRatio_ = static_cast<float>(numbers[1]); // 1 min ratio
-            floatingWindowLimitsConfig.isFloatingWindowLimitsConfigured_ = true;
+    if (floatNumbersConfig.count("exitSplitRatio") != 0) {
+        auto numbers = floatNumbersConfig.at("exitSplitRatio");
+        if ((numbers.size() == 1) && numbers[0] > 0 && numbers[0] < 0.5) { // valid range (0, 0.5)
+            windowRoot_->SetExitSplitRatio(numbers[0]);
         }
     }
-
-    windowRoot_->SetFloatingWindowLimitsConfig(floatingWindowLimitsConfig);
 }
 
 void WindowManagerService::OnStop()

wmserver/src/window_node_container.cpp

@@ -42,6 +42,7 @@ namespace {
     const char DISABLE_WINDOW_ANIMATION_PATH[] = "/etc/disable_window_animation";
     constexpr uint32_t MAX_BRIGHTNESS = 255;
     constexpr uint32_t SPLIT_WINDOWS_CNT = 2;
+    constexpr uint32_t EXIT_SPLIT_POINTS_NUMBER = 2;
 }
 
 WindowNodeContainer::WindowNodeContainer(const sptr<DisplayInfo>& displayInfo, ScreenId displayGroupId)
@@ -1289,6 +1290,30 @@ bool WindowNodeContainer::IsForbidDockSliceMove(DisplayId displayId) const
     return false;
 }
 
+bool WindowNodeContainer::IsDockSliceInExitSplitModeArea(DisplayId displayId) const
+{
+    auto windowPair = displayGroupController_->GetWindowPairByDisplayId(displayId);
+    if (windowPair == nullptr) {
+        WLOGFE("window pair is nullptr");
+        return false;
+    }
+    std::vector<int32_t> exitSplitPoints = layoutPolicy_->GetExitSplitPoints(displayId);
+    if (exitSplitPoints.size() != EXIT_SPLIT_POINTS_NUMBER) {
+        return false;
+    }
+    return windowPair->IsDockSliceInExitSplitModeArea(exitSplitPoints);
+}
+
+void WindowNodeContainer::ExitSplitMode(DisplayId displayId)
+{
+    auto windowPair = displayGroupController_->GetWindowPairByDisplayId(displayId);
+    if (windowPair == nullptr) {
+        WLOGFE("window pair is nullptr");
+        return;
+    }
+    windowPair->ExitSplitMode();
+}
+
 void WindowNodeContainer::MinimizeAllAppWindows(DisplayId displayId)
 {
     WMError ret =  MinimizeAppNodeExceptOptions(MinimizeReason::MINIMIZE_ALL);

wmserver/src/window_pair.cpp

@@ -149,6 +149,49 @@ bool WindowPair::IsForbidDockSliceMove() const
     return true;
 }
 
+bool WindowPair::IsDockSliceInExitSplitModeArea(const std::vector<int32_t>& exitSplitPoints)
+{
+    if (!IsPaired()) {
+        return false;
+    }
+    int32_t dividerOrigin;
+    Rect rect = divider_->GetWindowRect();
+    if (rect.width_ < rect.height_) {
+        dividerOrigin = rect.posX_;
+    } else {
+        dividerOrigin = rect.posY_; // vertical display
+    }
+    if (dividerOrigin < exitSplitPoints[0] || dividerOrigin > exitSplitPoints[1]) {
+        return true;
+    }
+    return false;
+}
+
+void WindowPair::ExitSplitMode()
+{
+    if (!IsPaired()) {
+        return;
+    }
+    Rect dividerRect = divider_->GetWindowRect();
+    sptr<WindowNode> hideWindow, fullScreenWindow;
+    bool isVertical = (dividerRect.height_ < dividerRect.width_) ? true : false;
+    if ((isVertical && (primary_->GetWindowRect().height_ < secondary_->GetWindowRect().height_)) ||
+        (!isVertical && (primary_->GetWindowRect().width_ < secondary_->GetWindowRect().width_))) {
+        hideWindow = primary_;
+        fullScreenWindow = secondary_;
+    } else {
+        hideWindow = secondary_;
+        fullScreenWindow = primary_;
+    }
+    if (WindowHelper::IsWindowModeSupported(fullScreenWindow->GetModeSupportInfo(),
+        WindowMode::WINDOW_MODE_FULLSCREEN)) {
+        fullScreenWindow->GetWindowProperty()->SetLastWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
+    }
+    MinimizeApp::AddNeedMinimizeApp(hideWindow, MinimizeReason::SPLIT_QUIT);
+    MinimizeApp::ExecuteMinimizeTargetReason(MinimizeReason::SPLIT_QUIT);
+    WLOGFI("Exit Split Mode, Minimize Window %{public}u", hideWindow->GetWindowId());
+}
+
 void WindowPair::Clear()
 {
     WLOGI("Clear window pair.");

wmserver/src/window_root.cpp

@@ -102,6 +102,7 @@ sptr<WindowNodeContainer> WindowRoot::CreateWindowNodeContainer(DisplayId displa
         return nullptr;
     }
     container->GetLayoutPolicy()->SetFloatingWindowLimitsConfig(floatingWindowLimitsConfig_);
+    container->GetLayoutPolicy()->SetSplitRatioConfig(splitRatioConfig_);
     return container;
 }
 
@@ -247,6 +248,26 @@ bool WindowRoot::IsForbidDockSliceMove(DisplayId displayId) const
     return container->IsForbidDockSliceMove(displayId);
 }
 
+bool WindowRoot::IsDockSliceInExitSplitModeArea(DisplayId displayId) const
+{
+    auto container = const_cast<WindowRoot*>(this)->GetOrCreateWindowNodeContainer(displayId);
+    if (container == nullptr) {
+        WLOGFE("can't find container");
+        return false;
+    }
+    return container->IsDockSliceInExitSplitModeArea(displayId);
+}
+
+void WindowRoot::ExitSplitMode(DisplayId displayId)
+{
+    auto container = GetOrCreateWindowNodeContainer(displayId);
+    if (container == nullptr) {
+        WLOGFE("can't find container");
+        return;
+    }
+    container->ExitSplitMode(displayId);
+}
+
 std::vector<Rect> WindowRoot::GetAvoidAreaByType(uint32_t windowId, AvoidAreaType avoidAreaType)
 {
     std::vector<Rect> avoidArea;
@@ -1155,6 +1176,28 @@ void WindowRoot::SetMaxAppWindowNumber(int windowNum)
     maxAppWindowNumber_ = windowNum;
 }
 
+void WindowRoot::SetSplitRatios(const std::vector<float>& splitRatioNumbers)
+{
+    auto& splitRatios = splitRatioConfig_.splitRatios;
+    splitRatios.clear();
+    splitRatios = splitRatioNumbers;
+    for (auto iter = splitRatios.begin(); iter != splitRatios.end();) {
+        if (*iter > 0 && *iter < 1) { // valid ratio range (0, 1)
+            iter++;
+        } else {
+            iter = splitRatios.erase(iter);
+        }
+    }
+    std::sort(splitRatios.begin(), splitRatios.end());
+    auto iter = std::unique(splitRatios.begin(), splitRatios.end());
+    splitRatios.erase(iter, splitRatios.end()); // remove duplitcate ratios
+}
+
+void WindowRoot::SetExitSplitRatio(float exitSplitRatio)
+{
+    splitRatioConfig_.exitSplitRatio = exitSplitRatio;
+}
+
 WMError WindowRoot::GetModeChangeHotZones(DisplayId displayId,
     ModeChangeHotZones& hotZones, const ModeChangeHotZonesConfig& config)
 {