Refactor PiP logic in preparation for expanded state.
- #1: Move logic for handling IME size changes into SysUI, and only rely
on PinnedStackController to provide bounds when first entering
PiP and on rotation
- #2: Doing #1 allows us to move PipMotionHelper to SysUI completely, which
lets us aggregate the animation calls out of PipTouchHandler
- #3: Add proper callbacks to the listeners when the movement bounds
changed from config change, ime change, or aspect ratio change. This
allows SysUI to calculate the associated movement bounds for the
expanded state, and we can then remove the corresponding WM call.
It also means that SysUI is the only thing that needs to know about
the expanded state.
- #4: Fix issue where TV was getting the default bounds, not taking the
aspect ratio when the PiP was entered into account. Doing #3
allows us to report the right bounds.
- #5: Remove dead code related to edge snapping/minimizing now that they
are on by default and associated tuner setting, and controller
callbacks
Test: android.server.cts.ActivityManagerPinnedStackTests (all existing tests pass)
Change-Id: I3ef361bdf8d44094b4c0a11c70ba4db7d697fdec
Signed-off-by: Winson Chung <winsonc@google.com>
diff --git a/packages/SystemUI/res/values/strings.xml b/packages/SystemUI/res/values/strings.xml
index 363b3e2..910a504 100644
--- a/packages/SystemUI/res/values/strings.xml
+++ b/packages/SystemUI/res/values/strings.xml
@@ -1761,14 +1761,6 @@
not appear on production builds ever. -->
<string name="pip_drag_to_dismiss_summary" translatable="false">Drag to the dismiss target at the bottom of the screen to close the PIP</string>
- <!-- PIP allow minimize title. Non-translatable since it should
- not appear on production builds ever. -->
- <string name="pip_allow_minimize_title" translatable="false">Allow PIP to minimize</string>
-
- <!-- PIP allow minimize description. Non-translatable since it should
- not appear on production builds ever. -->
- <string name="pip_allow_minimize_summary" translatable="false">Allow PIP to minimize slightly offscreen</string>
-
<!-- Tuner string -->
<string name="change_theme_reboot" translatable="false">Changing the theme requires a restart.</string>
<!-- Tuner string -->
diff --git a/packages/SystemUI/res/xml/tuner_prefs.xml b/packages/SystemUI/res/xml/tuner_prefs.xml
index 94a7c07..6198ab7 100644
--- a/packages/SystemUI/res/xml/tuner_prefs.xml
+++ b/packages/SystemUI/res/xml/tuner_prefs.xml
@@ -131,12 +131,6 @@
android:summary="@string/pip_drag_to_dismiss_summary"
sysui:defValue="false" />
- <com.android.systemui.tuner.TunerSwitch
- android:key="pip_allow_minimize"
- android:title="@string/pip_allow_minimize_title"
- android:summary="@string/pip_allow_minimize_summary"
- sysui:defValue="true" />
-
</PreferenceScreen>
<PreferenceScreen
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipDismissViewController.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipDismissViewController.java
index e182176..beec137 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipDismissViewController.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipDismissViewController.java
@@ -17,18 +17,15 @@
package com.android.systemui.pip.phone;
import android.content.Context;
-import android.content.res.Resources;
import android.graphics.PixelFormat;
import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.Rect;
import android.view.Gravity;
import android.view.LayoutInflater;
-import android.view.TouchDelegate;
import android.view.View;
import android.view.View.OnLayoutChangeListener;
import android.view.WindowManager;
-import android.view.WindowManager.LayoutParams;
import android.widget.FrameLayout;
import com.android.systemui.Interpolators;
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipManager.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipManager.java
index 3df557d..f59b2a4 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipManager.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipManager.java
@@ -16,20 +16,16 @@
package com.android.systemui.pip.phone;
-import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
import static android.view.Display.DEFAULT_DISPLAY;
import android.app.ActivityManager;
-import android.app.ActivityManager.StackInfo;
-import android.app.ActivityOptions;
import android.app.IActivityManager;
import android.content.ComponentName;
import android.content.Context;
-import android.content.Intent;
import android.content.pm.ParceledListSlice;
+import android.graphics.Rect;
import android.os.Handler;
import android.os.RemoteException;
-import android.os.UserHandle;
import android.util.Log;
import android.view.IPinnedStackController;
import android.view.IPinnedStackListener;
@@ -94,7 +90,7 @@
}
}
if (expandPipToFullscreen) {
- mTouchHandler.expandPinnedStackToFullscreen();
+ mTouchHandler.getMotionHelper().expandPip();
} else {
Log.w(TAG, "Can not expand PiP to fullscreen via intent from the same package.");
}
@@ -114,28 +110,31 @@
}
@Override
- public void onBoundsChanged(boolean adjustedForIme) {
- // Do nothing
- }
-
- @Override
- public void onActionsChanged(ParceledListSlice actions) {
+ public void onImeVisibilityChanged(boolean imeVisible, int imeHeight) {
mHandler.post(() -> {
- mMenuController.setAppActions(actions);
+ mTouchHandler.onImeVisibilityChanged(imeVisible, imeHeight);
});
}
@Override
public void onMinimizedStateChanged(boolean isMinimized) {
mHandler.post(() -> {
- mTouchHandler.onMinimizedStateChanged(isMinimized);
+ mTouchHandler.setMinimizedState(isMinimized, true /* fromController */);
});
}
@Override
- public void onSnapToEdgeStateChanged(boolean isSnapToEdge) {
+ public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds,
+ boolean fromImeAdjustement) {
mHandler.post(() -> {
- mTouchHandler.onSnapToEdgeStateChanged(isSnapToEdge);
+ mTouchHandler.onMovementBoundsChanged(insetBounds, normalBounds, fromImeAdjustement);
+ });
+ }
+
+ @Override
+ public void onActionsChanged(ParceledListSlice actions) {
+ mHandler.post(() -> {
+ mMenuController.setAppActions(actions);
});
}
}
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipMediaController.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipMediaController.java
index 236f499..5a665a9 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipMediaController.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipMediaController.java
@@ -28,7 +28,6 @@
import android.content.IntentFilter;
import android.graphics.drawable.Icon;
import android.media.session.MediaController;
-import android.media.session.MediaController.TransportControls;
import android.media.session.MediaSession;
import android.media.session.MediaSessionManager;
import android.media.session.PlaybackState;
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java
new file mode 100644
index 0000000..28ab3fb
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java
@@ -0,0 +1,376 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.pip.phone;
+
+import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
+
+import static com.android.systemui.Interpolators.FAST_OUT_LINEAR_IN;
+import static com.android.systemui.Interpolators.FAST_OUT_SLOW_IN;
+import static com.android.systemui.Interpolators.LINEAR_OUT_SLOW_IN;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.RectEvaluator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.app.ActivityManager.StackInfo;
+import android.app.IActivityManager;
+import android.content.Context;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.os.Handler;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.animation.Interpolator;
+
+import com.android.internal.os.BackgroundThread;
+import com.android.internal.policy.PipSnapAlgorithm;
+import com.android.systemui.recents.misc.SystemServicesProxy;
+import com.android.systemui.statusbar.FlingAnimationUtils;
+
+/**
+ * A helper to animate and manipulate the PiP.
+ */
+public class PipMotionHelper {
+
+ private static final String TAG = "PipMotionHelper";
+
+ private static final RectEvaluator RECT_EVALUATOR = new RectEvaluator(new Rect());
+
+ private static final int DEFAULT_MOVE_STACK_DURATION = 225;
+ private static final int SNAP_STACK_DURATION = 225;
+ private static final int DISMISS_STACK_DURATION = 375;
+ private static final int SHRINK_STACK_FROM_MENU_DURATION = 175;
+ private static final int EXPAND_STACK_TO_MENU_DURATION = 175;
+ private static final int EXPAND_STACK_TO_FULLSCREEN_DURATION = 225;
+ private static final int MINIMIZE_STACK_MAX_DURATION = 200;
+
+ // The fraction of the stack width that the user has to drag offscreen to minimize the PiP
+ private static final float MINIMIZE_OFFSCREEN_FRACTION = 0.2f;
+
+ private Context mContext;
+ private IActivityManager mActivityManager;
+ private Handler mHandler;
+
+ private PipSnapAlgorithm mSnapAlgorithm;
+ private FlingAnimationUtils mFlingAnimationUtils;
+
+ private final Rect mBounds = new Rect();
+ private final Rect mStableInsets = new Rect();
+
+ private ValueAnimator mBoundsAnimator = null;
+ private ValueAnimator.AnimatorUpdateListener mUpdateBoundsListener =
+ new AnimatorUpdateListener() {
+ @Override
+ public void onAnimationUpdate(ValueAnimator animation) {
+ mBounds.set((Rect) animation.getAnimatedValue());
+ }
+ };
+
+ public PipMotionHelper(Context context, IActivityManager activityManager,
+ PipSnapAlgorithm snapAlgorithm, FlingAnimationUtils flingAnimationUtils) {
+ mContext = context;
+ mHandler = BackgroundThread.getHandler();
+ mActivityManager = activityManager;
+ mSnapAlgorithm = snapAlgorithm;
+ mFlingAnimationUtils = flingAnimationUtils;
+ onConfigurationChanged();
+ }
+
+ /**
+ * Updates whenever the configuration changes.
+ */
+ void onConfigurationChanged() {
+ mSnapAlgorithm.onConfigurationChanged();
+ SystemServicesProxy.getInstance(mContext).getStableInsets(mStableInsets);
+ }
+
+ /**
+ * Synchronizes the current bounds with the pinned stack.
+ */
+ void synchronizePinnedStackBounds() {
+ cancelAnimations();
+ try {
+ StackInfo stackInfo = mActivityManager.getStackInfo(PINNED_STACK_ID);
+ mBounds.set(stackInfo.bounds);
+ } catch (RemoteException e) {
+ Log.w(TAG, "Failed to get pinned stack bounds");
+ }
+ }
+
+ /**
+ * Tries to the move the pinned stack to the given {@param bounds}.
+ */
+ void movePip(Rect toBounds) {
+ cancelAnimations();
+ resizePipUnchecked(toBounds);
+ mBounds.set(toBounds);
+ }
+
+ /**
+ * Resizes the pinned stack back to fullscreen.
+ */
+ void expandPip() {
+ cancelAnimations();
+ mHandler.post(() -> {
+ try {
+ mActivityManager.resizeStack(PINNED_STACK_ID, null /* bounds */,
+ true /* allowResizeInDockedMode */, true /* preserveWindows */,
+ true /* animate */, EXPAND_STACK_TO_FULLSCREEN_DURATION);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Error showing PiP menu activity", e);
+ }
+ });
+ }
+
+ /**
+ * Dismisses the pinned stack.
+ */
+ void dismissPip() {
+ cancelAnimations();
+ mHandler.post(() -> {
+ try {
+ mActivityManager.removeStack(PINNED_STACK_ID);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Failed to remove PiP", e);
+ }
+ });
+ }
+
+ /**
+ * @return the PiP bounds.
+ */
+ Rect getBounds() {
+ return mBounds;
+ }
+
+ /**
+ * @return the closest minimized PiP bounds.
+ */
+ Rect getClosestMinimizedBounds(Rect stackBounds, Rect movementBounds) {
+ Point displaySize = new Point();
+ mContext.getDisplay().getRealSize(displaySize);
+ Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, stackBounds);
+ mSnapAlgorithm.applyMinimizedOffset(toBounds, movementBounds, displaySize, mStableInsets);
+ return toBounds;
+ }
+
+ /**
+ * @return whether the PiP at the current bounds should be minimized.
+ */
+ boolean shouldMinimizePip() {
+ Point displaySize = new Point();
+ mContext.getDisplay().getRealSize(displaySize);
+ if (mBounds.left < 0) {
+ float offscreenFraction = (float) -mBounds.left / mBounds.width();
+ return offscreenFraction >= MINIMIZE_OFFSCREEN_FRACTION;
+ } else if (mBounds.right > displaySize.x) {
+ float offscreenFraction = (float) (mBounds.right - displaySize.x) /
+ mBounds.width();
+ return offscreenFraction >= MINIMIZE_OFFSCREEN_FRACTION;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Flings the minimized PiP to the closest minimized snap target.
+ */
+ Rect flingToMinimizedState(float velocityY, Rect movementBounds) {
+ cancelAnimations();
+ // We currently only allow flinging the minimized stack up and down, so just lock the
+ // movement bounds to the current stack bounds horizontally
+ movementBounds = new Rect(mBounds.left, movementBounds.top, mBounds.left,
+ movementBounds.bottom);
+ Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds,
+ 0 /* velocityX */, velocityY);
+ if (!mBounds.equals(toBounds)) {
+ mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, 0, FAST_OUT_SLOW_IN,
+ mUpdateBoundsListener);
+ mFlingAnimationUtils.apply(mBoundsAnimator, 0,
+ distanceBetweenRectOffsets(mBounds, toBounds),
+ velocityY);
+ mBoundsAnimator.start();
+ }
+ return toBounds;
+ }
+
+ /**
+ * Animates the PiP to the minimized state, slightly offscreen.
+ */
+ Rect animateToClosestMinimizedState(Rect movementBounds,
+ final PipMenuActivityController menuController) {
+ cancelAnimations();
+ Rect toBounds = getClosestMinimizedBounds(mBounds, movementBounds);
+ if (!mBounds.equals(toBounds)) {
+ mBoundsAnimator = createAnimationToBounds(mBounds, toBounds,
+ MINIMIZE_STACK_MAX_DURATION, LINEAR_OUT_SLOW_IN, mUpdateBoundsListener);
+ mBoundsAnimator.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationStart(Animator animation) {
+ menuController.hideMenu();
+ }
+ });
+ mBoundsAnimator.start();
+ }
+ return toBounds;
+ }
+
+ /**
+ * Flings the PiP to the closest snap target.
+ */
+ Rect flingToSnapTarget(float velocity, float velocityX, float velocityY, Rect movementBounds) {
+ cancelAnimations();
+ Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds,
+ velocityX, velocityY);
+ if (!mBounds.equals(toBounds)) {
+ mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, 0, FAST_OUT_SLOW_IN,
+ mUpdateBoundsListener);
+ mFlingAnimationUtils.apply(mBoundsAnimator, 0,
+ distanceBetweenRectOffsets(mBounds, toBounds),
+ velocity);
+ mBoundsAnimator.start();
+ }
+ return toBounds;
+ }
+
+ /**
+ * Animates the PiP to the closest snap target.
+ */
+ Rect animateToClosestSnapTarget(Rect movementBounds) {
+ cancelAnimations();
+ Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds);
+ if (!mBounds.equals(toBounds)) {
+ mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, SNAP_STACK_DURATION,
+ FAST_OUT_SLOW_IN, mUpdateBoundsListener);
+ mBoundsAnimator.start();
+ }
+ return toBounds;
+ }
+
+ /**
+ * Animates the PiP to the expanded state to show the menu.
+ */
+ float animateToExpandedState(Rect expandedBounds, Rect movementBounds,
+ Rect expandedMovementBounds) {
+ float savedSnapFraction = mSnapAlgorithm.getSnapFraction(new Rect(mBounds), movementBounds);
+ mSnapAlgorithm.applySnapFraction(expandedBounds, expandedMovementBounds, savedSnapFraction);
+ mBoundsAnimator = createAnimationToBounds(mBounds, expandedBounds,
+ EXPAND_STACK_TO_MENU_DURATION, FAST_OUT_SLOW_IN, mUpdateBoundsListener);
+ mBoundsAnimator.start();
+ return savedSnapFraction;
+ }
+
+ /**
+ * Animates the PiP from the expanded state to the normal state after the menu is hidden.
+ */
+ void animateToUnexpandedState(Rect normalBounds, float savedSnapFraction,
+ Rect normalMovementBounds) {
+ if (savedSnapFraction >= 0f) {
+ mSnapAlgorithm.applySnapFraction(normalBounds, normalMovementBounds, savedSnapFraction);
+ mBoundsAnimator = createAnimationToBounds(mBounds, normalBounds,
+ SHRINK_STACK_FROM_MENU_DURATION, FAST_OUT_SLOW_IN, mUpdateBoundsListener);
+ mBoundsAnimator.start();
+ } else {
+ animateToClosestSnapTarget(normalMovementBounds);
+ }
+ }
+
+ /**
+ * Animates the dismissal of the PiP over the dismiss target bounds.
+ */
+ Rect animateDismissFromDrag(Rect dismissBounds) {
+ cancelAnimations();
+ Rect toBounds = new Rect(dismissBounds.centerX(),
+ dismissBounds.centerY(),
+ dismissBounds.centerX() + 1,
+ dismissBounds.centerY() + 1);
+ mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, DISMISS_STACK_DURATION,
+ FAST_OUT_LINEAR_IN, mUpdateBoundsListener);
+ mBoundsAnimator.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ dismissPip();
+ }
+ });
+ mBoundsAnimator.start();
+ return toBounds;
+ }
+
+ /**
+ * Animates the PiP to some given bounds.
+ */
+ void animateToBounds(Rect toBounds) {
+ cancelAnimations();
+ if (!mBounds.equals(toBounds)) {
+ mBoundsAnimator = createAnimationToBounds(mBounds, toBounds,
+ DEFAULT_MOVE_STACK_DURATION, FAST_OUT_LINEAR_IN, mUpdateBoundsListener);
+ mBoundsAnimator.start();
+ }
+ }
+
+ /**
+ * Cancels all existing animations.
+ */
+ void cancelAnimations() {
+ if (mBoundsAnimator != null) {
+ mBoundsAnimator.cancel();
+ mBoundsAnimator = null;
+ }
+ }
+
+ /**
+ * Creates an animation to move the PiP to give given {@param toBounds}.
+ */
+ private ValueAnimator createAnimationToBounds(Rect fromBounds, Rect toBounds, int duration,
+ Interpolator interpolator, ValueAnimator.AnimatorUpdateListener updateListener) {
+ ValueAnimator anim = ValueAnimator.ofObject(RECT_EVALUATOR, fromBounds, toBounds);
+ anim.setDuration(duration);
+ anim.setInterpolator(interpolator);
+ anim.addUpdateListener((ValueAnimator animation) -> {
+ resizePipUnchecked((Rect) animation.getAnimatedValue());
+ });
+ if (updateListener != null) {
+ anim.addUpdateListener(updateListener);
+ }
+ return anim;
+ }
+
+ /**
+ * Directly resizes the PiP to the given {@param bounds}.
+ */
+ private void resizePipUnchecked(Rect toBounds) {
+ if (!toBounds.equals(mBounds)) {
+ mHandler.post(() -> {
+ try {
+ mActivityManager.resizePinnedStack(toBounds, null /* tempPinnedTaskBounds */);
+ mBounds.set(toBounds);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Could not move pinned stack to bounds: " + toBounds, e);
+ }
+ });
+ }
+ }
+
+ /**
+ * @return the distance between points {@param p1} and {@param p2}.
+ */
+ private float distanceBetweenRectOffsets(Rect r1, Rect r2) {
+ return PointF.length(r1.left - r2.left, r1.top - r2.top);
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java
index 10393c6..b3adee0 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java
@@ -16,21 +16,10 @@
package com.android.systemui.pip.phone;
-import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
import static android.view.WindowManager.INPUT_CONSUMER_PIP;
-import static com.android.systemui.Interpolators.FAST_OUT_LINEAR_IN;
-import static com.android.systemui.Interpolators.FAST_OUT_SLOW_IN;
-import static com.android.systemui.Interpolators.LINEAR_OUT_SLOW_IN;
-
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ValueAnimator;
-import android.animation.ValueAnimator.AnimatorUpdateListener;
-import android.app.ActivityManager.StackInfo;
import android.app.IActivityManager;
import android.content.Context;
-import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.Rect;
import android.os.Handler;
@@ -47,8 +36,6 @@
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
-import com.android.internal.os.BackgroundThread;
-import com.android.internal.policy.PipMotionHelper;
import com.android.internal.policy.PipSnapAlgorithm;
import com.android.systemui.Dependency;
import com.android.systemui.statusbar.FlingAnimationUtils;
@@ -60,24 +47,15 @@
*/
public class PipTouchHandler implements TunerService.Tunable {
private static final String TAG = "PipTouchHandler";
- private static final boolean DEBUG_ALLOW_OUT_OF_BOUNDS_STACK = false;
// These values are used for metrics and should never change
private static final int METRIC_VALUE_DISMISSED_BY_TAP = 0;
private static final int METRIC_VALUE_DISMISSED_BY_DRAG = 1;
private static final String TUNER_KEY_DRAG_TO_DISMISS = "pip_drag_to_dismiss";
- private static final String TUNER_KEY_ALLOW_MINIMIZE = "pip_allow_minimize";
- private static final int SNAP_STACK_DURATION = 225;
- private static final int DISMISS_STACK_DURATION = 375;
- private static final int EXPAND_STACK_DURATION = 225;
- private static final int MINIMIZE_STACK_MAX_DURATION = 200;
private static final int SHOW_DISMISS_AFFORDANCE_DELAY = 200;
- // The fraction of the stack width that the user has to drag offscreen to minimize the PIP
- private static final float MINIMIZE_OFFSCREEN_FRACTION = 0.2f;
-
private final Context mContext;
private final IActivityManager mActivityManager;
private final IWindowManager mWindowManager;
@@ -86,34 +64,28 @@
private IPinnedStackController mPinnedStackController;
private PipInputEventReceiver mInputEventReceiver;
- private PipMenuActivityController mMenuController;
- private PipDismissViewController mDismissViewController;
+ private final PipMenuActivityController mMenuController;
+ private final PipDismissViewController mDismissViewController;
private final PipSnapAlgorithm mSnapAlgorithm;
- private PipMotionHelper mMotionHelper;
// Allow dragging the PIP to a location to close it
private boolean mEnableDragToDismiss = false;
- // Allow the PIP to be "docked" slightly offscreen
- private boolean mEnableMinimizing = true;
- private final Rect mStableInsets = new Rect();
- private final Rect mPinnedStackBounds = new Rect();
- private final Rect mBoundedPinnedStackBounds = new Rect();
- private ValueAnimator mPinnedStackBoundsAnimator = null;
- private ValueAnimator.AnimatorUpdateListener mUpdatePinnedStackBoundsListener =
- new AnimatorUpdateListener() {
- @Override
- public void onAnimationUpdate(ValueAnimator animation) {
- mPinnedStackBounds.set((Rect) animation.getAnimatedValue());
- }
- };
+ // The current movement bounds
+ private Rect mMovementBounds = new Rect();
+
+ // The reference bounds used to calculate the normal/expanded target bounds
+ private Rect mNormalBounds = new Rect();
+ private Rect mNormalMovementBounds = new Rect();
+ private Rect mExpandedBounds = new Rect();
+ private Rect mExpandedMovementBounds = new Rect();
private Handler mHandler = new Handler();
private Runnable mShowDismissAffordance = new Runnable() {
@Override
public void run() {
if (mEnableDragToDismiss) {
- mDismissViewController.showDismissTarget(mPinnedStackBounds);
+ mDismissViewController.showDismissTarget(mMotionHelper.getBounds());
}
}
};
@@ -121,13 +93,18 @@
// Behaviour states
private boolean mIsTappingThrough;
private boolean mIsMinimized;
+ private boolean mIsMenuVisible;
+ private boolean mIsImeShowing;
+ private int mImeHeight;
+ private float mSavedSnapFraction = -1f;
// Touch state
private final PipTouchState mTouchState;
private final FlingAnimationUtils mFlingAnimationUtils;
private final PipTouchGesture[] mGestures;
+ private final PipMotionHelper mMotionHelper;
- // Temporary vars
+ // Temp vars
private final Rect mTmpBounds = new Rect();
/**
@@ -160,32 +137,25 @@
private class PipMenuListener implements PipMenuActivityController.Listener {
@Override
public void onPipMenuVisibilityChanged(boolean visible) {
- if (!visible) {
- mIsTappingThrough = false;
- registerInputConsumer();
- } else {
- unregisterInputConsumer();
- }
- MetricsLogger.visibility(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_MENU,
- visible);
+ setMenuVisibilityState(visible);
}
@Override
public void onPipExpand() {
if (!mIsMinimized) {
- expandPinnedStackToFullscreen();
+ mMotionHelper.expandPip();
}
}
@Override
public void onPipMinimize() {
- setMinimizedState(true);
- animateToClosestMinimizedTarget();
+ setMinimizedStateInternal(true);
+ mMotionHelper.animateToClosestMinimizedState(mMovementBounds, mMenuController);
}
@Override
public void onPipDismiss() {
- BackgroundThread.getHandler().post(PipTouchHandler.this::dismissPinnedStack);
+ mMotionHelper.dismissPip();
MetricsLogger.action(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_DISMISSED,
METRIC_VALUE_DISMISSED_BY_TAP);
}
@@ -208,13 +178,12 @@
mGestures = new PipTouchGesture[] {
mDefaultMovementGesture
};
- mMotionHelper = new PipMotionHelper(BackgroundThread.getHandler());
+ mMotionHelper = new PipMotionHelper(mContext, mActivityManager, mSnapAlgorithm,
+ mFlingAnimationUtils);
registerInputConsumer();
- setSnapToEdge(true);
// Register any tuner settings changes
- Dependency.get(TunerService.class).addTunable(this, TUNER_KEY_DRAG_TO_DISMISS,
- TUNER_KEY_ALLOW_MINIMIZE);
+ Dependency.get(TunerService.class).addTunable(this, TUNER_KEY_DRAG_TO_DISMISS);
}
@Override
@@ -222,17 +191,12 @@
if (newValue == null) {
// Reset back to default
mEnableDragToDismiss = false;
- mEnableMinimizing = true;
- setMinimizedState(false);
return;
}
switch (key) {
case TUNER_KEY_DRAG_TO_DISMISS:
mEnableDragToDismiss = Integer.parseInt(newValue) != 0;
break;
- case TUNER_KEY_ALLOW_MINIMIZE:
- mEnableMinimizing = Integer.parseInt(newValue) != 0;
- break;
}
}
@@ -243,26 +207,70 @@
registerInputConsumer();
}
if (mIsMinimized) {
- setMinimizedState(false);
+ setMinimizedStateInternal(false);
}
}
public void onConfigurationChanged() {
- mSnapAlgorithm.onConfigurationChanged();
- updateBoundedPinnedStackBounds(false /* updatePinnedStackBounds */);
+ mMotionHelper.onConfigurationChanged();
+ mMotionHelper.synchronizePinnedStackBounds();
}
- public void onMinimizedStateChanged(boolean isMinimized) {
- if (mIsMinimized != isMinimized) {
- MetricsLogger.action(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_MINIMIZED,
- isMinimized);
+ public void onImeVisibilityChanged(boolean imeVisible, int imeHeight) {
+ mIsImeShowing = imeVisible;
+ mImeHeight = imeHeight;
+ }
+
+ public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds,
+ boolean fromImeAdjustement) {
+ // Re-calculate the expanded bounds
+ mNormalBounds = normalBounds;
+ Rect normalMovementBounds = new Rect();
+ mSnapAlgorithm.getMovementBounds(mNormalBounds, insetBounds, normalMovementBounds,
+ mIsImeShowing ? mImeHeight : 0);
+ // TODO: Figure out the expanded size policy
+ mExpandedBounds = new Rect(normalBounds);
+ Rect expandedMovementBounds = new Rect();
+ mSnapAlgorithm.getMovementBounds(mExpandedBounds, insetBounds, expandedMovementBounds,
+ mIsImeShowing ? mImeHeight : 0);
+
+
+ // If this is from an IME adjustment, then we should move the PiP so that it is not occluded
+ // by the IME
+ if (fromImeAdjustement) {
+ if (mTouchState.isUserInteracting()) {
+ // Defer the update of the current movement bounds until after the user finishes
+ // touching the screen
+ } else {
+ final Rect bounds = new Rect(mMotionHelper.getBounds());
+ final Rect toMovementBounds = mIsMenuVisible
+ ? expandedMovementBounds
+ : normalMovementBounds;
+ if (mIsImeShowing) {
+ // IME visible
+ if (bounds.top == mMovementBounds.bottom) {
+ // If the PIP is currently resting on top of the IME, then adjust it with
+ // the hiding IME
+ bounds.offsetTo(bounds.left, toMovementBounds.bottom);
+ } else {
+ bounds.offset(0, Math.min(0, toMovementBounds.bottom - bounds.top));
+ }
+ } else {
+ // IME hidden
+ if (bounds.top == mMovementBounds.bottom) {
+ // If the PIP is resting on top of the IME, then adjust it with the hiding IME
+ bounds.offsetTo(bounds.left, toMovementBounds.bottom);
+ }
+ }
+ mMotionHelper.animateToBounds(bounds);
+ }
}
- mIsMinimized = isMinimized;
- mSnapAlgorithm.setMinimized(isMinimized);
- }
- public void onSnapToEdgeStateChanged(boolean isSnapToEdge) {
- mSnapAlgorithm.setSnapToEdge(isSnapToEdge);
+ // Update the movement bounds after doing the calculations based on the old movement bounds
+ // above
+ mNormalMovementBounds = normalMovementBounds;
+ mExpandedMovementBounds = expandedMovementBounds;
+ updateMovementBounds();
}
private boolean handleTouchEvent(MotionEvent ev) {
@@ -276,20 +284,11 @@
switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN: {
- // Cancel any existing animations on the pinned stack
- if (mPinnedStackBoundsAnimator != null) {
- mPinnedStackBoundsAnimator.cancel();
- }
+ mMotionHelper.synchronizePinnedStackBounds();
- updateBoundedPinnedStackBounds(true /* updatePinnedStackBounds */);
for (PipTouchGesture gesture : mGestures) {
gesture.onDown(mTouchState);
}
- try {
- mPinnedStackController.setInInteractiveMode(true);
- } catch (RemoteException e) {
- Log.e(TAG, "Could not set dragging state", e);
- }
break;
}
case MotionEvent.ACTION_MOVE: {
@@ -303,7 +302,7 @@
case MotionEvent.ACTION_UP: {
// Update the movement bounds again if the state has changed since the user started
// dragging (ie. when the IME shows)
- updateBoundedPinnedStackBounds(false /* updatePinnedStackBounds */);
+ updateMovementBounds();
for (PipTouchGesture gesture : mGestures) {
if (gesture.onUp(mTouchState)) {
@@ -314,11 +313,6 @@
// Fall through to clean up
}
case MotionEvent.ACTION_CANCEL: {
- try {
- mPinnedStackController.setInInteractiveMode(false);
- } catch (RemoteException e) {
- Log.e(TAG, "Could not set dragging state", e);
- }
break;
}
}
@@ -326,16 +320,6 @@
}
/**
- * @return whether the current touch state places the pip partially offscreen.
- */
- private boolean isDraggingOffscreen(PipTouchState touchState) {
- PointF lastDelta = touchState.getLastTouchDelta();
- PointF downDelta = touchState.getDownTouchDelta();
- float left = mPinnedStackBounds.left + lastDelta.x;
- return !(mBoundedPinnedStackBounds.left <= left && left <= mBoundedPinnedStackBounds.right);
- }
-
- /**
* Registers the input consumer.
*/
private void registerInputConsumer() {
@@ -374,27 +358,30 @@
}
/**
- * Sets the snap-to-edge state and notifies the controller.
+ * Sets the minimized state.
*/
- private void setSnapToEdge(boolean snapToEdge) {
- onSnapToEdgeStateChanged(snapToEdge);
-
- if (mPinnedStackController != null) {
- try {
- mPinnedStackController.setSnapToEdge(snapToEdge);
- } catch (RemoteException e) {
- Log.e(TAG, "Could not set snap mode to edge", e);
- }
- }
+ void setMinimizedStateInternal(boolean isMinimized) {
+ setMinimizedState(isMinimized, false /* fromController */);
}
/**
- * Sets the minimized state and notifies the controller.
+ * Sets the minimized state.
*/
- private void setMinimizedState(boolean isMinimized) {
- onMinimizedStateChanged(isMinimized);
+ void setMinimizedState(boolean isMinimized, boolean fromController) {
+ if (mIsMinimized != isMinimized) {
+ MetricsLogger.action(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_MINIMIZED,
+ isMinimized);
+ }
+ mIsMinimized = isMinimized;
+ mSnapAlgorithm.setMinimized(isMinimized);
- if (mPinnedStackController != null) {
+ if (fromController) {
+ if (isMinimized) {
+ // Move the PiP to the new bounds immediately if minimized
+ mMotionHelper.movePip(mMotionHelper.getClosestMinimizedBounds(mNormalBounds,
+ mMovementBounds));
+ }
+ } else if (mPinnedStackController != null) {
try {
mPinnedStackController.setIsMinimized(isMinimized);
} catch (RemoteException e) {
@@ -404,178 +391,43 @@
}
/**
- * @return whether the given {@param pinnedStackBounds} indicates the PIP should be minimized.
+ * Sets the menu visibility.
*/
- private boolean shouldMinimizedPinnedStack() {
- Point displaySize = new Point();
- mContext.getDisplay().getRealSize(displaySize);
- if (mPinnedStackBounds.left < 0) {
- float offscreenFraction = (float) -mPinnedStackBounds.left / mPinnedStackBounds.width();
- return offscreenFraction >= MINIMIZE_OFFSCREEN_FRACTION;
- } else if (mPinnedStackBounds.right > displaySize.x) {
- float offscreenFraction = (float) (mPinnedStackBounds.right - displaySize.x) /
- mPinnedStackBounds.width();
- return offscreenFraction >= MINIMIZE_OFFSCREEN_FRACTION;
+ void setMenuVisibilityState(boolean isMenuVisible) {
+ if (!isMenuVisible) {
+ mIsTappingThrough = false;
+ registerInputConsumer();
} else {
- return false;
+ unregisterInputConsumer();
}
- }
+ MetricsLogger.visibility(mContext, MetricsEvent.ACTION_PICTURE_IN_PICTURE_MENU,
+ isMenuVisible);
- /**
- * Flings the minimized PIP to the closest minimized snap target.
- */
- private void flingToMinimizedSnapTarget(float velocityY) {
- // We currently only allow flinging the minimized stack up and down, so just lock the
- // movement bounds to the current stack bounds horizontally
- Rect movementBounds = new Rect(mPinnedStackBounds.left, mBoundedPinnedStackBounds.top,
- mPinnedStackBounds.left, mBoundedPinnedStackBounds.bottom);
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mPinnedStackBounds,
- 0 /* velocityX */, velocityY);
- if (!mPinnedStackBounds.equals(toBounds)) {
- mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
- toBounds, 0, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
- mFlingAnimationUtils.apply(mPinnedStackBoundsAnimator, 0,
- distanceBetweenRectOffsets(mPinnedStackBounds, toBounds),
- velocityY);
- mPinnedStackBoundsAnimator.start();
- }
- }
-
- /**
- * Animates the PIP to the minimized state, slightly offscreen.
- */
- private void animateToClosestMinimizedTarget() {
- Point displaySize = new Point();
- mContext.getDisplay().getRealSize(displaySize);
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
- mPinnedStackBounds);
- mSnapAlgorithm.applyMinimizedOffset(toBounds, mBoundedPinnedStackBounds, displaySize,
- mStableInsets);
- mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
- toBounds, MINIMIZE_STACK_MAX_DURATION, LINEAR_OUT_SLOW_IN,
- mUpdatePinnedStackBoundsListener);
- mPinnedStackBoundsAnimator.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationStart(Animator animation) {
- mMenuController.hideMenu();
+ if (isMenuVisible != mIsMenuVisible) {
+ if (isMenuVisible) {
+ // Save the current snap fraction and if we do not drag or move the PiP, then
+ // we store back to this snap fraction. Otherwise, we'll reset the snap
+ // fraction and snap to the closest edge
+ Rect expandedBounds = new Rect(mExpandedBounds);
+ mSavedSnapFraction = mMotionHelper.animateToExpandedState(expandedBounds,
+ mMovementBounds, mExpandedMovementBounds);
+ } else {
+ // Try and restore the PiP to the closest edge, using the saved snap fraction
+ // if possible
+ Rect normalBounds = new Rect(mNormalBounds);
+ mMotionHelper.animateToUnexpandedState(normalBounds, mSavedSnapFraction,
+ mNormalMovementBounds);
}
- });
- mPinnedStackBoundsAnimator.start();
- }
-
- /**
- * Flings the PIP to the closest snap target.
- */
- private Rect flingToSnapTarget(float velocity, float velocityX, float velocityY) {
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
- mPinnedStackBounds, velocityX, velocityY);
- if (!mPinnedStackBounds.equals(toBounds)) {
- mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
- toBounds, 0, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
- mFlingAnimationUtils.apply(mPinnedStackBoundsAnimator, 0,
- distanceBetweenRectOffsets(mPinnedStackBounds, toBounds),
- velocity);
- mPinnedStackBoundsAnimator.start();
- }
- return toBounds;
- }
-
- /**
- * Animates the PIP to the closest snap target.
- */
- private Rect animateToClosestSnapTarget() {
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(mBoundedPinnedStackBounds,
- mPinnedStackBounds);
- if (!mPinnedStackBounds.equals(toBounds)) {
- mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
- toBounds, SNAP_STACK_DURATION, FAST_OUT_SLOW_IN, mUpdatePinnedStackBoundsListener);
- mPinnedStackBoundsAnimator.start();
- }
- return toBounds;
- }
-
- /**
- * Animates the dismissal of the PIP over the dismiss target bounds.
- */
- private void animateDismissPinnedStack(Rect dismissBounds) {
- Rect toBounds = new Rect(dismissBounds.centerX(),
- dismissBounds.centerY(),
- dismissBounds.centerX() + 1,
- dismissBounds.centerY() + 1);
- mPinnedStackBoundsAnimator = mMotionHelper.createAnimationToBounds(mPinnedStackBounds,
- toBounds, DISMISS_STACK_DURATION, FAST_OUT_LINEAR_IN, mUpdatePinnedStackBoundsListener);
- mPinnedStackBoundsAnimator.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(Animator animation) {
- BackgroundThread.getHandler().post(PipTouchHandler.this::dismissPinnedStack);
- }
- });
- mPinnedStackBoundsAnimator.start();
- }
-
- /**
- * Resizes the pinned stack back to fullscreen.
- */
- void expandPinnedStackToFullscreen() {
- BackgroundThread.getHandler().post(() -> {
- try {
- mActivityManager.resizeStack(PINNED_STACK_ID, null /* bounds */,
- true /* allowResizeInDockedMode */, true /* preserveWindows */,
- true /* animate */, EXPAND_STACK_DURATION);
- } catch (RemoteException e) {
- Log.e(TAG, "Error showing PIP menu activity", e);
- }
- });
- }
-
- /**
- * Tries to the move the pinned stack to the given {@param bounds}.
- */
- private void movePinnedStack(Rect bounds) {
- if (!bounds.equals(mPinnedStackBounds)) {
- mPinnedStackBounds.set(bounds);
- if (mEnableDragToDismiss) {
- mDismissViewController.updateDismissTarget(bounds);
- }
- mMotionHelper.resizeToBounds(mPinnedStackBounds);
+ mIsMenuVisible = isMenuVisible;
+ updateMovementBounds();
}
}
/**
- * Dismisses the pinned stack.
+ * @return the motion helper.
*/
- private void dismissPinnedStack() {
- try {
- mActivityManager.removeStack(PINNED_STACK_ID);
- } catch (RemoteException e) {
- Log.e(TAG, "Failed to remove PIP", e);
- }
- }
-
- /**
- * Updates the movement bounds of the pinned stack.
- */
- private void updateBoundedPinnedStackBounds(boolean updatePinnedStackBounds) {
- try {
- StackInfo info = mActivityManager.getStackInfo(PINNED_STACK_ID);
- if (info != null) {
- if (updatePinnedStackBounds) {
- mPinnedStackBounds.set(info.bounds);
- }
- mWindowManager.getStableInsets(info.displayId, mStableInsets);
- mBoundedPinnedStackBounds.set(mWindowManager.getPictureInPictureMovementBounds(
- info.displayId));
- }
- } catch (RemoteException e) {
- Log.e(TAG, "Could not fetch PIP movement bounds.", e);
- }
- }
-
- /**
- * @return the distance between points {@param p1} and {@param p2}.
- */
- private float distanceBetweenRectOffsets(Rect r1, Rect r2) {
- return PointF.length(r1.left - r2.left, r1.top - r2.top);
+ public PipMotionHelper getMotionHelper() {
+ return mMotionHelper;
}
/**
@@ -593,25 +445,31 @@
@Override
boolean onMove(PipTouchState touchState) {
+ if (touchState.startedDragging()) {
+ mSavedSnapFraction = -1f;
+ }
+
if (touchState.startedDragging() && mEnableDragToDismiss) {
mHandler.removeCallbacks(mShowDismissAffordance);
- mDismissViewController.showDismissTarget(mPinnedStackBounds);
+ mDismissViewController.showDismissTarget(mMotionHelper.getBounds());
}
if (touchState.isDragging()) {
// Move the pinned stack freely
- PointF lastDelta = touchState.getLastTouchDelta();
- float left = mPinnedStackBounds.left + lastDelta.x;
- float top = mPinnedStackBounds.top + lastDelta.y;
+ mTmpBounds.set(mMotionHelper.getBounds());
+ final PointF lastDelta = touchState.getLastTouchDelta();
+ float left = mTmpBounds.left + lastDelta.x;
+ float top = mTmpBounds.top + lastDelta.y;
if (!touchState.allowDraggingOffscreen()) {
- left = Math.max(mBoundedPinnedStackBounds.left, Math.min(
- mBoundedPinnedStackBounds.right, left));
+ left = Math.max(mMovementBounds.left, Math.min(mMovementBounds.right, left));
}
- top = Math.max(mBoundedPinnedStackBounds.top, Math.min(
- mBoundedPinnedStackBounds.bottom, top));
- mTmpBounds.set(mPinnedStackBounds);
+ top = Math.max(mMovementBounds.top, Math.min(mMovementBounds.bottom, top));
mTmpBounds.offsetTo((int) left, (int) top);
- movePinnedStack(mTmpBounds);
+ mMotionHelper.movePip(mTmpBounds);
+
+ if (mEnableDragToDismiss) {
+ mDismissViewController.updateDismissTarget(mTmpBounds);
+ }
return true;
}
return false;
@@ -626,9 +484,12 @@
final float velocity = PointF.length(vel.x, vel.y);
if (touchState.isDragging()
&& velocity < mFlingAnimationUtils.getMinVelocityPxPerSecond()) {
- if (mDismissViewController.shouldDismiss(mPinnedStackBounds)) {
+ if (mDismissViewController.shouldDismiss(mMotionHelper.getBounds())) {
Rect dismissBounds = mDismissViewController.getDismissBounds();
- animateDismissPinnedStack(dismissBounds);
+ mMotionHelper.animateDismissFromDrag(dismissBounds);
+ MetricsLogger.action(mContext,
+ MetricsEvent.ACTION_PICTURE_IN_PICTURE_DISMISSED,
+ METRIC_VALUE_DISMISSED_BY_DRAG);
return true;
}
}
@@ -638,34 +499,34 @@
}
if (touchState.isDragging()) {
PointF vel = mTouchState.getVelocity();
- if (!mIsMinimized && (shouldMinimizedPinnedStack()
+ if (!mIsMinimized && (mMotionHelper.shouldMinimizePip()
|| isHorizontalFlingTowardsCurrentEdge(vel))) {
// Pip should be minimized
- setMinimizedState(true);
- animateToClosestMinimizedTarget();
+ setMinimizedStateInternal(true);
+ mMotionHelper.animateToClosestMinimizedState(mMovementBounds, mMenuController);
return true;
}
if (mIsMinimized) {
// If we're dragging and it wasn't a minimize gesture
// then we shouldn't be minimized.
- setMinimizedState(false);
+ setMinimizedStateInternal(false);
}
final float velocity = PointF.length(vel.x, vel.y);
if (velocity > mFlingAnimationUtils.getMinVelocityPxPerSecond()) {
- flingToSnapTarget(velocity, vel.x, vel.y);
+ mMotionHelper.flingToSnapTarget(velocity, vel.x, vel.y, mMovementBounds);
} else {
- animateToClosestSnapTarget();
+ mMotionHelper.animateToClosestSnapTarget(mMovementBounds);
}
} else if (mIsMinimized) {
// This was a tap, so no longer minimized
- animateToClosestSnapTarget();
- setMinimizedState(false);
+ mMotionHelper.animateToClosestSnapTarget(mMovementBounds);
+ setMinimizedStateInternal(false);
} else if (!mIsTappingThrough) {
mMenuController.showMenu();
mIsTappingThrough = true;
} else {
- expandPinnedStackToFullscreen();
+ mMotionHelper.expandPip();
}
return true;
}
@@ -679,17 +540,30 @@
final boolean isHorizontal = Math.abs(vel.x) > Math.abs(vel.y);
final boolean isFling = PointF.length(vel.x, vel.y) > mFlingAnimationUtils
.getMinVelocityPxPerSecond();
- final boolean towardsCurrentEdge = onEdge(true /* left */) && vel.x < 0
- || onEdge(false /* right */) && vel.x > 0;
+ final boolean towardsCurrentEdge = isOverEdge(true /* left */) && vel.x < 0
+ || isOverEdge(false /* right */) && vel.x > 0;
return towardsCurrentEdge && isHorizontal && isFling;
}
- private boolean onEdge(boolean checkLeft) {
+ /**
+ * @return whether the given bounds are on the left or right edge (depending on
+ * {@param checkLeft})
+ */
+ private boolean isOverEdge(boolean checkLeft) {
+ final Rect bounds = mMotionHelper.getBounds();
if (checkLeft) {
- return mPinnedStackBounds.left <= mBoundedPinnedStackBounds.left;
+ return bounds.left <= mMovementBounds.left;
} else {
- return mPinnedStackBounds.right >= mBoundedPinnedStackBounds.right
- + mPinnedStackBounds.width();
+ return bounds.right >= mMovementBounds.right + bounds.width();
}
}
+
+ /**
+ * Updates the current movement bounds based on whether the menu is currently visible.
+ */
+ private void updateMovementBounds() {
+ mMovementBounds = mIsMenuVisible
+ ? mExpandedMovementBounds
+ : mNormalMovementBounds;
+ }
}
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchState.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchState.java
index 2e84ced..868b34b7 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchState.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchState.java
@@ -34,6 +34,7 @@
private final PointF mLastTouch = new PointF();
private final PointF mLastDelta = new PointF();
private final PointF mVelocity = new PointF();
+ private boolean mIsUserInteracting = false;
private boolean mIsDragging = false;
private boolean mStartedDragging = false;
private boolean mAllowDraggingOffscreen = false;
@@ -57,6 +58,7 @@
mIsDragging = false;
mStartedDragging = false;
mAllowDraggingOffscreen = true;
+ mIsUserInteracting = true;
break;
}
case MotionEvent.ACTION_MOVE: {
@@ -107,6 +109,7 @@
// Fall through to clean up
}
case MotionEvent.ACTION_CANCEL: {
+ mIsUserInteracting = false;
recycleVelocityTracker();
break;
}
@@ -151,6 +154,13 @@
}
/**
+ * @return whether the user is currently interacting with the PiP.
+ */
+ public boolean isUserInteracting() {
+ return mIsUserInteracting;
+ }
+
+ /**
* @return whether the user has started dragging just in the last handled touch event.
*/
public boolean startedDragging() {
diff --git a/packages/SystemUI/src/com/android/systemui/pip/tv/PipManager.java b/packages/SystemUI/src/com/android/systemui/pip/tv/PipManager.java
index 964fefa..cf7b05e 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/tv/PipManager.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/tv/PipManager.java
@@ -25,6 +25,7 @@
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
+import android.content.pm.ParceledListSlice;
import android.content.res.Resources;
import android.graphics.Rect;
import android.media.session.MediaController;
@@ -39,6 +40,8 @@
import android.util.Log;
import android.util.Pair;
import android.view.Display;
+import android.view.IPinnedStackController;
+import android.view.IPinnedStackListener;
import android.view.IWindowManager;
import android.view.WindowManagerGlobal;
@@ -51,6 +54,8 @@
import java.util.List;
import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
+import static android.view.Display.DEFAULT_DISPLAY;
+
import static com.android.systemui.Prefs.Key.TV_PICTURE_IN_PICTURE_ONBOARDING_SHOWN;
/**
@@ -159,6 +164,8 @@
private boolean mOnboardingShown;
private String[] mLastPackagesResourceGranted;
+ private final PinnedStackListener mPinnedStackListener = new PinnedStackListener();
+
private final Runnable mResizePinnedStackRunnable = new Runnable() {
@Override
public void run() {
@@ -196,6 +203,32 @@
}
};
+ /**
+ * Handler for messages from the PIP controller.
+ */
+ private class PinnedStackListener extends IPinnedStackListener.Stub {
+
+ @Override
+ public void onListenerRegistered(IPinnedStackController controller) {}
+
+ @Override
+ public void onImeVisibilityChanged(boolean imeVisible, int imeHeight) {}
+
+ @Override
+ public void onMinimizedStateChanged(boolean isMinimized) {}
+
+ @Override
+ public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds,
+ boolean fromImeAdjustement) {
+ mHandler.post(() -> {
+ mDefaultPipBounds.set(normalBounds);
+ });
+ }
+
+ @Override
+ public void onActionsChanged(ParceledListSlice actions) {}
+ }
+
private PipManager() { }
/**
@@ -221,16 +254,16 @@
mPipRecentsOverlayManager = new PipRecentsOverlayManager(context);
mMediaSessionManager =
(MediaSessionManager) mContext.getSystemService(Context.MEDIA_SESSION_SERVICE);
+
+ try {
+ mWindowManager.registerPinnedStackListener(DEFAULT_DISPLAY, mPinnedStackListener);
+ } catch (RemoteException e) {
+ Log.e(TAG, "Failed to register pinned stack listener", e);
+ }
}
private void loadConfigurationsAndApply() {
Resources res = mContext.getResources();
- try {
- mDefaultPipBounds = mWindowManager.getPictureInPictureDefaultBounds(
- Display.DEFAULT_DISPLAY);
- } catch (RemoteException e) {
- Log.e(TAG, "Failed to get default PIP bounds", e);
- }
mSettingsPipBounds = Rect.unflattenFromString(res.getString(
R.string.pip_settings_bounds));
mMenuModePipBounds = Rect.unflattenFromString(res.getString(