diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/AppToOverviewAnimationProvider.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/AppToOverviewAnimationProvider.java index b5ac6e5dce..1eb3becf10 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/AppToOverviewAnimationProvider.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/AppToOverviewAnimationProvider.java @@ -36,8 +36,8 @@ import com.android.launcher3.BaseDraggingActivity; import com.android.launcher3.anim.AnimationSuccessListener; import com.android.launcher3.statehandlers.DepthController; import com.android.quickstep.util.AppWindowAnimationHelper; -import com.android.quickstep.util.AppWindowAnimationHelper.TransformParams; import com.android.quickstep.util.RemoteAnimationProvider; +import com.android.quickstep.util.TransformParams; import com.android.quickstep.views.RecentsView; import com.android.systemui.shared.system.RemoteAnimationTargetCompat; import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat; @@ -164,9 +164,7 @@ final class AppToOverviewAnimationProvider exten valueAnimator.setDuration(RECENTS_LAUNCH_DURATION); valueAnimator.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR); valueAnimator.addUpdateListener((v) -> { - params.setProgress((float) v.getAnimatedValue()) - .setTargetSet(targets) - .setLauncherOnTop(true); + params.setProgress((float) v.getAnimatedValue()).setTargetSet(targets); clipHelper.applyTransform(params); }); diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/BaseSwipeUpHandler.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/BaseSwipeUpHandler.java index 313ae44902..1515ffa815 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/BaseSwipeUpHandler.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/BaseSwipeUpHandler.java @@ -52,9 +52,9 @@ import com.android.quickstep.RecentsAnimationCallbacks.RecentsAnimationListener; import com.android.quickstep.util.ActiveGestureLog; import com.android.quickstep.util.ActivityInitListener; import com.android.quickstep.util.AppWindowAnimationHelper; -import com.android.quickstep.util.AppWindowAnimationHelper.TransformParams; import com.android.quickstep.util.RecentsOrientedState; import com.android.quickstep.util.RectFSpringAnim; +import com.android.quickstep.util.TransformParams; import com.android.quickstep.views.RecentsView; import com.android.quickstep.views.TaskView; import com.android.systemui.shared.recents.model.ThumbnailData; @@ -424,8 +424,7 @@ public abstract class BaseSwipeUpHandler 1 - mLauncherAlpha.value); + mTransformParams.setBaseAlphaCallback((t, a) -> 1 - mLauncherAlpha.value); } else { - mAppWindowAnimationHelper.setBaseAlphaCallback((t, a) -> mLauncherAlpha.value); + mTransformParams.setBaseAlphaCallback((t, a) -> mLauncherAlpha.value); } // Going home has an extra long progress to ensure that it animates into the screen diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/LauncherSwipeHandler.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/LauncherSwipeHandler.java index 8e22fbdc43..a9c4f4a3e7 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/LauncherSwipeHandler.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/LauncherSwipeHandler.java @@ -80,11 +80,11 @@ import com.android.quickstep.BaseActivityInterface.HomeAnimationFactory; import com.android.quickstep.GestureState.GestureEndTarget; import com.android.quickstep.inputconsumers.OverviewInputConsumer; import com.android.quickstep.util.ActiveGestureLog; -import com.android.quickstep.util.AppWindowAnimationHelper.TargetAlphaProvider; import com.android.quickstep.util.RectFSpringAnim; import com.android.quickstep.util.ShelfPeekAnim; import com.android.quickstep.util.ShelfPeekAnim.ShelfAnimState; import com.android.quickstep.util.TaskViewSimulator; +import com.android.quickstep.util.TransformParams.TargetAlphaProvider; import com.android.quickstep.views.LiveTileOverlay; import com.android.quickstep.views.RecentsView; import com.android.quickstep.views.TaskView; @@ -605,9 +605,7 @@ public class LauncherSwipeHandler if (mWindowTransitionController != null) { float progress = mCurrentShift.value / mDragLengthFactor; mWindowTransitionController.setPlayFraction(progress); - mTransformParams - .setTargetSet(mRecentsAnimationTargets) - .setLauncherOnTop(true); + mTransformParams.setTargetSet(mRecentsAnimationTargets); mTaskViewSimulator.setScroll(mRecentsView == null ? 0 : mRecentsView.getScrollOffset()); mTaskViewSimulator.apply(mTransformParams); @@ -1337,8 +1335,7 @@ public class LauncherSwipeHandler } private void setTargetAlphaProvider(TargetAlphaProvider provider) { - mAppWindowAnimationHelper.setTaskAlphaCallback(provider); - mTaskViewSimulator.setTaskAlphaCallback(provider); + mTransformParams.setTaskAlphaCallback(provider); updateFinalShift(); } diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/TaskViewUtils.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/TaskViewUtils.java index 5db8f3124c..9a7a49186d 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/TaskViewUtils.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/TaskViewUtils.java @@ -38,6 +38,7 @@ import com.android.launcher3.model.data.ItemInfo; import com.android.launcher3.statehandlers.DepthController; import com.android.quickstep.util.AppWindowAnimationHelper; import com.android.quickstep.util.MultiValueUpdateListener; +import com.android.quickstep.util.TransformParams; import com.android.quickstep.views.RecentsView; import com.android.quickstep.views.TaskView; import com.android.systemui.shared.recents.model.Task; @@ -132,11 +133,10 @@ public final class TaskViewUtils { final RemoteAnimationTargets targets = new RemoteAnimationTargets(appTargets, wallpaperTargets, MODE_OPENING); targets.addDependentTransactionApplier(applier); - AppWindowAnimationHelper.TransformParams params = - new AppWindowAnimationHelper.TransformParams() + TransformParams params = + new TransformParams() .setSyncTransactionApplier(applier) - .setTargetSet(targets) - .setLauncherOnTop(true); + .setTargetSet(targets); AnimatorSet animatorSet = new AnimatorSet(); final RecentsView recentsView = v.getRecentsView(); @@ -150,7 +150,7 @@ public final class TaskViewUtils { final RectF mThumbnailRect; { - inOutHelper.setTaskAlphaCallback((t, alpha) -> mTaskAlpha.value); + params.setTaskAlphaCallback((t, alpha) -> mTaskAlpha.value); inOutHelper.prepareAnimation( BaseActivity.fromContext(v.getContext()).getDeviceProfile()); inOutHelper.fromTaskThumbnailView(v.getThumbnail(), (RecentsView) v.getParent(), @@ -175,7 +175,7 @@ public final class TaskViewUtils { v.getRecentsView().getClipAnimationHelper(); if (liveTileAnimationHelper != null) { // Append the surface transform params for the live tile app. - AppWindowAnimationHelper.TransformParams liveTileParams = + TransformParams liveTileParams = v.getRecentsView().getLiveTileParams(true /* mightNeedToRefill */); if (liveTileParams != null) { SurfaceParams[] liveTileSurfaceParams = @@ -186,7 +186,7 @@ public final class TaskViewUtils { } } // Apply surface transform using the surface params list. - AppWindowAnimationHelper.applySurfaceParams(params.getSyncTransactionApplier(), + params.applySurfaceParams( surfaceParamsList.toArray(new SurfaceParams[surfaceParamsList.size()])); // Get the task bounds for the app that's being opened after surface transform // update. diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/inputconsumers/DeviceLockedInputConsumer.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/inputconsumers/DeviceLockedInputConsumer.java index 7b8d40c911..adf19df39f 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/inputconsumers/DeviceLockedInputConsumer.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/inputconsumers/DeviceLockedInputConsumer.java @@ -21,8 +21,8 @@ import static android.view.MotionEvent.ACTION_UP; import static com.android.launcher3.Utilities.squaredHypot; import static com.android.launcher3.Utilities.squaredTouchSlop; -import static com.android.quickstep.MultiStateCallback.DEBUG_STATES; import static com.android.quickstep.LauncherSwipeHandler.MIN_PROGRESS_FOR_OVERVIEW; +import static com.android.quickstep.MultiStateCallback.DEBUG_STATES; import static com.android.quickstep.util.ActiveGestureLog.INTENT_EXTRA_LOG_TRACE_ID; import android.content.ComponentName; @@ -44,12 +44,13 @@ import com.android.quickstep.GestureState; import com.android.quickstep.InputConsumer; import com.android.quickstep.LockScreenRecentsActivity; import com.android.quickstep.MultiStateCallback; +import com.android.quickstep.RecentsAnimationCallbacks; import com.android.quickstep.RecentsAnimationController; import com.android.quickstep.RecentsAnimationDeviceState; -import com.android.quickstep.RecentsAnimationCallbacks; import com.android.quickstep.RecentsAnimationTargets; import com.android.quickstep.TaskAnimationManager; import com.android.quickstep.util.AppWindowAnimationHelper; +import com.android.quickstep.util.TransformParams; import com.android.systemui.shared.recents.model.ThumbnailData; import com.android.systemui.shared.system.InputMonitorCompat; import com.android.systemui.shared.system.RemoteAnimationTargetCompat; @@ -84,7 +85,7 @@ public class DeviceLockedInputConsumer implements InputConsumer, private final PointF mTouchDown = new PointF(); private final AppWindowAnimationHelper mAppWindowAnimationHelper; - private final AppWindowAnimationHelper.TransformParams mTransformParams; + private final TransformParams mTransformParams; private final Point mDisplaySize; private final MultiStateCallback mStateCallback; @@ -105,7 +106,7 @@ public class DeviceLockedInputConsumer implements InputConsumer, mGestureState = gestureState; mTouchSlopSquared = squaredTouchSlop(context); mAppWindowAnimationHelper = new AppWindowAnimationHelper(context); - mTransformParams = new AppWindowAnimationHelper.TransformParams(); + mTransformParams = new TransformParams(); mInputMonitorCompat = inputMonitorCompat; // Do not use DeviceProfile as the user data might be locked @@ -230,8 +231,7 @@ public class DeviceLockedInputConsumer implements InputConsumer, Utilities.scaleRectAboutCenter(displaySize, SCALE_DOWN); displaySize.offsetTo(displaySize.left, 0); - mTransformParams.setTargetSet(mRecentsAnimationTargets) - .setLauncherOnTop(true); + mTransformParams.setTargetSet(mRecentsAnimationTargets); mAppWindowAnimationHelper.updateTargetRect(displaySize); mAppWindowAnimationHelper.applyTransform(mTransformParams); diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/util/AppWindowAnimationHelper.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/util/AppWindowAnimationHelper.java index cd7c7eedbd..d3bd01289b 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/util/AppWindowAnimationHelper.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/util/AppWindowAnimationHelper.java @@ -15,11 +15,10 @@ */ package com.android.quickstep.util; -import static com.android.launcher3.config.FeatureFlags.ENABLE_QUICKSTEP_LIVE_TILE; +import static com.android.launcher3.Utilities.boundToRange; +import static com.android.launcher3.Utilities.mapRange; import static com.android.systemui.shared.system.QuickStepContract.getWindowCornerRadius; import static com.android.systemui.shared.system.QuickStepContract.supportsRoundedCornersOnWindows; -import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME; -import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING; import android.annotation.TargetApi; import android.content.Context; @@ -36,9 +35,7 @@ import com.android.launcher3.BaseDraggingActivity; import com.android.launcher3.DeviceProfile; import com.android.launcher3.R; import com.android.launcher3.Utilities; -import com.android.launcher3.anim.Interpolators; import com.android.launcher3.views.BaseDragLayer; -import com.android.quickstep.RemoteAnimationTargets; import com.android.quickstep.SystemUiProxy; import com.android.quickstep.views.RecentsView; import com.android.quickstep.views.TaskThumbnailView; @@ -46,14 +43,14 @@ import com.android.systemui.shared.recents.utilities.RectFEvaluator; import com.android.systemui.shared.system.RemoteAnimationTargetCompat; import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat; import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams; -import com.android.systemui.shared.system.TransactionCompat; +import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams.Builder; import com.android.systemui.shared.system.WindowManagerWrapper; /** * Utility class to handle window clip animation */ @TargetApi(Build.VERSION_CODES.P) -public class AppWindowAnimationHelper { +public class AppWindowAnimationHelper implements TransformParams.BuilderProxy { // The bounds of the source app in device coordinates private final RectF mSourceStackBounds = new RectF(); @@ -94,9 +91,6 @@ public class AppWindowAnimationHelper { // Corner radius currently applied to transformed window. private float mCurrentCornerRadius; - private TargetAlphaProvider mTaskAlphaCallback = (t, a) -> a; - private TargetAlphaProvider mBaseAlphaCallback = (t, a) -> 1; - public AppWindowAnimationHelper(RecentsOrientedState orientedState, Context context) { Resources res = context.getResources(); mOrientedState = orientedState; @@ -167,7 +161,7 @@ public class AppWindowAnimationHelper { if (surfaceParams == null) { return null; } - applySurfaceParams(params.mSyncTransactionApplier, surfaceParams); + params.applySurfaceParams(surfaceParams); return mCurrentRect; } @@ -176,96 +170,69 @@ public class AppWindowAnimationHelper { * the SurfaceParams to apply via {@link SyncRtSurfaceTransactionApplierCompat#applyParams}. */ public SurfaceParams[] computeSurfaceParams(TransformParams params) { - if (params.mTargetSet == null) { + if (params.getTargetSet() == null) { return null; } - float progress = Utilities.boundToRange(params.mProgress, 0, 1); updateCurrentRect(params); + return params.createSurfaceParams(this); + } - SurfaceParams[] surfaceParams = new SurfaceParams[params.mTargetSet.unfilteredApps.length]; - for (int i = 0; i < params.mTargetSet.unfilteredApps.length; i++) { - RemoteAnimationTargetCompat app = params.mTargetSet.unfilteredApps[i]; - SurfaceParams.Builder builder = new SurfaceParams.Builder(app.leash); + @Override + public void onBuildParams(Builder builder, RemoteAnimationTargetCompat app, + int targetMode, TransformParams params) { + Rect crop = mTmpRect; + crop.set(app.screenSpaceBounds); + crop.offsetTo(0, 0); + float cornerRadius = 0f; + float scale = Math.max(mCurrentRect.width(), mTargetRect.width()) / crop.width(); + if (app.mode == targetMode + && app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) { + mTmpMatrix.setRectToRect(mSourceRect, mCurrentRect, ScaleToFit.FILL); if (app.localBounds != null) { - mTmpMatrix.setTranslate(0, 0); - if (app.activityType == ACTIVITY_TYPE_HOME && app.mode == MODE_CLOSING) { - mTmpMatrix.setTranslate(app.localBounds.left, app.localBounds.top); - } + mTmpMatrix.postTranslate(app.localBounds.left, app.localBounds.top); } else { - mTmpMatrix.setTranslate(app.position.x, app.position.y); + mTmpMatrix.postTranslate(app.position.x, app.position.y); + } + mCurrentClipRectF.roundOut(crop); + if (mSupportsRoundedCornersOnWindows) { + if (params.getCornerRadius() > -1) { + cornerRadius = params.getCornerRadius(); + scale = mCurrentRect.width() / crop.width(); + } else { + float windowCornerRadius = mUseRoundedCornersOnWindows + ? mWindowCornerRadius : 0; + cornerRadius = mapRange(boundToRange(params.getProgress(), 0, 1), + windowCornerRadius, mTaskCornerRadius); + } + mCurrentCornerRadius = cornerRadius; } - Rect crop = mTmpRect; - crop.set(app.screenSpaceBounds); - crop.offsetTo(0, 0); - float alpha; - float cornerRadius = 0f; - float scale = Math.max(mCurrentRect.width(), mTargetRect.width()) / crop.width(); - if (app.mode == params.mTargetSet.targetMode) { - alpha = mTaskAlphaCallback.getAlpha(app, params.mTargetAlpha); - if (app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) { - mTmpMatrix.setRectToRect(mSourceRect, mCurrentRect, ScaleToFit.FILL); - if (app.localBounds != null) { - mTmpMatrix.postTranslate(app.localBounds.left, app.localBounds.top); - } else { - mTmpMatrix.postTranslate(app.position.x, app.position.y); - } - mCurrentClipRectF.roundOut(crop); - if (mSupportsRoundedCornersOnWindows) { - if (params.mCornerRadius > -1) { - cornerRadius = params.mCornerRadius; - scale = mCurrentRect.width() / crop.width(); - } else { - float windowCornerRadius = mUseRoundedCornersOnWindows - ? mWindowCornerRadius : 0; - cornerRadius = Utilities.mapRange(progress, windowCornerRadius, - mTaskCornerRadius); - } - mCurrentCornerRadius = cornerRadius; - } - // Fade out Assistant overlay. - if (app.activityType == RemoteAnimationTargetCompat.ACTIVITY_TYPE_ASSISTANT - && app.isNotInRecents) { - alpha = 1 - Interpolators.DEACCEL_2_5.getInterpolation(progress); - } - } else if (params.mTargetSet.hasRecents) { - // If home has a different target then recents, reverse anim the - // home target. - alpha = 1 - (progress * params.mTargetAlpha); - } - } else { - alpha = mBaseAlphaCallback.getAlpha(app, progress); - if (ENABLE_QUICKSTEP_LIVE_TILE.get() && params.mLauncherOnTop) { - crop = null; - } - } - builder.withAlpha(alpha) - .withMatrix(mTmpMatrix) + builder.withMatrix(mTmpMatrix) .withWindowCrop(crop) // Since radius is in Surface space, but we draw the rounded corners in screen // space, we have to undo the scale .withCornerRadius(cornerRadius / scale); - surfaceParams[i] = builder.build(); + } - return surfaceParams; } public RectF updateCurrentRect(TransformParams params) { - if (params.mCurrentRect != null) { - mCurrentRect.set(params.mCurrentRect); + if (params.getCurrentRect() != null) { + mCurrentRect.set(params.getCurrentRect()); } else { mTmpRectF.set(mTargetRect); - Utilities.scaleRectFAboutCenter(mTmpRectF, params.mOffsetScale); - mCurrentRect.set(mRectFEvaluator.evaluate(params.mProgress, mSourceRect, mTmpRectF)); + Utilities.scaleRectFAboutCenter(mTmpRectF, params.getOffsetScale()); + mCurrentRect.set(mRectFEvaluator.evaluate( + params.getProgress(), mSourceRect, mTmpRectF)); if (mOrientedState == null || !mOrientedState.isMultipleOrientationSupportedByDevice()) { - mCurrentRect.offset(params.mOffset, 0); + mCurrentRect.offset(params.getOffset(), 0); } else { int displayRotation = mOrientedState.getDisplayRotation(); int launcherRotation = mOrientedState.getLauncherRotation(); - mOrientedState.getOrientationHandler().offsetTaskRect(mCurrentRect, - params.mOffset, displayRotation, launcherRotation); + mOrientedState.getOrientationHandler().offsetTaskRect( + mCurrentRect, params.getOffset(), displayRotation, launcherRotation); } } @@ -275,7 +242,7 @@ public class AppWindowAnimationHelper { private void updateClipRect(TransformParams params) { // Don't clip past progress > 1. - float progress = Math.min(1, params.mProgress); + float progress = Math.min(1, params.getProgress()); mCurrentClipRectF.left = mSourceWindowClipInsets.left * progress; mCurrentClipRectF.top = mSourceWindowClipInsets.top * progress; mCurrentClipRectF.right = @@ -289,28 +256,6 @@ public class AppWindowAnimationHelper { return mCurrentRectWithInsets; } - public static void applySurfaceParams(@Nullable SyncRtSurfaceTransactionApplierCompat - syncTransactionApplier, SurfaceParams[] params) { - if (syncTransactionApplier != null) { - syncTransactionApplier.scheduleApply(params); - } else { - TransactionCompat t = new TransactionCompat(); - for (SurfaceParams param : params) { - SyncRtSurfaceTransactionApplierCompat.applyParams(t, param); - } - t.setEarlyWakeup(); - t.apply(); - } - } - - public void setTaskAlphaCallback(TargetAlphaProvider callback) { - mTaskAlphaCallback = callback; - } - - public void setBaseAlphaCallback(TargetAlphaProvider callback) { - mBaseAlphaCallback = callback; - } - public void fromTaskThumbnailView(TaskThumbnailView ttv, RecentsView rv, @Nullable RemoteAnimationTargetCompat target) { BaseDraggingActivity activity = BaseDraggingActivity.fromContext(ttv.getContext()); @@ -386,157 +331,4 @@ public class AppWindowAnimationHelper { return mCurrentCornerRadius; } - public interface TargetAlphaProvider { - float getAlpha(RemoteAnimationTargetCompat target, float expectedAlpha); - } - - public static class TransformParams { - private float mProgress; - private float mOffset; - private float mOffsetScale; - private @Nullable RectF mCurrentRect; - private float mTargetAlpha; - private float mCornerRadius; - private boolean mLauncherOnTop; - private RemoteAnimationTargets mTargetSet; - private SyncRtSurfaceTransactionApplierCompat mSyncTransactionApplier; - - public TransformParams() { - mProgress = 0; - mOffset = 0; - mOffsetScale = 1; - mCurrentRect = null; - mTargetAlpha = 1; - mCornerRadius = -1; - mLauncherOnTop = false; - } - - /** - * Sets the progress of the transformation, where 0 is the source and 1 is the target. We - * automatically adjust properties such as currentRect and cornerRadius based on this - * progress, unless they are manually overridden by setting them on this TransformParams. - */ - public TransformParams setProgress(float progress) { - mProgress = progress; - return this; - } - - /** - * Sets the corner radius of the transformed window, in pixels. If unspecified (-1), we - * simply interpolate between the window's corner radius to the task view's corner radius, - * based on {@link #mProgress}. - */ - public TransformParams setCornerRadius(float cornerRadius) { - mCornerRadius = cornerRadius; - return this; - } - - /** - * Sets the current rect to show the transformed window, in device coordinates. This gives - * the caller manual control of where to show the window. If unspecified (null), we - * interpolate between {@link AppWindowAnimationHelper#mSourceRect} and - * {@link AppWindowAnimationHelper#mTargetRect}, based on {@link #mProgress}. - */ - public TransformParams setCurrentRect(RectF currentRect) { - mCurrentRect = currentRect; - return this; - } - - /** - * Specifies the alpha of the transformed window. Default is 1. - */ - public TransformParams setTargetAlpha(float targetAlpha) { - mTargetAlpha = targetAlpha; - return this; - } - - /** - * If {@link #mCurrentRect} is null (i.e. {@link #setCurrentRect(RectF)} hasn't overridden - * the default), then offset the current rect by this amount after computing the rect based - * on {@link #mProgress}. - */ - public TransformParams setOffset(float offset) { - mOffset = offset; - return this; - } - - /** - * If {@link #mCurrentRect} is null (i.e. {@link #setCurrentRect(RectF)} hasn't overridden - * the default), then scale the current rect by this amount after computing the rect based - * on {@link #mProgress}. - */ - public TransformParams setOffsetScale(float offsetScale) { - mOffsetScale = offsetScale; - return this; - } - - /** - * If true, sets the crop = null and layer = Integer.MAX_VALUE for targets that don't match - * {@link #mTargetSet}.targetMode. (Currently only does this when live tiles are enabled.) - */ - public TransformParams setLauncherOnTop(boolean launcherOnTop) { - mLauncherOnTop = launcherOnTop; - return this; - } - - /** - * Specifies the set of RemoteAnimationTargetCompats that are included in the transformation - * that these TransformParams help compute. These TransformParams generally only apply to - * the targetSet.apps which match the targetSet.targetMode (e.g. the MODE_CLOSING app when - * swiping to home). - */ - public TransformParams setTargetSet(RemoteAnimationTargets targetSet) { - mTargetSet = targetSet; - return this; - } - - /** - * Sets the SyncRtSurfaceTransactionApplierCompat that will apply the SurfaceParams that - * are computed based on these TransformParams. - */ - public TransformParams setSyncTransactionApplier( - SyncRtSurfaceTransactionApplierCompat applier) { - mSyncTransactionApplier = applier; - return this; - } - - // Pubic getters so outside packages can read the values. - - public float getProgress() { - return mProgress; - } - - public float getOffset() { - return mOffset; - } - - public float getOffsetScale() { - return mOffsetScale; - } - - @Nullable - public RectF getCurrentRect() { - return mCurrentRect; - } - - public float getTargetAlpha() { - return mTargetAlpha; - } - - public float getCornerRadius() { - return mCornerRadius; - } - - public boolean isLauncherOnTop() { - return mLauncherOnTop; - } - - public RemoteAnimationTargets getTargetSet() { - return mTargetSet; - } - - public SyncRtSurfaceTransactionApplierCompat getSyncTransactionApplier() { - return mSyncTransactionApplier; - } - } } diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TaskViewSimulator.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TaskViewSimulator.java index ea22d403f6..a95908d3bf 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TaskViewSimulator.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TaskViewSimulator.java @@ -19,7 +19,6 @@ import static android.view.Surface.ROTATION_0; import static com.android.launcher3.states.RotationHelper.deltaRotation; import static com.android.launcher3.touch.PagedOrientationHandler.MATRIX_POST_TRANSLATE; -import static com.android.quickstep.util.AppWindowAnimationHelper.applySurfaceParams; import static com.android.quickstep.util.RecentsOrientedState.isFixedRotationTransformEnabled; import static com.android.quickstep.util.RecentsOrientedState.postDisplayRotation; import static com.android.systemui.shared.system.WindowManagerWrapper.WINDOWING_MODE_FULLSCREEN; @@ -33,24 +32,21 @@ import android.graphics.RectF; import com.android.launcher3.DeviceProfile; import com.android.launcher3.R; import com.android.launcher3.Utilities; -import com.android.launcher3.anim.Interpolators; import com.android.launcher3.touch.PagedOrientationHandler; import com.android.quickstep.AnimatedFloat; import com.android.quickstep.RecentsAnimationTargets; -import com.android.quickstep.util.AppWindowAnimationHelper.TargetAlphaProvider; -import com.android.quickstep.util.AppWindowAnimationHelper.TransformParams; import com.android.quickstep.views.RecentsView.ScrollState; import com.android.quickstep.views.TaskThumbnailView.PreviewPositionHelper; import com.android.quickstep.views.TaskView; import com.android.quickstep.views.TaskView.FullscreenDrawParams; import com.android.systemui.shared.recents.model.ThumbnailData; import com.android.systemui.shared.system.RemoteAnimationTargetCompat; -import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams; +import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams.Builder; /** * A utility class which emulates the layout behavior of TaskView and RecentsView */ -public class TaskViewSimulator { +public class TaskViewSimulator implements TransformParams.BuilderProxy { private final Rect mTmpCropRect = new Rect(); private final RectF mTempRectF = new RectF(); @@ -68,8 +64,6 @@ public class TaskViewSimulator { private RemoteAnimationTargetCompat mRunningTarget; private RecentsAnimationTargets mAllTargets; - private TargetAlphaProvider mTaskAlphaCallback = (t, a) -> a; - // Thumbnail view properties private final Rect mThumbnailPosition = new Rect(); private final ThumbnailData mThumbnailData = new ThumbnailData(); @@ -168,13 +162,6 @@ public class TaskViewSimulator { } } - /** - * Sets an alternate function which can be used to control the alpha - */ - public void setTaskAlphaCallback(TargetAlphaProvider callback) { - mTaskAlphaCallback = callback; - } - /** * Applies the target to the previously set parameters */ @@ -245,35 +232,18 @@ public class TaskViewSimulator { mInversePositionMatrix.mapRect(mTempRectF); mTempRectF.roundOut(mTmpCropRect); - SurfaceParams[] surfaceParams = new SurfaceParams[mAllTargets.unfilteredApps.length]; - for (int i = 0; i < mAllTargets.unfilteredApps.length; i++) { - RemoteAnimationTargetCompat app = mAllTargets.unfilteredApps[i]; - SurfaceParams.Builder builder = new SurfaceParams.Builder(app.leash); + params.applySurfaceParams(params.createSurfaceParams(this)); + } - if (app.mode == mAllTargets.targetMode) { - float alpha = mTaskAlphaCallback.getAlpha(app, params.getTargetAlpha()); - if (app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) { - // Fade out Assistant overlay. - if (app.activityType == RemoteAnimationTargetCompat.ACTIVITY_TYPE_ASSISTANT - && app.isNotInRecents) { - alpha = Interpolators.ACCEL_2.getInterpolation(fullScreenProgress.value); - } - - builder.withAlpha(alpha) - .withMatrix(mMatrix) - .withWindowCrop(mTmpCropRect) - .withCornerRadius(getCurrentCornerRadius()); - } else if (params.getTargetSet().hasRecents) { - // If home has a different target then recents, reverse anim the home target. - builder.withAlpha(fullScreenProgress.value * params.getTargetAlpha()); - } - } else { - builder.withAlpha(1); - } - surfaceParams[i] = builder.build(); + @Override + public void onBuildParams(Builder builder, RemoteAnimationTargetCompat app, + int targetMode, TransformParams params) { + if (app.mode == mAllTargets.targetMode + && app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) { + builder.withMatrix(mMatrix) + .withWindowCrop(mTmpCropRect) + .withCornerRadius(getCurrentCornerRadius()); } - - applySurfaceParams(params.getSyncTransactionApplier(), surfaceParams); } /** diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TransformParams.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TransformParams.java new file mode 100644 index 0000000000..02e2142d7d --- /dev/null +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/util/TransformParams.java @@ -0,0 +1,237 @@ +/* + * Copyright (C) 2020 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.quickstep.util; + +import android.graphics.RectF; + +import androidx.annotation.Nullable; + +import com.android.launcher3.Utilities; +import com.android.launcher3.anim.Interpolators; +import com.android.quickstep.RemoteAnimationTargets; +import com.android.systemui.shared.system.RemoteAnimationTargetCompat; +import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat; +import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams; +import com.android.systemui.shared.system.TransactionCompat; + +public class TransformParams { + + private float mProgress; + private float mOffset; + private float mOffsetScale; + private @Nullable RectF mCurrentRect; + private float mTargetAlpha; + private float mCornerRadius; + private RemoteAnimationTargets mTargetSet; + private SyncRtSurfaceTransactionApplierCompat mSyncTransactionApplier; + + private TargetAlphaProvider mTaskAlphaCallback = (t, a) -> a; + private TargetAlphaProvider mBaseAlphaCallback = (t, a) -> 1; + + public TransformParams() { + mProgress = 0; + mOffset = 0; + mOffsetScale = 1; + mCurrentRect = null; + mTargetAlpha = 1; + mCornerRadius = -1; + } + + /** + * Sets the progress of the transformation, where 0 is the source and 1 is the target. We + * automatically adjust properties such as currentRect and cornerRadius based on this + * progress, unless they are manually overridden by setting them on this TransformParams. + */ + public TransformParams setProgress(float progress) { + mProgress = progress; + return this; + } + + /** + * Sets the corner radius of the transformed window, in pixels. If unspecified (-1), we + * simply interpolate between the window's corner radius to the task view's corner radius, + * based on {@link #mProgress}. + */ + public TransformParams setCornerRadius(float cornerRadius) { + mCornerRadius = cornerRadius; + return this; + } + + /** + * Sets the current rect to show the transformed window, in device coordinates. This gives + * the caller manual control of where to show the window. If unspecified (null), we + * interpolate between {@link AppWindowAnimationHelper#mSourceRect} and + * {@link AppWindowAnimationHelper#mTargetRect}, based on {@link #mProgress}. + */ + public TransformParams setCurrentRect(RectF currentRect) { + mCurrentRect = currentRect; + return this; + } + + /** + * Specifies the alpha of the transformed window. Default is 1. + */ + public TransformParams setTargetAlpha(float targetAlpha) { + mTargetAlpha = targetAlpha; + return this; + } + + /** + * If {@link #mCurrentRect} is null (i.e. {@link #setCurrentRect(RectF)} hasn't overridden + * the default), then offset the current rect by this amount after computing the rect based + * on {@link #mProgress}. + */ + public TransformParams setOffset(float offset) { + mOffset = offset; + return this; + } + + /** + * If {@link #mCurrentRect} is null (i.e. {@link #setCurrentRect(RectF)} hasn't overridden + * the default), then scale the current rect by this amount after computing the rect based + * on {@link #mProgress}. + */ + public TransformParams setOffsetScale(float offsetScale) { + mOffsetScale = offsetScale; + return this; + } + + /** + * Specifies the set of RemoteAnimationTargetCompats that are included in the transformation + * that these TransformParams help compute. These TransformParams generally only apply to + * the targetSet.apps which match the targetSet.targetMode (e.g. the MODE_CLOSING app when + * swiping to home). + */ + public TransformParams setTargetSet(RemoteAnimationTargets targetSet) { + mTargetSet = targetSet; + return this; + } + + /** + * Sets the SyncRtSurfaceTransactionApplierCompat that will apply the SurfaceParams that + * are computed based on these TransformParams. + */ + public TransformParams setSyncTransactionApplier( + SyncRtSurfaceTransactionApplierCompat applier) { + mSyncTransactionApplier = applier; + return this; + } + + /** + * Sets an alternate function which can be used to control the alpha of target app + */ + public TransformParams setTaskAlphaCallback(TargetAlphaProvider callback) { + mTaskAlphaCallback = callback; + return this; + } + + /** + * Sets an alternate function which can be used to control the alpha of non-target app + */ + public TransformParams setBaseAlphaCallback(TargetAlphaProvider callback) { + mBaseAlphaCallback = callback; + return this; + } + + public SurfaceParams[] createSurfaceParams(BuilderProxy proxy) { + RemoteAnimationTargets targets = mTargetSet; + SurfaceParams[] surfaceParams = new SurfaceParams[targets.unfilteredApps.length]; + for (int i = 0; i < targets.unfilteredApps.length; i++) { + RemoteAnimationTargetCompat app = targets.unfilteredApps[i]; + SurfaceParams.Builder builder = new SurfaceParams.Builder(app.leash); + + float progress = Utilities.boundToRange(getProgress(), 0, 1); + float alpha; + if (app.mode == targets.targetMode) { + alpha = mTaskAlphaCallback.getAlpha(app, getTargetAlpha()); + if (app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) { + // Fade out Assistant overlay. + if (app.activityType == RemoteAnimationTargetCompat.ACTIVITY_TYPE_ASSISTANT + && app.isNotInRecents) { + alpha = 1 - Interpolators.DEACCEL_2_5.getInterpolation(progress); + } + } else if (targets.hasRecents) { + // If home has a different target then recents, reverse anim the + // home target. + alpha = 1 - (progress * getTargetAlpha()); + } + } else { + alpha = mBaseAlphaCallback.getAlpha(app, progress); + } + proxy.onBuildParams(builder.withAlpha(alpha), app, targets.targetMode, this); + surfaceParams[i] = builder.build(); + } + return surfaceParams; + } + + // Pubic getters so outside packages can read the values. + + public float getProgress() { + return mProgress; + } + + public float getOffset() { + return mOffset; + } + + public float getOffsetScale() { + return mOffsetScale; + } + + @Nullable + public RectF getCurrentRect() { + return mCurrentRect; + } + + public float getTargetAlpha() { + return mTargetAlpha; + } + + public float getCornerRadius() { + return mCornerRadius; + } + + public RemoteAnimationTargets getTargetSet() { + return mTargetSet; + } + + public SyncRtSurfaceTransactionApplierCompat getSyncTransactionApplier() { + return mSyncTransactionApplier; + } + + public void applySurfaceParams(SurfaceParams[] params) { + if (mSyncTransactionApplier != null) { + mSyncTransactionApplier.scheduleApply(params); + } else { + TransactionCompat t = new TransactionCompat(); + for (SurfaceParams param : params) { + SyncRtSurfaceTransactionApplierCompat.applyParams(t, param); + } + t.setEarlyWakeup(); + t.apply(); + } + } + + public interface TargetAlphaProvider { + float getAlpha(RemoteAnimationTargetCompat target, float expectedAlpha); + } + + public interface BuilderProxy { + + void onBuildParams(SurfaceParams.Builder builder, + RemoteAnimationTargetCompat app, int targetMode, TransformParams params); + } +} diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/views/LauncherRecentsView.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/views/LauncherRecentsView.java index 416af2b37c..8a6bd846c9 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/views/LauncherRecentsView.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/views/LauncherRecentsView.java @@ -50,8 +50,7 @@ import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper; import com.android.launcher3.util.TraceHelper; import com.android.launcher3.views.ScrimView; import com.android.quickstep.SysUINavigationMode; -import com.android.quickstep.util.AppWindowAnimationHelper; -import com.android.quickstep.util.AppWindowAnimationHelper.TransformParams; +import com.android.quickstep.util.TransformParams; import com.android.systemui.plugins.PluginListener; import com.android.systemui.plugins.RecentsExtraCard; @@ -213,14 +212,14 @@ public class LauncherRecentsView extends RecentsView @Override public void redrawLiveTile(boolean mightNeedToRefill) { - AppWindowAnimationHelper.TransformParams transformParams = getLiveTileParams(mightNeedToRefill); + TransformParams transformParams = getLiveTileParams(mightNeedToRefill); if (transformParams != null) { mAppWindowAnimationHelper.applyTransform(transformParams); } } @Override - public AppWindowAnimationHelper.TransformParams getLiveTileParams( + public TransformParams getLiveTileParams( boolean mightNeedToRefill) { if (!mEnableDrawingLiveTile || mRecentsAnimationController == null || mRecentsAnimationTargets == null || mAppWindowAnimationHelper == null) { @@ -248,8 +247,7 @@ public class LauncherRecentsView extends RecentsView .setCurrentRect(mTempRectF) .setTargetAlpha(taskView.getAlpha()) .setSyncTransactionApplier(mSyncTransactionApplier) - .setTargetSet(mRecentsAnimationTargets) - .setLauncherOnTop(true); + .setTargetSet(mRecentsAnimationTargets); } return mTransformParams; } diff --git a/quickstep/recents_ui_overrides/src/com/android/quickstep/views/RecentsView.java b/quickstep/recents_ui_overrides/src/com/android/quickstep/views/RecentsView.java index 31563ad03c..4f6f9705a3 100644 --- a/quickstep/recents_ui_overrides/src/com/android/quickstep/views/RecentsView.java +++ b/quickstep/recents_ui_overrides/src/com/android/quickstep/views/RecentsView.java @@ -125,6 +125,7 @@ import com.android.quickstep.ViewUtils; import com.android.quickstep.util.AppWindowAnimationHelper; import com.android.quickstep.util.LayoutUtils; import com.android.quickstep.util.RecentsOrientedState; +import com.android.quickstep.util.TransformParams; import com.android.quickstep.util.WindowSizeStrategy; import com.android.systemui.plugins.ResourceProvider; import com.android.systemui.shared.recents.IPinnedStackAnimationListener; @@ -2111,7 +2112,7 @@ public abstract class RecentsView extends PagedView impl return mAppWindowAnimationHelper; } - public AppWindowAnimationHelper.TransformParams getLiveTileParams( + public TransformParams getLiveTileParams( boolean mightNeedToRefill) { return null; }