Merge "Revert "Extra common logic of default transition animation"" into main (83223e8b) · Commits · e / os / android_frameworks_base

libs/WindowManager/Shell/src/com/android/wm/shell/transition/DefaultTransitionHandler.java

+36 −89

Original line number	Original line	Diff line number	Diff line
	@@ -826,26 +826,24 @@ public class DefaultTransitionHandler implements Transitions.TransitionHandler {
	@NonNull Runnable finishCallback, @NonNull TransactionPool pool,		@NonNull Runnable finishCallback, @NonNull TransactionPool pool,
	@NonNull ShellExecutor mainExecutor, @Nullable Point position, float cornerRadius,		@NonNull ShellExecutor mainExecutor, @Nullable Point position, float cornerRadius,
	@Nullable Rect clipRect, boolean isActivity) {		@Nullable Rect clipRect, boolean isActivity) {
	final DefaultAnimationAdapter adapter = new DefaultAnimationAdapter(anim, leash,
	position, clipRect, cornerRadius, isActivity);
	buildSurfaceAnimation(animations, anim, finishCallback, pool, mainExecutor, adapter);
	}

	/** Builds an animator for the surface and adds it to the `animations` list. */
	static void buildSurfaceAnimation(@NonNull ArrayList<Animator> animations,
	@NonNull Animation anim, @NonNull Runnable finishCallback,
	@NonNull TransactionPool pool, @NonNull ShellExecutor mainExecutor,
	@NonNull AnimationAdapter updateListener) {
	final SurfaceControl.Transaction transaction = pool.acquire();		final SurfaceControl.Transaction transaction = pool.acquire();
	updateListener.setTransaction(transaction);
	final ValueAnimator va = ValueAnimator.ofFloat(0f, 1f);		final ValueAnimator va = ValueAnimator.ofFloat(0f, 1f);
			final Transformation transformation = new Transformation();
			final float[] matrix = new float[9];
	// Animation length is already expected to be scaled.		// Animation length is already expected to be scaled.
	va.overrideDurationScale(1.0f);		va.overrideDurationScale(1.0f);
	va.setDuration(anim.computeDurationHint());		va.setDuration(anim.computeDurationHint());
			final ValueAnimator.AnimatorUpdateListener updateListener = animation -> {
			final long currentPlayTime = Math.min(va.getDuration(), va.getCurrentPlayTime());

			applyTransformation(currentPlayTime, transaction, leash, anim, transformation, matrix,
			position, cornerRadius, clipRect, isActivity);
			};
	va.addUpdateListener(updateListener);		va.addUpdateListener(updateListener);

	final Runnable finisher = () -> {		final Runnable finisher = () -> {
	updateListener.onAnimationUpdate(va);		applyTransformation(va.getDuration(), transaction, leash, anim, transformation, matrix,
			position, cornerRadius, clipRect, isActivity);

	pool.release(transaction);		pool.release(transaction);
	mainExecutor.execute(() -> {		mainExecutor.execute(() -> {
	@@ -1009,88 +1007,37 @@ public class DefaultTransitionHandler implements Transitions.TransitionHandler {
	\|\| animType == ANIM_FROM_STYLE;		\|\| animType == ANIM_FROM_STYLE;
	}		}

	/** The animation adapter for buildSurfaceAnimation. */		private static void applyTransformation(long time, SurfaceControl.Transaction t,
	abstract static class AnimationAdapter implements ValueAnimator.AnimatorUpdateListener {		SurfaceControl leash, Animation anim, Transformation tmpTransformation, float[] matrix,
	@NonNull final SurfaceControl mLeash;		Point position, float cornerRadius, @Nullable Rect immutableClipRect,
	@NonNull SurfaceControl.Transaction mTransaction;
	private Choreographer mChoreographer;

	AnimationAdapter(@NonNull SurfaceControl leash) {
	mLeash = leash;
	}

	void setTransaction(@NonNull SurfaceControl.Transaction transaction) {
	mTransaction = transaction;
	}

	@Override
	public void onAnimationUpdate(@NonNull ValueAnimator animator) {
	applyTransformation(animator);
	if (mChoreographer == null) {
	mChoreographer = Choreographer.getInstance();
	}
	mTransaction.setFrameTimelineVsync(mChoreographer.getVsyncId());
	mTransaction.apply();
	}

	abstract void applyTransformation(@NonNull ValueAnimator animator);
	}

	private static class DefaultAnimationAdapter extends AnimationAdapter {
	final Transformation mTransformation = new Transformation();
	final float[] mMatrix = new float[9];
	@NonNull final Animation mAnim;
	@Nullable final Point mPosition;
	@Nullable final Rect mClipRect;
	final float mCornerRadius;
	final boolean mIsActivity;

	DefaultAnimationAdapter(@NonNull Animation anim, @NonNull SurfaceControl leash,
	@Nullable Point position, @Nullable Rect clipRect, float cornerRadius,
	boolean isActivity) {		boolean isActivity) {
	super(leash);		tmpTransformation.clear();
	mAnim = anim;		anim.getTransformation(time, tmpTransformation);
	mPosition = (position != null && (position.x != 0 \|\| position.y != 0))
	? position : null;
	mClipRect = (clipRect != null && !clipRect.isEmpty()) ? clipRect : null;
	mCornerRadius = cornerRadius;
	mIsActivity = isActivity;
	}

	@Override
	void applyTransformation(@NonNull ValueAnimator animator) {
	final long currentPlayTime = Math.min(animator.getDuration(),
	animator.getCurrentPlayTime());
	final Transformation transformation = mTransformation;
	final SurfaceControl.Transaction t = mTransaction;
	final SurfaceControl leash = mLeash;
	transformation.clear();
	mAnim.getTransformation(currentPlayTime, transformation);
	if (com.android.graphics.libgui.flags.Flags.edgeExtensionShader()		if (com.android.graphics.libgui.flags.Flags.edgeExtensionShader()
	&& mIsActivity && mAnim.getExtensionEdges() != 0) {		&& anim.getExtensionEdges() != 0x0 && isActivity) {
	t.setEdgeExtensionEffect(leash, mAnim.getExtensionEdges());		t.setEdgeExtensionEffect(leash, anim.getExtensionEdges());
	}		}
	if (mPosition != null) {		if (position != null) {
	transformation.getMatrix().postTranslate(mPosition.x, mPosition.y);		tmpTransformation.getMatrix().postTranslate(position.x, position.y);
	}		}
	t.setMatrix(leash, transformation.getMatrix(), mMatrix);		t.setMatrix(leash, tmpTransformation.getMatrix(), matrix);
	t.setAlpha(leash, transformation.getAlpha());		t.setAlpha(leash, tmpTransformation.getAlpha());

	if (mClipRect != null) {		final Rect clipRect = immutableClipRect == null ? null : new Rect(immutableClipRect);
	Rect clipRect = mClipRect;		Insets extensionInsets = Insets.min(tmpTransformation.getInsets(), Insets.NONE);
	final Insets extensionInsets = Insets.min(transformation.getInsets(), Insets.NONE);		if (!extensionInsets.equals(Insets.NONE) && clipRect != null && !clipRect.isEmpty()) {
	if (!extensionInsets.equals(Insets.NONE)) {		// Clip out any overflowing edge extension
	// Clip out any overflowing edge extension.
	clipRect = new Rect(mClipRect);
	clipRect.inset(extensionInsets);		clipRect.inset(extensionInsets);
	t.setCrop(leash, clipRect);		t.setCrop(leash, clipRect);
	}		}
	if (mCornerRadius > 0 && mAnim.hasRoundedCorners()) {
	// Rounded corner can only be applied if a crop is set.		if (anim.hasRoundedCorners() && cornerRadius > 0 && clipRect != null) {
			// We can only apply rounded corner if a crop is set
	t.setCrop(leash, clipRect);		t.setCrop(leash, clipRect);
	t.setCornerRadius(leash, mCornerRadius);		t.setCornerRadius(leash, cornerRadius);
	}
	}
	}		}

			t.setFrameTimelineVsync(Choreographer.getInstance().getVsyncId());
			t.apply();
	}		}
	}		}