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

Commit c91d1c3e authored by Robert Carr's avatar Robert Carr
Browse files

Pinned stack animation: Trigger window preservation when dropping shadows. 

When resizing from smaller to large we go in two phases. First we resize to large + insets
so that we can scale up without pixelation. Then once we have reached our target we remove
the insets. As pointed out in the previous CL we don't want the window preservation
mechanism for the first size change, but it is perfect for removing the shadows. Otherwise
we have an issue where the client jumps, as when the shadows are removed we need to update
the position in synchronization with the client drawing.

Bug: 35396882
Test: Move skeleton app to fullscreen and verify no position jump at end.
Change-Id: I87eaf866f5a5ed058844670eeadffc34c061a378
parent 8f0a3ad8

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

+1 −64
Original line number Diff line number Diff line
@@ -1984,7 +1984,7 @@ public class WindowManagerService extends IWindowManager.Stub 
            if (viewVisibility == View.VISIBLE &&

                    (win.mAppToken == null || win.mAttrs.type == TYPE_APPLICATION_STARTING

                            || !win.mAppToken.clientHidden)) {

                result = relayoutVisibleWindow(outConfig, result, win, winAnimator, attrChanges,

                result = win.relayoutVisibleWindow(outConfig, result, attrChanges,

                        oldVisibility);

                try {

                    result = createSurfaceControl(outSurface, result, win, winAnimator);
@@ -2202,69 +2202,6 @@ public class WindowManagerService extends IWindowManager.Stub 
        return result;

    }



    private int relayoutVisibleWindow(Configuration outConfig, int result, WindowState win,

            WindowStateAnimator winAnimator, int attrChanges, int oldVisibility) {

        result |= !win.isVisibleLw() ? WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME : 0;

        if (win.mAnimatingExit) {

            Slog.d(TAG, "relayoutVisibleWindow: " + win + " mAnimatingExit=true, mRemoveOnExit="

                    + win.mRemoveOnExit + ", mDestroying=" + win.mDestroying);



            winAnimator.cancelExitAnimationForNextAnimationLocked();

            win.mAnimatingExit = false;

        }

        if (win.mDestroying) {

            win.mDestroying = false;

            mDestroySurface.remove(win);

        }

        if (oldVisibility == View.GONE) {

            winAnimator.mEnterAnimationPending = true;

        }



        win.mLastVisibleLayoutRotation = mRotation;



        winAnimator.mEnteringAnimation = true;

        if ((result & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {

            win.prepareWindowToDisplayDuringRelayout(outConfig);

        }

        if ((attrChanges & LayoutParams.FORMAT_CHANGED) != 0) {

            // If the format can't be changed in place, preserve the old surface until the app draws

            // on the new one. This prevents blinking when we change elevation of freeform and

            // pinned windows.

            if (!winAnimator.tryChangeFormatInPlaceLocked()) {

                winAnimator.preserveSurfaceLocked();

                result |= RELAYOUT_RES_SURFACE_CHANGED

                        | WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME;

            }

        }



        // If we're starting a drag-resize, we'll be changing the surface size as well as

        // notifying the client to render to with an offset from the surface's top-left.

        if (win.isDragResizeChanged() || win.isResizedWhileNotDragResizing()) {

            win.setDragResizing();

            win.setResizedWhileNotDragResizing(false);

            // We can only change top level windows to the full-screen surface when

            // resizing (as we only have one full-screen surface). So there is no need

            // to preserve and destroy windows which are attached to another, they

            // will keep their surface and its size may change over time.

            if (win.mHasSurface && !win.isChildWindow()) {

                winAnimator.preserveSurfaceLocked();

                result |= WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME;

            }

        }

        final boolean freeformResizing = win.isDragResizing()

                && win.getResizeMode() == DRAG_RESIZE_MODE_FREEFORM;

        final boolean dockedResizing = win.isDragResizing()

                && win.getResizeMode() == DRAG_RESIZE_MODE_DOCKED_DIVIDER;

        result |= freeformResizing ? WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_FREEFORM : 0;

        result |= dockedResizing ? WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_DOCKED : 0;

        if (win.isAnimatingWithSavedSurface()) {

            // If we're animating with a saved surface now, request client to report draw.

            // We still need to know when the real thing is drawn.

            result |= WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME;

        }

        return result;

    }



    public void performDeferredDestroyWindow(Session session, IWindow client) {

        long origId = Binder.clearCallingIdentity();

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

+83 −0
Original line number Diff line number Diff line
@@ -40,6 +40,7 @@ import static android.view.WindowManager.LayoutParams.FLAG_SECURE; 
import static android.view.WindowManager.LayoutParams.FLAG_SHOW_WALLPAPER;

import static android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED;

import static android.view.WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;

import static android.view.WindowManager.LayoutParams.FORMAT_CHANGED;

import static android.view.WindowManager.LayoutParams.LAST_SUB_WINDOW;

import static android.view.WindowManager.LayoutParams.MATCH_PARENT;

import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
@@ -56,6 +57,10 @@ import static android.view.WindowManager.LayoutParams.TYPE_DRAWN_APPLICATION; 
import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;

import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG;

import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER;

import static android.view.WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_DOCKED;

import static android.view.WindowManagerGlobal.RELAYOUT_RES_DRAG_RESIZING_FREEFORM;

import static android.view.WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME;

import static android.view.WindowManagerGlobal.RELAYOUT_RES_SURFACE_CHANGED;

import static android.view.WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER;

import static android.view.WindowManagerPolicy.TRANSIT_ENTER;

import static android.view.WindowManagerPolicy.TRANSIT_EXIT;
@@ -539,6 +544,12 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 


    private static final Region sEmptyRegion = new Region();



    /**

     * Surface insets from the previous call to relayout(), used to track

     * if we are changing the Surface insets.

     */

    final Rect mLastSurfaceInsets = new Rect();



    /**

     * Compares two window sub-layers and returns -1 if the first is lesser than the second in terms

     * of z-order and 1 otherwise.
@@ -4296,6 +4307,78 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
                -mAttrs.surfaceInsets.bottom);

    }



    boolean surfaceInsetsChanging() {

        return !mLastSurfaceInsets.equals(mAttrs.surfaceInsets);

    }



    int relayoutVisibleWindow(Configuration outConfig, int result,

            int attrChanges, int oldVisibility) {

        result |= !isVisibleLw() ? RELAYOUT_RES_FIRST_TIME : 0;

        if (mAnimatingExit) {

            Slog.d(TAG, "relayoutVisibleWindow: " + this + " mAnimatingExit=true, mRemoveOnExit="

                    + mRemoveOnExit + ", mDestroying=" + mDestroying);



            mWinAnimator.cancelExitAnimationForNextAnimationLocked();

            mAnimatingExit = false;

        }

        if (mDestroying) {

            mDestroying = false;

            mService.mDestroySurface.remove(this);

        }

        if (oldVisibility == View.GONE) {

            mWinAnimator.mEnterAnimationPending = true;

        }



        mLastVisibleLayoutRotation = mService.mRotation;



        mWinAnimator.mEnteringAnimation = true;

        if ((result & RELAYOUT_RES_FIRST_TIME) != 0) {

            prepareWindowToDisplayDuringRelayout(outConfig);

        }

        if ((attrChanges & FORMAT_CHANGED) != 0) {

            // If the format can't be changed in place, preserve the old surface until the app draws

            // on the new one. This prevents blinking when we change elevation of freeform and

            // pinned windows.

            if (!mWinAnimator.tryChangeFormatInPlaceLocked()) {

                mWinAnimator.preserveSurfaceLocked();

                result |= RELAYOUT_RES_SURFACE_CHANGED

                        | RELAYOUT_RES_FIRST_TIME;

            }

        }



        // When we change the Surface size, in scenarios which may require changing

        // the surface position in sync with the resize, we use a preserved surface

        // so we can freeze it while waiting for the client to report draw on the newly

        // sized surface.

        if (isDragResizeChanged() || isResizedWhileNotDragResizing()

                || surfaceInsetsChanging()) {

            mLastSurfaceInsets.set(mAttrs.surfaceInsets);



            setDragResizing();

            setResizedWhileNotDragResizing(false);

            // We can only change top level windows to the full-screen surface when

            // resizing (as we only have one full-screen surface). So there is no need

            // to preserve and destroy windows which are attached to another, they

            // will keep their surface and its size may change over time.

            if (mHasSurface && !isChildWindow()) {

                mWinAnimator.preserveSurfaceLocked();

                result |= RELAYOUT_RES_FIRST_TIME;

            }

        }

        final boolean freeformResizing = isDragResizing()

                && getResizeMode() == DRAG_RESIZE_MODE_FREEFORM;

        final boolean dockedResizing = isDragResizing()

                && getResizeMode() == DRAG_RESIZE_MODE_DOCKED_DIVIDER;

        result |= freeformResizing ? RELAYOUT_RES_DRAG_RESIZING_FREEFORM : 0;

        result |= dockedResizing ? RELAYOUT_RES_DRAG_RESIZING_DOCKED : 0;

        if (isAnimatingWithSavedSurface()) {

            // If we're animating with a saved surface now, request client to report draw.

            // We still need to know when the real thing is drawn.

            result |= RELAYOUT_RES_FIRST_TIME;

        }

        return result;

    }



    // TODO: Hack to work around the number of states AppWindowToken needs to access without having

    // access to its windows children. Need to investigate re-writing

    // {@link AppWindowToken#updateReportedVisibilityLocked} so this can be removed.