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

Commit 62f735e0 authored by jorgegil@google.com's avatar jorgegil@google.com
Browse files

Persist PiP size to be restored on re-entry 

Adds support for restoring the PiP size along with its snap fraction.
Modifies PipBoundsHandler logic to use both the previous size and
position (snap fraction) when calculaing the bounds for re-entry.
Additionally, some phone-specific logic is added to ensure that the
re-entry size that is restored is the non-expanded size (i.e. the
size before the bounds are animated to expand when pip is clicked).

Bug: 143641277
Test: enter pip, move it, touch to expand, restore. Then re-enter
pip. Pip should retain its size and position.
Test: atest PinnedStackTests
Change-Id: I21b7e4bf9360cd7da9faf2015c04d12d37c0241f
parent a11e1ce8

core/java/android/view/IPinnedStackListener.aidl

+5 −5
Original line number Diff line number Diff line
@@ -67,20 +67,20 @@ oneway interface IPinnedStackListener { 
    void onActionsChanged(in ParceledListSlice actions);



    /**

     * Called by the window manager to notify the listener to save the reentry fraction,

     * Called by the window manager to notify the listener to save the reentry fraction and size,

     * typically when an Activity leaves PiP (picture-in-picture) mode to fullscreen.

     * {@param componentName} represents the application component of PiP window

     * while {@param bounds} is the current PiP bounds used to calculate the

     * reentry snap fraction.

     * reentry snap fraction and size.

     */

    void onSaveReentrySnapFraction(in ComponentName componentName, in Rect bounds);

    void onSaveReentryBounds(in ComponentName componentName, in Rect bounds);



    /**

     * Called by the window manager to notify the listener to reset saved reentry fraction,

     * Called by the window manager to notify the listener to reset saved reentry fraction and size,

     * typically when an Activity enters PiP (picture-in-picture) mode from fullscreen.

     * {@param componentName} represents the application component of PiP window.

     */

    void onResetReentrySnapFraction(in ComponentName componentName);

    void onResetReentryBounds(in ComponentName componentName);



    /**

     * Called when the window manager has detected change on DisplayInfo,  or

core/java/com/android/internal/policy/PipSnapAlgorithm.java

+22 −0
Original line number Diff line number Diff line
@@ -359,6 +359,28 @@ public class PipSnapAlgorithm { 
        return new Size(width, height);

    }



    /**

     * @return the adjusted size so that it conforms to the given aspectRatio, ensuring that the

     * minimum edge is at least minEdgeSize.

     */

    public Size getSizeForAspectRatio(Size size, float aspectRatio, float minEdgeSize) {

        final int smallestSize = Math.min(size.getWidth(), size.getHeight());

        final int minSize = (int) Math.max(minEdgeSize, smallestSize);



        final int width;

        final int height;

        if (aspectRatio <= 1) {

            // Portrait, width is the minimum size.

            width = minSize;

            height = Math.round(width / aspectRatio);

        } else {

            // Landscape, height is the minimum size

            height = minSize;

            width = Math.round(height * aspectRatio);

        }

        return new Size(width, height);

    }



    /**

     * @return the closest point in {@param points} to the given {@param x} and {@param y}.

     */

packages/SystemUI/shared/src/com/android/systemui/shared/system/PinnedStackListenerForwarder.java

+6 −6
Original line number Diff line number Diff line
@@ -83,16 +83,16 @@ public class PinnedStackListenerForwarder extends IPinnedStackListener.Stub { 
    }



    @Override

    public void onSaveReentrySnapFraction(ComponentName componentName, Rect bounds) {

    public void onSaveReentryBounds(ComponentName componentName, Rect bounds) {

        for (PinnedStackListener listener : mListeners) {

            listener.onSaveReentrySnapFraction(componentName, bounds);

            listener.onSaveReentryBounds(componentName, bounds);

        }

    }



    @Override

    public void onResetReentrySnapFraction(ComponentName componentName) {

    public void onResetReentryBounds(ComponentName componentName) {

        for (PinnedStackListener listener : mListeners) {

            listener.onResetReentrySnapFraction(componentName);

            listener.onResetReentryBounds(componentName);

        }

    }
@@ -140,9 +140,9 @@ public class PinnedStackListenerForwarder extends IPinnedStackListener.Stub { 


        public void onActionsChanged(ParceledListSlice actions) {}



        public void onSaveReentrySnapFraction(ComponentName componentName, Rect bounds) {}

        public void onSaveReentryBounds(ComponentName componentName, Rect bounds) {}



        public void onResetReentrySnapFraction(ComponentName componentName) {}

        public void onResetReentryBounds(ComponentName componentName) {}



        public void onDisplayInfoChanged(DisplayInfo displayInfo) {}

packages/SystemUI/src/com/android/systemui/pip/PipBoundsHandler.java

+34 −23
Original line number Diff line number Diff line
@@ -64,6 +64,7 @@ public class PipBoundsHandler { 
    private IPinnedStackController mPinnedStackController;

    private ComponentName mLastPipComponentName;

    private float mReentrySnapFraction = INVALID_SNAP_FRACTION;

    private Size mReentrySize = null;



    private float mDefaultAspectRatio;

    private float mMinAspectRatio;
@@ -162,7 +163,7 @@ public class PipBoundsHandler { 
    public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds,

            Rect animatingBounds, DisplayInfo displayInfo) {

        getInsetBounds(insetBounds);

        final Rect defaultBounds = getDefaultBounds(INVALID_SNAP_FRACTION);

        final Rect defaultBounds = getDefaultBounds(INVALID_SNAP_FRACTION, null);

        normalBounds.set(defaultBounds);

        if (animatingBounds.isEmpty()) {

            animatingBounds.set(defaultBounds);
@@ -175,26 +176,28 @@ public class PipBoundsHandler { 
    }



    /**

     * Responds to IPinnedStackListener on saving reentry snap fraction

     * Responds to IPinnedStackListener on saving reentry snap fraction and size

     * for a given {@link ComponentName}.

     */

    public void onSaveReentrySnapFraction(ComponentName componentName, Rect bounds) {

    public void onSaveReentryBounds(ComponentName componentName, Rect bounds) {

        mReentrySnapFraction = getSnapFraction(bounds);

        mReentrySize = new Size(bounds.width(), bounds.height());

        mLastPipComponentName = componentName;

    }



    /**

     * Responds to IPinnedStackListener on resetting reentry snap fraction

     * Responds to IPinnedStackListener on resetting reentry snap fraction and size

     * for a given {@link ComponentName}.

     */

    public void onResetReentrySnapFraction(ComponentName componentName) {

    public void onResetReentryBounds(ComponentName componentName) {

        if (componentName.equals(mLastPipComponentName)) {

            onResetReentrySnapFractionUnchecked();

            onResetReentryBoundsUnchecked();

        }

    }



    private void onResetReentrySnapFractionUnchecked() {

    private void onResetReentryBoundsUnchecked() {

        mReentrySnapFraction = INVALID_SNAP_FRACTION;

        mReentrySize = null;

        mLastPipComponentName = null;

    }
@@ -233,7 +236,7 @@ public class PipBoundsHandler { 
    public void onPrepareAnimation(Rect sourceRectHint, float aspectRatio, Rect bounds) {

        final Rect destinationBounds;

        if (bounds == null) {

            destinationBounds = getDefaultBounds(mReentrySnapFraction);

            destinationBounds = getDefaultBounds(mReentrySnapFraction, mReentrySize);

        } else {

            destinationBounds = new Rect(bounds);

        }
@@ -245,7 +248,7 @@ public class PipBoundsHandler { 
            return;

        }

        mAspectRatio = aspectRatio;

        onResetReentrySnapFractionUnchecked();

        onResetReentryBoundsUnchecked();

        try {

            mPinnedStackController.startAnimation(destinationBounds, sourceRectHint,

                    -1 /* animationDuration */);
@@ -269,13 +272,14 @@ public class PipBoundsHandler { 
     */

    private void transformBoundsToAspectRatio(Rect stackBounds, float aspectRatio,

            boolean useCurrentMinEdgeSize) {

        // Save the snap fraction, calculate the aspect ratio based on screen size



        // Save the snap fraction and adjust the size based on the new aspect ratio.

        final float snapFraction = mSnapAlgorithm.getSnapFraction(stackBounds,

                getMovementBounds(stackBounds));



        final int minEdgeSize = useCurrentMinEdgeSize ? mCurrentMinSize : mDefaultMinSize;

        final Size size = mSnapAlgorithm.getSizeForAspectRatio(aspectRatio, minEdgeSize,

                mDisplayInfo.logicalWidth, mDisplayInfo.logicalHeight);

        final Size size = mSnapAlgorithm.getSizeForAspectRatio(

                new Size(stackBounds.width(), stackBounds.height()), aspectRatio, minEdgeSize);



        final int left = (int) (stackBounds.centerX() - size.getWidth() / 2f);

        final int top = (int) (stackBounds.centerY() - size.getHeight() / 2f);

        stackBounds.set(left, top, left + size.getWidth(), top + size.getHeight());
@@ -286,21 +290,20 @@ public class PipBoundsHandler { 
    }



    /**

     * @return the default bounds to show the PIP, if a {@param snapFraction} is provided, then it

     * will apply the default bounds to the provided snap fraction.

     * @return the default bounds to show the PIP, if a {@param snapFraction} and {@param size} are

     * provided, then it will apply the default bounds to the provided snap fraction and size.

     */

    private Rect getDefaultBounds(float snapFraction) {

        final Rect insetBounds = new Rect();

        getInsetBounds(insetBounds);



    private Rect getDefaultBounds(float snapFraction, Size size) {

        final Rect defaultBounds = new Rect();

        final Size size = mSnapAlgorithm.getSizeForAspectRatio(mDefaultAspectRatio,

                mDefaultMinSize, mDisplayInfo.logicalWidth, mDisplayInfo.logicalHeight);

        if (snapFraction != INVALID_SNAP_FRACTION) {

        if (snapFraction != INVALID_SNAP_FRACTION && size != null) {

            defaultBounds.set(0, 0, size.getWidth(), size.getHeight());

            final Rect movementBounds = getMovementBounds(defaultBounds);

            mSnapAlgorithm.applySnapFraction(defaultBounds, movementBounds, snapFraction);

        } else {

            final Rect insetBounds = new Rect();

            getInsetBounds(insetBounds);

            size = mSnapAlgorithm.getSizeForAspectRatio(mDefaultAspectRatio,

                    mDefaultMinSize, mDisplayInfo.logicalWidth, mDisplayInfo.logicalHeight);

            Gravity.apply(mDefaultStackGravity, size.getWidth(), size.getHeight(), insetBounds,

                    0, Math.max(mIsImeShowing ? mImeHeight : 0,

                            mIsShelfShowing ? mShelfHeight : 0),
@@ -364,10 +367,18 @@ public class PipBoundsHandler { 
     * @return the default snap fraction to apply instead of the default gravity when calculating

     *         the default stack bounds when first entering PiP.

     */

    private float getSnapFraction(Rect stackBounds) {

    public float getSnapFraction(Rect stackBounds) {

        return mSnapAlgorithm.getSnapFraction(stackBounds, getMovementBounds(stackBounds));

    }



    /**

     * Applies the given snap fraction to the given stack bounds.

     */

    public void applySnapFraction(Rect stackBounds, float snapFraction) {

        final Rect movementBounds = getMovementBounds(stackBounds);

        mSnapAlgorithm.applySnapFraction(stackBounds, movementBounds, snapFraction);

    }



    /**

     * @return the pixels for a given dp value.

     */

packages/SystemUI/src/com/android/systemui/pip/phone/PipManager.java

+17 −4
Original line number Diff line number Diff line
@@ -65,6 +65,7 @@ public class PipManager implements BasePipManager { 
    private final DisplayInfo mTmpDisplayInfo = new DisplayInfo();

    private final Rect mTmpInsetBounds = new Rect();

    private final Rect mTmpNormalBounds = new Rect();

    private final Rect mReentryBounds = new Rect();



    private PipBoundsHandler mPipBoundsHandler;

    private InputConsumerController mInputConsumerController;
@@ -164,13 +165,25 @@ public class PipManager implements BasePipManager { 
        }



        @Override

        public void onSaveReentrySnapFraction(ComponentName componentName, Rect bounds) {

            mHandler.post(() -> mPipBoundsHandler.onSaveReentrySnapFraction(componentName, bounds));

        public void onSaveReentryBounds(ComponentName componentName, Rect bounds) {

            mHandler.post(() -> {

                // On phones, the expansion animation that happens on pip tap before restoring

                // to fullscreen makes it so that the bounds received here are the expanded

                // bounds. We want to restore to the unexpanded bounds when re-entering pip,

                // so we save the bounds before expansion (normal) instead of the current

                // bounds.

                mReentryBounds.set(mTouchHandler.getNormalBounds());

                // Apply the snap fraction of the current bounds to the normal bounds.

                float snapFraction = mPipBoundsHandler.getSnapFraction(bounds);

                mPipBoundsHandler.applySnapFraction(mReentryBounds, snapFraction);

                // Save reentry bounds (normal non-expand bounds with current position applied).

                mPipBoundsHandler.onSaveReentryBounds(componentName, mReentryBounds);

            });

        }



        @Override

        public void onResetReentrySnapFraction(ComponentName componentName) {

            mHandler.post(() -> mPipBoundsHandler.onResetReentrySnapFraction(componentName));

        public void onResetReentryBounds(ComponentName componentName) {

            mHandler.post(() -> mPipBoundsHandler.onResetReentryBounds(componentName));

        }



        @Override