openkylin
/
platform_packages_apps_Launcher3
mirror of https://gitee.com/openkylin/platform_packages_apps_launcher3.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge "Moving TransformParams to an separate class." into ub-launcher3-rvc-dev

This commit is contained in:
TreeHugger Robot 2020-05-08 00:09:05 +00:00 committed by Android (Google) Code Review
parent e4d1a71413 f29376bb29
commit 0e0bcc7631
11 changed files with 324 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
quickstep/recents_ui_overrides/src/com/android/quickstep/AppToOverviewAnimationProvider.java
View File

@ -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<T extends BaseDraggingActivity> 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);
});

11
quickstep/recents_ui_overrides/src/com/android/quickstep/BaseSwipeUpHandler.java
View File

@ -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<T extends BaseDraggingActivity, Q exten
.setProgress(shift)
.setOffset(offset)
.setOffsetScale(offsetScale)
.setTargetSet(mRecentsAnimationTargets)
.setLauncherOnTop(true);
.setTargetSet(mRecentsAnimationTargets);
mAppWindowAnimationHelper.applyTransform(mTransformParams);
}
@ -453,11 +452,9 @@ public abstract class BaseSwipeUpHandler<T extends BaseDraggingActivity, Q exten
final RectF targetRect = homeAnimationFactory.getWindowTargetRect();
final View floatingView = homeAnimationFactory.getFloatingView();
final boolean isFloatingIconView = floatingView instanceof FloatingIconView;
final RectF startRect = new RectF(
mAppWindowAnimationHelper.applyTransform(
final RectF startRect = new RectF(mAppWindowAnimationHelper.applyTransform(
mTransformParams.setProgress(startProgress)
.setTargetSet(mRecentsAnimationTargets)
.setLauncherOnTop(false)));
.setTargetSet(mRecentsAnimationTargets)));
if (isFloatingIconView) {
mOrientedState.mapInverseRectFromNormalOrientation(
startRect, mDp.widthPx, mDp.heightPx);

4
quickstep/recents_ui_overrides/src/com/android/quickstep/FallbackSwipeHandler.java
View File

@ -118,9 +118,9 @@ public class FallbackSwipeHandler extends BaseSwipeUpHandler<RecentsActivity, Fa
// Keep the home launcher invisible until we decide to land there.
mLauncherAlpha.value = mRunningOverHome ? 1 : 0;
if (mSwipeUpOverHome) {
mAppWindowAnimationHelper.setBaseAlphaCallback((t, a) -> 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

9
quickstep/recents_ui_overrides/src/com/android/quickstep/LauncherSwipeHandler.java
View File

@ -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<T extends BaseDraggingActivity>
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<T extends BaseDraggingActivity>
}
private void setTargetAlphaProvider(TargetAlphaProvider provider) {
mAppWindowAnimationHelper.setTaskAlphaCallback(provider);
mTaskViewSimulator.setTaskAlphaCallback(provider);
mTransformParams.setTaskAlphaCallback(provider);
updateFinalShift();
}

14
quickstep/recents_ui_overrides/src/com/android/quickstep/TaskViewUtils.java
View File

@ -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.

12
quickstep/recents_ui_overrides/src/com/android/quickstep/inputconsumers/DeviceLockedInputConsumer.java
View File

@ -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);

298
quickstep/recents_ui_overrides/src/com/android/quickstep/util/AppWindowAnimationHelper.java
View File

@ -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;
}
}
}

54
quickstep/recents_ui_overrides/src/com/android/quickstep/util/TaskViewSimulator.java
View File

@ -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);
}
/**

237
quickstep/recents_ui_overrides/src/com/android/quickstep/util/TransformParams.java Normal file
View File

@ -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);
}
}

10
quickstep/recents_ui_overrides/src/com/android/quickstep/views/LauncherRecentsView.java
View File

@ -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<BaseQuickstepLauncher>
@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<BaseQuickstepLauncher>
.setCurrentRect(mTempRectF)
.setTargetAlpha(taskView.getAlpha())
.setSyncTransactionApplier(mSyncTransactionApplier)
.setTargetSet(mRecentsAnimationTargets)
.setLauncherOnTop(true);
.setTargetSet(mRecentsAnimationTargets);
}
return mTransformParams;
}

3
quickstep/recents_ui_overrides/src/com/android/quickstep/views/RecentsView.java
View File

@ -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<T extends BaseActivity> extends PagedView impl
return mAppWindowAnimationHelper;
}
public AppWindowAnimationHelper.TransformParams getLiveTileParams(
public TransformParams getLiveTileParams(
boolean mightNeedToRefill) {
return null;
}