Animator stuff (119907cd) · Commits · e / os / android_frameworks_base

core/java/android/view/HardwareRenderer.java

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -485,4 +485,6 @@ public abstract class HardwareRenderer {
	* Called by {@link ViewRootImpl} when a new performTraverals is scheduled.		* Called by {@link ViewRootImpl} when a new performTraverals is scheduled.
	*/		*/
	abstract void notifyFramePending();		abstract void notifyFramePending();

			abstract void registerAnimatingRenderNode(RenderNode animator);
	}		}

core/java/android/view/RenderNode.java

+17 −4

Original line number	Original line	Diff line number	Diff line
	@@ -167,10 +167,13 @@ public class RenderNode {
	public static final int STATUS_DREW = 0x4;		public static final int STATUS_DREW = 0x4;

	private boolean mValid;		private boolean mValid;
	private final long mNativeRenderNode;		// Do not access directly unless you are ThreadedRenderer
			final long mNativeRenderNode;
			private final View mOwningView;

	private RenderNode(String name) {		private RenderNode(String name, View owningView) {
	mNativeRenderNode = nCreate(name);		mNativeRenderNode = nCreate(name);
			mOwningView = owningView;
	}		}

	/**		/**
	@@ -178,6 +181,7 @@ public class RenderNode {
	*/		*/
	private RenderNode(long nativePtr) {		private RenderNode(long nativePtr) {
	mNativeRenderNode = nativePtr;		mNativeRenderNode = nativePtr;
			mOwningView = null;
	}		}

	/**		/**
	@@ -188,8 +192,8 @@ public class RenderNode {
	*		*
	* @return A new RenderNode.		* @return A new RenderNode.
	*/		*/
	public static RenderNode create(String name) {		public static RenderNode create(String name, @Nullable View owningView) {
	return new RenderNode(name);		return new RenderNode(name, owningView);
	}		}

	/**		/**
	@@ -805,7 +809,15 @@ public class RenderNode {
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////

	public void addAnimator(RenderNodeAnimator animator) {		public void addAnimator(RenderNodeAnimator animator) {
			if (mOwningView == null \|\| mOwningView.mAttachInfo == null) {
			throw new IllegalStateException("Cannot start this animator on a detached view!");
			}
	nAddAnimator(mNativeRenderNode, animator.getNativeAnimator());		nAddAnimator(mNativeRenderNode, animator.getNativeAnimator());
			mOwningView.mAttachInfo.mViewRootImpl.registerAnimatingRenderNode(this);
			}

			public void endAllAnimators() {
			nEndAllAnimators(mNativeRenderNode);
	}		}

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	@@ -891,6 +903,7 @@ public class RenderNode {
	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////

	private static native void nAddAnimator(long renderNode, long animatorPtr);		private static native void nAddAnimator(long renderNode, long animatorPtr);
			private static native void nEndAllAnimators(long renderNode);

	///////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////
	// Finalization		// Finalization

core/java/android/view/RenderNodeAnimator.java

+18 −26

Original line number	Original line	Diff line number	Diff line
	@@ -19,7 +19,6 @@ package android.view;
	import android.animation.Animator;		import android.animation.Animator;
	import android.animation.TimeInterpolator;		import android.animation.TimeInterpolator;
	import android.animation.ValueAnimator;		import android.animation.ValueAnimator;
	import android.animation.Animator.AnimatorListener;
	import android.graphics.Canvas;		import android.graphics.Canvas;
	import android.graphics.CanvasProperty;		import android.graphics.CanvasProperty;
	import android.graphics.Paint;		import android.graphics.Paint;
	@@ -30,7 +29,6 @@ import com.android.internal.view.animation.FallbackLUTInterpolator;
	import com.android.internal.view.animation.HasNativeInterpolator;		import com.android.internal.view.animation.HasNativeInterpolator;
	import com.android.internal.view.animation.NativeInterpolatorFactory;		import com.android.internal.view.animation.NativeInterpolatorFactory;

	import java.lang.ref.WeakReference;
	import java.util.ArrayList;		import java.util.ArrayList;

	/**		/**
	@@ -111,13 +109,11 @@ public class RenderNodeAnimator extends Animator {
	mRenderProperty = property;		mRenderProperty = property;
	mFinalValue = finalValue;		mFinalValue = finalValue;
	mUiThreadHandlesDelay = true;		mUiThreadHandlesDelay = true;
	init(nCreateAnimator(new WeakReference<RenderNodeAnimator>(this),		init(nCreateAnimator(property, finalValue));
	property, finalValue));
	}		}

	public RenderNodeAnimator(CanvasProperty<Float> property, float finalValue) {		public RenderNodeAnimator(CanvasProperty<Float> property, float finalValue) {
	init(nCreateCanvasPropertyFloatAnimator(		init(nCreateCanvasPropertyFloatAnimator(
	new WeakReference<RenderNodeAnimator>(this),
	property.getNativeContainer(), finalValue));		property.getNativeContainer(), finalValue));
	mUiThreadHandlesDelay = false;		mUiThreadHandlesDelay = false;
	}		}
	@@ -132,14 +128,12 @@ public class RenderNodeAnimator extends Animator {
	*/		*/
	public RenderNodeAnimator(CanvasProperty<Paint> property, int paintField, float finalValue) {		public RenderNodeAnimator(CanvasProperty<Paint> property, int paintField, float finalValue) {
	init(nCreateCanvasPropertyPaintAnimator(		init(nCreateCanvasPropertyPaintAnimator(
	new WeakReference<RenderNodeAnimator>(this),
	property.getNativeContainer(), paintField, finalValue));		property.getNativeContainer(), paintField, finalValue));
	mUiThreadHandlesDelay = false;		mUiThreadHandlesDelay = false;
	}		}

	public RenderNodeAnimator(int x, int y, float startRadius, float endRadius) {		public RenderNodeAnimator(int x, int y, float startRadius, float endRadius) {
	init(nCreateRevealAnimator(new WeakReference<RenderNodeAnimator>(this),		init(nCreateRevealAnimator(x, y, startRadius, endRadius));
	x, y, startRadius, endRadius));
	mUiThreadHandlesDelay = true;		mUiThreadHandlesDelay = true;
	}		}

	@@ -192,7 +186,7 @@ public class RenderNodeAnimator extends Animator {
	}		}

	private void doStart() {		private void doStart() {
	nStart(mNativePtr.get());		nStart(mNativePtr.get(), this);

	// Alpha is a special snowflake that has the canonical value stored		// Alpha is a special snowflake that has the canonical value stored
	// in mTransformationInfo instead of in RenderNode, so we need to update		// in mTransformationInfo instead of in RenderNode, so we need to update
	@@ -248,24 +242,21 @@ public class RenderNodeAnimator extends Animator {

	public void setTarget(View view) {		public void setTarget(View view) {
	mViewTarget = view;		mViewTarget = view;
	mTarget = view.mRenderNode;		setTarget(mViewTarget.mRenderNode);
	mTarget.addAnimator(this);
	}		}

	public void setTarget(Canvas canvas) {		public void setTarget(Canvas canvas) {
	if (!(canvas instanceof GLES20RecordingCanvas)) {		if (!(canvas instanceof GLES20RecordingCanvas)) {
	throw new IllegalArgumentException("Not a GLES20RecordingCanvas");		throw new IllegalArgumentException("Not a GLES20RecordingCanvas");
	}		}

	final GLES20RecordingCanvas recordingCanvas = (GLES20RecordingCanvas) canvas;		final GLES20RecordingCanvas recordingCanvas = (GLES20RecordingCanvas) canvas;
	setTarget(recordingCanvas.mNode);		setTarget(recordingCanvas.mNode);
	}		}

	public void setTarget(RenderNode node) {		private void setTarget(RenderNode node) {
	if (mTarget != null) {		if (mTarget != null) {
	throw new IllegalStateException("Target already set!");		throw new IllegalStateException("Target already set!");
	}		}
	mViewTarget = null;
	mTarget = node;		mTarget = node;
	mTarget.addAnimator(this);		mTarget.addAnimator(this);
	}		}
	@@ -335,6 +326,12 @@ public class RenderNodeAnimator extends Animator {
	for (int i = 0; i < numListeners; i++) {		for (int i = 0; i < numListeners; i++) {
	listeners.get(i).onAnimationEnd(this);		listeners.get(i).onAnimationEnd(this);
	}		}

			// Release the native object, as it has a global reference to us. This
			// breaks the cyclic reference chain, and allows this object to be
			// GC'd
			mNativePtr.release();
			mNativePtr = null;
	}		}

	@SuppressWarnings("unchecked")		@SuppressWarnings("unchecked")
	@@ -427,34 +424,29 @@ public class RenderNodeAnimator extends Animator {
	}		}

	// Called by native		// Called by native
	private static void callOnFinished(WeakReference<RenderNodeAnimator> weakThis) {		private static void callOnFinished(RenderNodeAnimator animator) {
	RenderNodeAnimator animator = weakThis.get();
	if (animator != null) {
	animator.onFinished();		animator.onFinished();
	}		}
	}

	@Override		@Override
	public Animator clone() {		public Animator clone() {
	throw new IllegalStateException("Cannot clone this animator");		throw new IllegalStateException("Cannot clone this animator");
	}		}

	private static native long nCreateAnimator(WeakReference<RenderNodeAnimator> weakThis,		private static native long nCreateAnimator(int property, float finalValue);
	int property, float finalValue);		private static native long nCreateCanvasPropertyFloatAnimator(
	private static native long nCreateCanvasPropertyFloatAnimator(WeakReference<RenderNodeAnimator> weakThis,
	long canvasProperty, float finalValue);		long canvasProperty, float finalValue);
	private static native long nCreateCanvasPropertyPaintAnimator(WeakReference<RenderNodeAnimator> weakThis,		private static native long nCreateCanvasPropertyPaintAnimator(
	long canvasProperty, int paintField, float finalValue);		long canvasProperty, int paintField, float finalValue);
	private static native long nCreateRevealAnimator(WeakReference<RenderNodeAnimator> weakThis,		private static native long nCreateRevealAnimator(
	int x, int y, float startRadius, float endRadius);		int x, int y, float startRadius, float endRadius);

	private static native void nSetStartValue(long nativePtr, float startValue);		private static native void nSetStartValue(long nativePtr, float startValue);
	private static native void nSetDuration(long nativePtr, long duration);		private static native void nSetDuration(long nativePtr, long duration);
	private static native long nGetDuration(long nativePtr);		private static native long nGetDuration(long nativePtr);
	private static native void nSetStartDelay(long nativePtr, long startDelay);		private static native void nSetStartDelay(long nativePtr, long startDelay);
	private static native long nGetStartDelay(long nativePtr);
	private static native void nSetInterpolator(long animPtr, long interpolatorPtr);		private static native void nSetInterpolator(long animPtr, long interpolatorPtr);

	private static native void nStart(long animPtr);		private static native void nStart(long animPtr, RenderNodeAnimator finishListener);
	private static native void nEnd(long animPtr);		private static native void nEnd(long animPtr);
	}		}

core/java/android/view/ThreadedRenderer.java

+20 −0

Original line number	Original line	Diff line number	Diff line
	@@ -314,6 +314,20 @@ public class ThreadedRenderer extends HardwareRenderer {

	attachInfo.mIgnoreDirtyState = false;		attachInfo.mIgnoreDirtyState = false;

			// register animating rendernodes which started animating prior to renderer
			// creation, which is typical for animators started prior to first draw
			if (attachInfo.mPendingAnimatingRenderNodes != null) {
			final int count = attachInfo.mPendingAnimatingRenderNodes.size();
			for (int i = 0; i < count; i++) {
			registerAnimatingRenderNode(
			attachInfo.mPendingAnimatingRenderNodes.get(i));
			}
			attachInfo.mPendingAnimatingRenderNodes.clear();
			// We don't need this anymore as subsequent calls to
			// ViewRootImpl#attachRenderNodeAnimator will go directly to us.
			attachInfo.mPendingAnimatingRenderNodes = null;
			}

	int syncResult = nSyncAndDrawFrame(mNativeProxy, frameTimeNanos,		int syncResult = nSyncAndDrawFrame(mNativeProxy, frameTimeNanos,
	recordDuration, view.getResources().getDisplayMetrics().density);		recordDuration, view.getResources().getDisplayMetrics().density);
	if ((syncResult & SYNC_INVALIDATE_REQUIRED) != 0) {		if ((syncResult & SYNC_INVALIDATE_REQUIRED) != 0) {
	@@ -371,6 +385,11 @@ public class ThreadedRenderer extends HardwareRenderer {
	nNotifyFramePending(mNativeProxy);		nNotifyFramePending(mNativeProxy);
	}		}

			@Override
			void registerAnimatingRenderNode(RenderNode animator) {
			nRegisterAnimatingRenderNode(mRootNode.mNativeRenderNode, animator.mNativeRenderNode);
			}

	@Override		@Override
	protected void finalize() throws Throwable {		protected void finalize() throws Throwable {
	try {		try {
	@@ -468,6 +487,7 @@ public class ThreadedRenderer extends HardwareRenderer {
	private static native int nSyncAndDrawFrame(long nativeProxy,		private static native int nSyncAndDrawFrame(long nativeProxy,
	long frameTimeNanos, long recordDuration, float density);		long frameTimeNanos, long recordDuration, float density);
	private static native void nDestroyCanvasAndSurface(long nativeProxy);		private static native void nDestroyCanvasAndSurface(long nativeProxy);
			private static native void nRegisterAnimatingRenderNode(long rootRenderNode, long animatingNode);

	private static native void nInvokeFunctor(long functor, boolean waitForCompletion);		private static native void nInvokeFunctor(long functor, boolean waitForCompletion);

core/java/android/view/View.java

+5 −4

Original line number	Original line	Diff line number	Diff line
	@@ -3565,7 +3565,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
	setOverScrollMode(OVER_SCROLL_IF_CONTENT_SCROLLS);		setOverScrollMode(OVER_SCROLL_IF_CONTENT_SCROLLS);
	mUserPaddingStart = UNDEFINED_PADDING;		mUserPaddingStart = UNDEFINED_PADDING;
	mUserPaddingEnd = UNDEFINED_PADDING;		mUserPaddingEnd = UNDEFINED_PADDING;
	mRenderNode = RenderNode.create(getClass().getName());		mRenderNode = RenderNode.create(getClass().getName(), this);

	if (!sCompatibilityDone && context != null) {		if (!sCompatibilityDone && context != null) {
	final int targetSdkVersion = context.getApplicationInfo().targetSdkVersion;		final int targetSdkVersion = context.getApplicationInfo().targetSdkVersion;
	@@ -4161,7 +4161,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
	*/		*/
	View() {		View() {
	mResources = null;		mResources = null;
	mRenderNode = RenderNode.create(getClass().getName());		mRenderNode = RenderNode.create(getClass().getName(), this);
	}		}

	private static SparseArray<String> getAttributeMap() {		private static SparseArray<String> getAttributeMap() {
	@@ -15180,9 +15180,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
	* @param renderNode Existing RenderNode, or {@code null}		* @param renderNode Existing RenderNode, or {@code null}
	* @return A valid display list for the specified drawable		* @return A valid display list for the specified drawable
	*/		*/
	private static RenderNode getDrawableRenderNode(Drawable drawable, RenderNode renderNode) {		private RenderNode getDrawableRenderNode(Drawable drawable, RenderNode renderNode) {
	if (renderNode == null) {		if (renderNode == null) {
	renderNode = RenderNode.create(drawable.getClass().getName());		renderNode = RenderNode.create(drawable.getClass().getName(), this);
	}		}

	final Rect bounds = drawable.getBounds();		final Rect bounds = drawable.getBounds();
	@@ -19908,6 +19908,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
	boolean mHardwareAccelerated;		boolean mHardwareAccelerated;
	boolean mHardwareAccelerationRequested;		boolean mHardwareAccelerationRequested;
	HardwareRenderer mHardwareRenderer;		HardwareRenderer mHardwareRenderer;
			List<RenderNode> mPendingAnimatingRenderNodes;

	/**		/**
	* The state of the display to which the window is attached, as reported		* The state of the display to which the window is attached, as reported