Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 587497bc authored by HQ Liu's avatar HQ Liu
Browse files

Set windowing mode in TDA instead of DisplayContent 

Set the windowing mode in TaskDisplayArea. Earlier found that because
the windowing mode is set in DisplayContent, all WindowContainres under
the DisplayContent will inherit the new windowing mode. However, for
system windows, their windowing mode should always been fullscreen.
Setting the windowing mode in TDA can fix the issue. Using this new
method instead of resolving the system window windowing modes in
WindowToken.

Bug: b/241168290
Test: services/tests/wmtests
Change-Id: I3876020cf06f6bfe6d88431bc3609c7a67c833fc
parent 8df0cf45

services/core/java/com/android/server/wm/DisplayContent.java

+1 −10
Original line number Diff line number Diff line
@@ -1148,6 +1148,7 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 
        mMinSizeOfResizeableTaskDp = getMinimalTaskSizeDp();

        if (DEBUG_DISPLAY) Slog.v(TAG_WM, "Creating display=" + display);



        setWindowingMode(WINDOWING_MODE_FULLSCREEN);

        mWmService.mDisplayWindowSettings.applySettingsToDisplayLocked(this);

    }
@@ -2669,16 +2670,6 @@ class DisplayContent extends RootDisplayArea implements WindowManagerPolicy.Disp 
        }

    }



    @Override

    public void setWindowingMode(int windowingMode) {

        // Intentionally call onRequestedOverrideConfigurationChanged() directly to change windowing

        // mode and display windowing mode atomically.

        mTmpConfiguration.setTo(getRequestedOverrideConfiguration());

        mTmpConfiguration.windowConfiguration.setWindowingMode(windowingMode);

        mTmpConfiguration.windowConfiguration.setDisplayWindowingMode(windowingMode);

        onRequestedOverrideConfigurationChanged(mTmpConfiguration);

    }



    @Override

    void setDisplayWindowingMode(int windowingMode) {

        setWindowingMode(windowingMode);

services/core/java/com/android/server/wm/DisplayWindowSettings.java

+11 −5
Original line number Diff line number Diff line
@@ -150,7 +150,10 @@ class DisplayWindowSettings { 
        final SettingsProvider.SettingsEntry overrideSettings =

                mSettingsProvider.getOverrideSettings(displayInfo);

        overrideSettings.mWindowingMode = mode;

        dc.setWindowingMode(mode);

        final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();

        if (defaultTda != null) {

            defaultTda.setWindowingMode(mode);

        }

        mSettingsProvider.updateOverrideSettings(displayInfo, overrideSettings);

    }
@@ -253,8 +256,10 @@ class DisplayWindowSettings { 


        // Setting windowing mode first, because it may override overscan values later.

        final int windowingMode = getWindowingModeLocked(settings, dc);

        dc.setWindowingMode(windowingMode);



        final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();

        if (defaultTda != null) {

            defaultTda.setWindowingMode(windowingMode);

        }

        final int userRotationMode = settings.mUserRotationMode != null

                ? settings.mUserRotationMode : WindowManagerPolicy.USER_ROTATION_FREE;

        final int userRotation = settings.mUserRotation != null
@@ -311,10 +316,11 @@ class DisplayWindowSettings { 
     * changed.

     */

    boolean updateSettingsForDisplay(DisplayContent dc) {

        if (dc.getWindowingMode() != getWindowingModeLocked(dc)) {

        final TaskDisplayArea defaultTda = dc.getDefaultTaskDisplayArea();

        if (defaultTda != null && defaultTda.getWindowingMode() != getWindowingModeLocked(dc)) {

            // For the time being the only thing that may change is windowing mode, so just update

            // that.

            dc.setWindowingMode(getWindowingModeLocked(dc));

            defaultTda.setWindowingMode(getWindowingModeLocked(dc));

            return true;

        }

        return false;

services/core/java/com/android/server/wm/TaskDisplayArea.java

+11 −0
Original line number Diff line number Diff line
@@ -172,6 +172,8 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> { 
     */

    private final boolean mCanHostHomeTask;



    private final Configuration mTempConfiguration = new Configuration();



    TaskDisplayArea(DisplayContent displayContent, WindowManagerService service, String name,

                    int displayAreaFeature) {

        this(displayContent, service, name, displayAreaFeature, false /* createdByOrganizer */,
@@ -1890,6 +1892,15 @@ final class TaskDisplayArea extends DisplayArea<WindowContainer> { 
        mPreferredTopFocusableRootTask = null;

    }



    @Override

    public void setWindowingMode(int windowingMode) {

        mTempConfiguration.setTo(getRequestedOverrideConfiguration());

        WindowConfiguration tempRequestWindowConfiguration = mTempConfiguration.windowConfiguration;

        tempRequestWindowConfiguration.setWindowingMode(windowingMode);

        tempRequestWindowConfiguration.setDisplayWindowingMode(windowingMode);

        onRequestedOverrideConfigurationChanged(mTempConfiguration);

    }



    @Override

    TaskDisplayArea getTaskDisplayArea() {

        return this;

services/core/java/com/android/server/wm/TaskLaunchParamsModifier.java

+25 −18
Original line number Diff line number Diff line
@@ -137,7 +137,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        final DisplayContent display = suggestedDisplayArea.mDisplayContent;

        if (DEBUG) {

            appendLog("display-id=" + display.getDisplayId()

                    + " display-windowing-mode=" + display.getWindowingMode()

                    + " task-display-area-windowing-mode=" + suggestedDisplayArea.getWindowingMode()

                    + " suggested-display-area=" + suggestedDisplayArea);

        }
@@ -156,7 +156,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        // source is a freeform window in a fullscreen display launching an activity on the same

        // display.

        if (launchMode == WINDOWING_MODE_UNDEFINED

                && canInheritWindowingModeFromSource(display, source)) {

                && canInheritWindowingModeFromSource(display, suggestedDisplayArea, source)) {

            // The source's windowing mode may be different from its task, e.g. activity is set

            // to fullscreen and its task is pinned windowing mode when the activity is entering

            // pip.
@@ -184,7 +184,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        // is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is

        // different, we should recalculating the bounds.

        boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow = false;

        final boolean canApplyFreeformPolicy = canApplyFreeformWindowPolicy(display, launchMode);

        final boolean canApplyFreeformPolicy =

                canApplyFreeformWindowPolicy(suggestedDisplayArea, launchMode);

        if (mSupervisor.canUseActivityOptionsLaunchBounds(options)

                && (canApplyFreeformPolicy || canApplyPipWindowPolicy(launchMode))) {

            hasInitialBounds = true;
@@ -239,7 +240,8 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
                        == display.getDisplayId())) {

            // Only set windowing mode if display is in freeform. If the display is in fullscreen

            // mode we should only launch a task in fullscreen mode.

            if (currentParams.hasWindowingMode() && display.inFreeformWindowingMode()) {

            if (currentParams.hasWindowingMode()

                    && suggestedDisplayArea.inFreeformWindowingMode()) {

                launchMode = currentParams.mWindowingMode;

                fullyResolvedCurrentParam = launchMode != WINDOWING_MODE_FREEFORM;

                if (DEBUG) {
@@ -267,11 +269,11 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        // this step is to define the default policy when there is no initial bounds or a fully

        // resolved current params from callers.



        // hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay is set if the outParams.mBounds

        // hasInitialBoundsForSuggestedDisplayAreaInFreeformMode is set if the outParams.mBounds

        // is set with the suggestedDisplayArea. If it is set, but the eventual TaskDisplayArea is

        // different, we should recalcuating the bounds.

        boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay = false;

        if (display.inFreeformWindowingMode()) {

        boolean hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = false;

        if (suggestedDisplayArea.inFreeformWindowingMode()) {

            if (launchMode == WINDOWING_MODE_PINNED) {

                if (DEBUG) appendLog("picture-in-picture");

            } else if (!root.isResizeable()) {
@@ -280,7 +282,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
                    if (outParams.mBounds.isEmpty()) {

                        getTaskBounds(root, suggestedDisplayArea, layout, launchMode,

                                hasInitialBounds, outParams.mBounds);

                        hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay = true;

                        hasInitialBoundsForSuggestedDisplayAreaInFreeformMode = true;

                    }

                    if (DEBUG) appendLog("unresizable-freeform");

                } else {
@@ -290,10 +292,10 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
                }

            }

        } else {

            if (DEBUG) appendLog("non-freeform-display");

            if (DEBUG) appendLog("non-freeform-task-display-area");

        }

        // If launch mode matches display windowing mode, let it inherit from display.

        outParams.mWindowingMode = launchMode == display.getWindowingMode()

        outParams.mWindowingMode = launchMode == suggestedDisplayArea.getWindowingMode()

                ? WINDOWING_MODE_UNDEFINED : launchMode;



        if (phase == PHASE_WINDOWING_MODE) {
@@ -303,7 +305,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        // STEP 3: Finalize the display area. Here we allow WM shell route all launches that match

        // certain criteria to specific task display areas.

        final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode

                : display.getWindowingMode();

                : suggestedDisplayArea.getWindowingMode();

        TaskDisplayArea taskDisplayArea = suggestedDisplayArea;

        // If launch task display area is set in options we should just use it. We assume the

        // suggestedDisplayArea has the right one in this case.
@@ -320,14 +322,17 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
                mTmpDisplayArea = displayArea;

                return true;

            });

            // We may need to recalculate the bounds if the new TaskDisplayArea is different from

            // the suggested one we used to calculate the bounds.

            // We may need to recalculate the bounds and the windowing mode if the new

            // TaskDisplayArea is different from the suggested one we used to calculate the two

            // configurations.

            if (mTmpDisplayArea != null && mTmpDisplayArea != suggestedDisplayArea) {

                outParams.mWindowingMode = (launchMode == mTmpDisplayArea.getWindowingMode())

                        ? WINDOWING_MODE_UNDEFINED : launchMode;

                if (hasInitialBoundsForSuggestedDisplayAreaInFreeformWindow) {

                    outParams.mBounds.setEmpty();

                    getLayoutBounds(mTmpDisplayArea, root, layout, outParams.mBounds);

                    hasInitialBounds = !outParams.mBounds.isEmpty();

                } else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformDisplay) {

                } else if (hasInitialBoundsForSuggestedDisplayAreaInFreeformMode) {

                    outParams.mBounds.setEmpty();

                    getTaskBounds(root, mTmpDisplayArea, layout, launchMode,

                            hasInitialBounds, outParams.mBounds);
@@ -519,7 +524,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
    }



    private boolean canInheritWindowingModeFromSource(@NonNull DisplayContent display,

            @Nullable ActivityRecord source) {

            TaskDisplayArea suggestedDisplayArea, @Nullable ActivityRecord source) {

        if (source == null) {

            return false;

        }
@@ -527,7 +532,7 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        // There is not really any strong reason to tie the launching windowing mode and the source

        // on freeform displays. The launching windowing mode is more tied to the content of the new

        // activities.

        if (display.inFreeformWindowingMode()) {

        if (suggestedDisplayArea.inFreeformWindowingMode()) {

            return false;

        }
@@ -543,9 +548,11 @@ class TaskLaunchParamsModifier implements LaunchParamsModifier { 
        return display.getDisplayId() == source.getDisplayId();

    }



    private boolean canApplyFreeformWindowPolicy(@NonNull DisplayContent display, int launchMode) {

    private boolean canApplyFreeformWindowPolicy(@NonNull TaskDisplayArea suggestedDisplayArea,

            int launchMode) {

        return mSupervisor.mService.mSupportsFreeformWindowManagement

                && (display.inFreeformWindowingMode() || launchMode == WINDOWING_MODE_FREEFORM);

                && (suggestedDisplayArea.inFreeformWindowingMode()

                || launchMode == WINDOWING_MODE_FREEFORM);

    }



    private boolean canApplyPipWindowPolicy(int launchMode) {

services/core/java/com/android/server/wm/WindowToken.java

+0 −7
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 


package com.android.server.wm;



import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;

import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;

import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
@@ -631,12 +630,6 @@ class WindowToken extends WindowContainer<WindowState> { 
            getResolvedOverrideConfiguration().updateFrom(

                    mFixedRotationTransformState.mRotatedOverrideConfiguration);

        }

        if (getTaskDisplayArea() == null) {

            // We only defined behaviors of system windows in fullscreen mode, i.e. windows not

            // contained in a task display area.

            getResolvedOverrideConfiguration().windowConfiguration.setWindowingMode(

                    WINDOWING_MODE_FULLSCREEN);

        }

    }



    @Override