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

Commit 15ad49fb authored by chaviw's avatar chaviw
Browse files

Added VISIBLE_FOR_USER flag for policy visibility 

Modified mPolicyVisibility so its not longer a boolean but a bitwise-or
of flags to determine policy visibility. This allows separating each visibility
policy into its own flag to ensure they don't overwrite each other. When
checking visibility, it will check that all the bits are set.

To fix the issue with switching users, added a flag VISIBLE_FOR_USER.
When calling switchUser, VISIBLE_FOR_USER will get added or removed from
mPolicyVisibility bitwise variable.

Fixes: 130700429
Test: Switch user works correctly
Test: WindowStateTests
Test: WindowStateTests#testVisibilityChangeSwitchUser

Change-Id: Ic23205eb103e2b434f4e3f274696ae1606f0c474
parent 4e39cf9b

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

+4 −3
Original line number Diff line number Diff line
@@ -78,6 +78,7 @@ import static com.android.server.wm.WindowManagerService.H.NOTIFY_ACTIVITY_DRAWN 
import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_NORMAL;

import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_WILL_PLACE_SURFACES;

import static com.android.server.wm.WindowManagerService.logWithStack;

import static com.android.server.wm.WindowState.LEGACY_POLICY_VISIBILITY;

import static com.android.server.wm.WindowStateAnimator.STACK_CLIP_AFTER_ANIM;

import static com.android.server.wm.WindowStateAnimator.STACK_CLIP_BEFORE_ANIM;
@@ -638,8 +639,8 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree 
                // If we are being set visible, and the starting window is not yet displayed,

                // then make sure it doesn't get displayed.

                if (startingWindow != null && !startingWindow.isDrawnLw()) {

                    startingWindow.mPolicyVisibility = false;

                    startingWindow.mPolicyVisibilityAfterAnim = false;

                    startingWindow.clearPolicyVisibilityFlag(LEGACY_POLICY_VISIBILITY);

                    startingWindow.mLegacyPolicyVisibilityAfterAnim = false;

                }



                // We are becoming visible, so better freeze the screen with the windows that are
@@ -1932,7 +1933,7 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree 
                        + ", isAnimationSet=" + isSelfAnimating());

                if (!w.isDrawnLw()) {

                    Slog.v(TAG, "Not displayed: s=" + winAnimator.mSurfaceController

                            + " pv=" + w.mPolicyVisibility

                            + " pv=" + w.isVisibleByPolicy()

                            + " mDrawState=" + winAnimator.drawStateToString()

                            + " ph=" + w.isParentWindowHidden() + " th=" + hiddenRequested

                            + " a=" + isSelfAnimating());

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

+1 −1
Original line number Diff line number Diff line
@@ -4561,7 +4561,7 @@ class DisplayContent extends WindowContainer<DisplayContent.DisplayChildWindowCo 
                        token2.mOwnerCanManageAppTokens) ? -1 : 1;



        private final Predicate<WindowState> mGetOrientingWindow = w -> {

            if (!w.isVisibleLw() || !w.mPolicyVisibilityAfterAnim) {

            if (!w.isVisibleLw() || !w.mLegacyPolicyVisibilityAfterAnim) {

                return false;

            }

            final int req = w.mAttrs.screenOrientation;

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

+3 −4
Original line number Diff line number Diff line
@@ -29,12 +29,11 @@ import android.annotation.Nullable; 
import android.graphics.Point;

import android.graphics.Rect;

import android.util.proto.ProtoOutputStream;

import android.view.InsetsSource;

import android.view.InsetsSourceControl;

import android.view.InsetsState;

import android.view.SurfaceControl;

import android.view.SurfaceControl.Transaction;

import android.view.InsetsSource;

import android.view.InsetsSourceControl;

import android.view.ViewRootImpl;



import com.android.internal.util.function.TriConsumer;

import com.android.internal.util.function.pooled.PooledLambda;
@@ -142,7 +141,7 @@ class InsetsSourceProvider { 
                mStateController.notifyControlChanged(mControllingWin);

            }

        }

        setServerVisible(mWin.wouldBeVisibleIfPolicyIgnored() && mWin.mPolicyVisibility

        setServerVisible(mWin.wouldBeVisibleIfPolicyIgnored() && mWin.isVisibleByPolicy()

                && !mWin.mGivenInsetsPending);

    }

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

+1 −1
Original line number Diff line number Diff line
@@ -5298,7 +5298,7 @@ public class WindowManagerService extends IWindowManager.Stub 
                    ": removed=" + win.mRemoved + " visible=" + win.isVisibleLw() +

                    " mHasSurface=" + win.mHasSurface +

                    " drawState=" + win.mWinAnimator.mDrawState);

            if (win.mRemoved || !win.mHasSurface || !win.mPolicyVisibility) {

            if (win.mRemoved || !win.mHasSurface || !win.isVisibleByPolicy()) {

                // Window has been removed or hidden; no draw will now happen, so stop waiting.

                if (DEBUG_SCREEN_ON) Slog.w(TAG_WM, "Aborted waiting for drawn: " + win);

                mWaitingForDrawn.remove(win);

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

+74 −32
Original line number Diff line number Diff line
@@ -251,18 +251,33 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
    int mSeq;

    int mViewVisibility;

    int mSystemUiVisibility;



    /**

     * The visibility of the window based on policy like {@link WindowManagerPolicy}.

     * The visibility flag of the window based on policy like {@link WindowManagerPolicy}.

     * Normally set by calling {@link #showLw} and {@link #hideLw}.

     *

     * TODO: b/131253938 This will eventually be split into individual visibility policy flags.

     */

    static final int LEGACY_POLICY_VISIBILITY = 1;

    /**

     * The visibility flag that determines whether this window is visible for the current user.

     */

    boolean mPolicyVisibility = true;

    private static final int VISIBLE_FOR_USER = 1 << 1;

    private static final int POLICY_VISIBILITY_ALL = VISIBLE_FOR_USER | LEGACY_POLICY_VISIBILITY;

    /**

     * What {@link #mPolicyVisibility} should be set to after a transition animation.

     * For example, {@link #mPolicyVisibility} might true during an exit animation to hide it and

     * then set to the value of {@link #mPolicyVisibilityAfterAnim} which is false after the exit

     * animation is done.

     * The Bitwise-or of flags that contribute to visibility of the WindowState

     */

    boolean mPolicyVisibilityAfterAnim = true;

    private int mPolicyVisibility = POLICY_VISIBILITY_ALL;



    /**

     * Whether {@link #LEGACY_POLICY_VISIBILITY} flag should be set after a transition animation.

     * For example, {@link #LEGACY_POLICY_VISIBILITY} might be set during an exit animation to hide

     * it and then unset when the value of {@link #mLegacyPolicyVisibilityAfterAnim} is false

     * after the exit animation is done.

     *

     * TODO: b/131253938 Determine whether this can be changed to use a visibility flag instead.

     */

    boolean mLegacyPolicyVisibilityAfterAnim = true;

    // overlay window is hidden because the owning app is suspended

    private boolean mHiddenWhileSuspended;

    private boolean mAppOpVisibility = true;
@@ -1414,12 +1429,32 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 


    @Override

    boolean isVisible() {

        return wouldBeVisibleIfPolicyIgnored() && mPolicyVisibility

        return wouldBeVisibleIfPolicyIgnored() && isVisibleByPolicy()

                // If we don't have a provider, this window isn't used as a window generating

                // insets, so nobody can hide it over the inset APIs.

                && (mInsetProvider == null || mInsetProvider.isClientVisible());

    }



    /**

     * Ensures that all the policy visibility bits are set.

     * @return {@code true} if all flags about visiblity are set

     */

    boolean isVisibleByPolicy() {

        return (mPolicyVisibility & POLICY_VISIBILITY_ALL) == POLICY_VISIBILITY_ALL;

    }



    void clearPolicyVisibilityFlag(int policyVisibilityFlag) {

        mPolicyVisibility &= ~policyVisibilityFlag;

    }



    void setPolicyVisibilityFlag(int policyVisibilityFlag) {

        mPolicyVisibility |= policyVisibilityFlag;

    }



    private boolean isLegacyPolicyVisibility() {

        return (mPolicyVisibility & LEGACY_POLICY_VISIBILITY) != 0;

    }



    /**

     * @return {@code true} if the window would be visible if we'd ignore policy visibility,

     *         {@code false} otherwise.
@@ -1470,7 +1505,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
    boolean isVisibleOrAdding() {

        final AppWindowToken atoken = mAppToken;

        return (mHasSurface || (!mRelayoutCalled && mViewVisibility == View.VISIBLE))

                && mPolicyVisibility && !isParentWindowHidden()

                && isVisibleByPolicy() && !isParentWindowHidden()

                && (atoken == null || !atoken.hiddenRequested)

                && !mAnimatingExit && !mDestroying;

    }
@@ -1481,7 +1516,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
     * being visible.

     */

    boolean isOnScreen() {

        if (!mHasSurface || mDestroying || !mPolicyVisibility) {

        if (!mHasSurface || mDestroying || !isVisibleByPolicy()) {

            return false;

        }

        final AppWindowToken atoken = mAppToken;
@@ -1522,7 +1557,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
        }

        final boolean parentAndClientVisible = !isParentWindowHidden()

                && mViewVisibility == View.VISIBLE && !mToken.isHidden();

        return mHasSurface && mPolicyVisibility && !mDestroying

        return mHasSurface && isVisibleByPolicy() && !mDestroying

                && (parentAndClientVisible || isAnimating());

    }
@@ -1551,7 +1586,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
    @Override

    public boolean isDisplayedLw() {

        final AppWindowToken atoken = mAppToken;

        return isDrawnLw() && mPolicyVisibility

        return isDrawnLw() && isVisibleByPolicy()

                && ((!isParentWindowHidden() && (atoken == null || !atoken.hiddenRequested))

                        || isAnimating());

    }
@@ -2057,8 +2092,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
                Slog.i(TAG_WM, "  mSurfaceController=" + mWinAnimator.mSurfaceController

                        + " relayoutCalled=" + mRelayoutCalled

                        + " viewVis=" + mViewVisibility

                        + " policyVis=" + mPolicyVisibility

                        + " policyVisAfterAnim=" + mPolicyVisibilityAfterAnim

                        + " policyVis=" + isVisibleByPolicy()

                        + " policyVisAfterAnim=" + mLegacyPolicyVisibilityAfterAnim

                        + " parentHidden=" + isParentWindowHidden()

                        + " exiting=" + mAnimatingExit + " destroying=" + mDestroying);

                if (mAppToken != null) {
@@ -2192,7 +2227,9 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
        if (isHiddenFromUserLocked()) {

            if (DEBUG_VISIBILITY) Slog.w(TAG_WM, "user changing, hiding " + this

                    + ", attrs=" + mAttrs.type + ", belonging to " + mOwnerUid);

            hideLw(false);

            clearPolicyVisibilityFlag(VISIBLE_FOR_USER);

        } else {

            setPolicyVisibilityFlag(VISIBLE_FOR_USER);

        }

    }
@@ -2284,13 +2321,17 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
    }



    void checkPolicyVisibilityChange() {

        if (mPolicyVisibility != mPolicyVisibilityAfterAnim) {

        if (isLegacyPolicyVisibility() != mLegacyPolicyVisibilityAfterAnim) {

            if (DEBUG_VISIBILITY) {

                Slog.v(TAG, "Policy visibility changing after anim in " +

                        mWinAnimator + ": " + mPolicyVisibilityAfterAnim);

                        mWinAnimator + ": " + mLegacyPolicyVisibilityAfterAnim);

            }

            if (mLegacyPolicyVisibilityAfterAnim) {

                setPolicyVisibilityFlag(LEGACY_POLICY_VISIBILITY);

            } else {

                clearPolicyVisibilityFlag(LEGACY_POLICY_VISIBILITY);

            }

            mPolicyVisibility = mPolicyVisibilityAfterAnim;

            if (!mPolicyVisibility) {

            if (!isVisibleByPolicy()) {

                mWinAnimator.hide("checkPolicyVisibilityChange");

                if (isFocused()) {

                    if (DEBUG_FOCUS_LIGHT) Slog.i(TAG,
@@ -2531,7 +2572,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
    }



    boolean showLw(boolean doAnimation, boolean requestAnim) {

        if (mPolicyVisibility && mPolicyVisibilityAfterAnim) {

        if (isLegacyPolicyVisibility() && mLegacyPolicyVisibilityAfterAnim) {

            // Already showing.

            return false;

        }
@@ -2558,18 +2599,18 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
        if (DEBUG_VISIBILITY) Slog.v(TAG, "Policy visibility true: " + this);

        if (doAnimation) {

            if (DEBUG_VISIBILITY) Slog.v(TAG, "doAnimation: mPolicyVisibility="

                    + mPolicyVisibility + " animating=" + isAnimating());

                    + isLegacyPolicyVisibility() + " animating=" + isAnimating());

            if (!mToken.okToAnimate()) {

                doAnimation = false;

            } else if (mPolicyVisibility && !isAnimating()) {

            } else if (isLegacyPolicyVisibility() && !isAnimating()) {

                // Check for the case where we are currently visible and

                // not animating; we do not want to do animation at such a

                // point to become visible when we already are.

                doAnimation = false;

            }

        }

        mPolicyVisibility = true;

        mPolicyVisibilityAfterAnim = true;

        setPolicyVisibilityFlag(LEGACY_POLICY_VISIBILITY);

        mLegacyPolicyVisibilityAfterAnim = true;

        if (doAnimation) {

            mWinAnimator.applyAnimationLocked(TRANSIT_ENTER, true);

        }
@@ -2593,7 +2634,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
                doAnimation = false;

            }

        }

        boolean current = doAnimation ? mPolicyVisibilityAfterAnim : mPolicyVisibility;

        boolean current =

                doAnimation ? mLegacyPolicyVisibilityAfterAnim : isLegacyPolicyVisibility();

        if (!current) {

            // Already hiding.

            return false;
@@ -2604,11 +2646,11 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
                doAnimation = false;

            }

        }

        mPolicyVisibilityAfterAnim = false;

        mLegacyPolicyVisibilityAfterAnim = false;

        final boolean isFocused = isFocused();

        if (!doAnimation) {

            if (DEBUG_VISIBILITY) Slog.v(TAG, "Policy visibility false: " + this);

            mPolicyVisibility = false;

            clearPolicyVisibilityFlag(LEGACY_POLICY_VISIBILITY);

            // Window is no longer visible -- make sure if we were waiting

            // for it to be displayed before enabling the display, that

            // we allow the display to be enabled now.
@@ -3443,11 +3485,11 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
            pw.println(prefix + "mSeq=" + mSeq

                    + " mSystemUiVisibility=0x" + Integer.toHexString(mSystemUiVisibility));

        }

        if (!mPolicyVisibility || !mPolicyVisibilityAfterAnim || !mAppOpVisibility

        if (!isVisibleByPolicy() || !mLegacyPolicyVisibilityAfterAnim || !mAppOpVisibility

                || isParentWindowHidden() || mPermanentlyHidden || mForceHideNonSystemOverlayWindow

                || mHiddenWhileSuspended) {

            pw.println(prefix + "mPolicyVisibility=" + mPolicyVisibility

                    + " mPolicyVisibilityAfterAnim=" + mPolicyVisibilityAfterAnim

            pw.println(prefix + "mPolicyVisibility=" + isVisibleByPolicy()

                    + " mLegacyPolicyVisibilityAfterAnim=" + mLegacyPolicyVisibilityAfterAnim

                    + " mAppOpVisibility=" + mAppOpVisibility

                    + " parentHidden=" + isParentWindowHidden()

                    + " mPermanentlyHidden=" + mPermanentlyHidden
@@ -3904,7 +3946,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
                    + ": mDrawState=" + mWinAnimator.drawStateToString()

                    + " readyForDisplay=" + isReadyForDisplay()

                    + " starting=" + (mAttrs.type == TYPE_APPLICATION_STARTING)

                    + " during animation: policyVis=" + mPolicyVisibility

                    + " during animation: policyVis=" + isVisibleByPolicy()

                    + " parentHidden=" + isParentWindowHidden()

                    + " tok.hiddenRequested="

                    + (mAppToken != null && mAppToken.hiddenRequested)
@@ -4313,7 +4355,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP 
                    + ", animating=" + isAnimating());

            if (!isDrawnLw()) {

                Slog.v(TAG, "Not displayed: s=" + mWinAnimator.mSurfaceController

                        + " pv=" + mPolicyVisibility

                        + " pv=" + isVisibleByPolicy()

                        + " mDrawState=" + mWinAnimator.mDrawState

                        + " ph=" + isParentWindowHidden()

                        + " th=" + (mAppToken != null ? mAppToken.hiddenRequested : false)