Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 59f71093 authored by John Reck's avatar John Reck Committed by Android Git Automerger
Browse files

am 969f3860: am ad0faa70: Merge "Animator stuff" into lmp-dev 

* commit '969f3860d940bdcaa66441d561448cca92ebd8ea':
  Animator stuff
parents eebff5a5 eed938d2

core/java/android/view/HardwareRenderer.java

+2 −0
Original line number Diff line number Diff line
@@ -485,4 +485,6 @@ public abstract class HardwareRenderer { 
     * Called by {@link ViewRootImpl} when a new performTraverals is scheduled.

     */

    abstract void notifyFramePending();



    abstract void registerAnimatingRenderNode(RenderNode animator);

}

core/java/android/view/RenderNode.java

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



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

        mOwningView = owningView;

    }



    /**
@@ -178,6 +181,7 @@ public class RenderNode { 
     */

    private RenderNode(long nativePtr) {

        mNativeRenderNode = nativePtr;

        mOwningView = null;

    }



    /**
@@ -188,8 +192,8 @@ public class RenderNode { 
     *

     * @return A new RenderNode.

     */

    public static RenderNode create(String name) {

        return new RenderNode(name);

    public static RenderNode create(String name, @Nullable View owningView) {

        return new RenderNode(name, owningView);

    }



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



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

        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 nEndAllAnimators(long renderNode);



    ///////////////////////////////////////////////////////////////////////////

    // Finalization

core/java/android/view/RenderNodeAnimator.java

+18 −26
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ package android.view; 
import android.animation.Animator;

import android.animation.TimeInterpolator;

import android.animation.ValueAnimator;

import android.animation.Animator.AnimatorListener;

import android.graphics.Canvas;

import android.graphics.CanvasProperty;

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.NativeInterpolatorFactory;



import java.lang.ref.WeakReference;

import java.util.ArrayList;



/**
@@ -111,13 +109,11 @@ public class RenderNodeAnimator extends Animator { 
        mRenderProperty = property;

        mFinalValue = finalValue;

        mUiThreadHandlesDelay = true;

        init(nCreateAnimator(new WeakReference<RenderNodeAnimator>(this),

                property, finalValue));

        init(nCreateAnimator(property, finalValue));

    }



    public RenderNodeAnimator(CanvasProperty<Float> property, float finalValue) {

        init(nCreateCanvasPropertyFloatAnimator(

                new WeakReference<RenderNodeAnimator>(this),

                property.getNativeContainer(), finalValue));

        mUiThreadHandlesDelay = false;

    }
@@ -132,14 +128,12 @@ public class RenderNodeAnimator extends Animator { 
     */

    public RenderNodeAnimator(CanvasProperty<Paint> property, int paintField, float finalValue) {

        init(nCreateCanvasPropertyPaintAnimator(

                new WeakReference<RenderNodeAnimator>(this),

                property.getNativeContainer(), paintField, finalValue));

        mUiThreadHandlesDelay = false;

    }



    public RenderNodeAnimator(int x, int y, float startRadius, float endRadius) {

        init(nCreateRevealAnimator(new WeakReference<RenderNodeAnimator>(this),

                x, y, startRadius, endRadius));

        init(nCreateRevealAnimator(x, y, startRadius, endRadius));

        mUiThreadHandlesDelay = true;

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



    private void doStart() {

        nStart(mNativePtr.get());

        nStart(mNativePtr.get(), this);



        // Alpha is a special snowflake that has the canonical value stored

        // 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) {

        mViewTarget = view;

        mTarget = view.mRenderNode;

        mTarget.addAnimator(this);

        setTarget(mViewTarget.mRenderNode);

    }



    public void setTarget(Canvas canvas) {

        if (!(canvas instanceof GLES20RecordingCanvas)) {

            throw new IllegalArgumentException("Not a GLES20RecordingCanvas");

        }



        final GLES20RecordingCanvas recordingCanvas = (GLES20RecordingCanvas) canvas;

        setTarget(recordingCanvas.mNode);

    }



    public void setTarget(RenderNode node) {

    private void setTarget(RenderNode node) {

        if (mTarget != null) {

            throw new IllegalStateException("Target already set!");

        }

        mViewTarget = null;

        mTarget = node;

        mTarget.addAnimator(this);

    }
@@ -335,6 +326,12 @@ public class RenderNodeAnimator extends Animator { 
        for (int i = 0; i < numListeners; i++) {

            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")
@@ -427,34 +424,29 @@ public class RenderNodeAnimator extends Animator { 
    }



    // Called by native

    private static void callOnFinished(WeakReference<RenderNodeAnimator> weakThis) {

        RenderNodeAnimator animator = weakThis.get();

        if (animator != null) {

    private static void callOnFinished(RenderNodeAnimator animator) {

        animator.onFinished();

    }

    }



    @Override

    public Animator clone() {

        throw new IllegalStateException("Cannot clone this animator");

    }



    private static native long nCreateAnimator(WeakReference<RenderNodeAnimator> weakThis,

            int property, float finalValue);

    private static native long nCreateCanvasPropertyFloatAnimator(WeakReference<RenderNodeAnimator> weakThis,

    private static native long nCreateAnimator(int property, float finalValue);

    private static native long nCreateCanvasPropertyFloatAnimator(

            long canvasProperty, float finalValue);

    private static native long nCreateCanvasPropertyPaintAnimator(WeakReference<RenderNodeAnimator> weakThis,

    private static native long nCreateCanvasPropertyPaintAnimator(

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



    private static native void nSetStartValue(long nativePtr, float startValue);

    private static native void nSetDuration(long nativePtr, long duration);

    private static native long nGetDuration(long nativePtr);

    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 nStart(long animPtr);

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

    private static native void nEnd(long animPtr);

}

core/java/android/view/ThreadedRenderer.java

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


        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,

                recordDuration, view.getResources().getDisplayMetrics().density);

        if ((syncResult & SYNC_INVALIDATE_REQUIRED) != 0) {
@@ -369,6 +383,11 @@ public class ThreadedRenderer extends HardwareRenderer { 
        nNotifyFramePending(mNativeProxy);

    }



    @Override

    void registerAnimatingRenderNode(RenderNode animator) {

        nRegisterAnimatingRenderNode(mRootNode.mNativeRenderNode, animator.mNativeRenderNode);

    }



    @Override

    protected void finalize() throws Throwable {

        try {
@@ -466,6 +485,7 @@ public class ThreadedRenderer extends HardwareRenderer { 
    private static native int nSyncAndDrawFrame(long nativeProxy,

            long frameTimeNanos, long recordDuration, float density);

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

core/java/android/view/View.java

+5 −4
Original line number Diff line number Diff line
@@ -3565,7 +3565,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, 
        setOverScrollMode(OVER_SCROLL_IF_CONTENT_SCROLLS);

        mUserPaddingStart = UNDEFINED_PADDING;

        mUserPaddingEnd = UNDEFINED_PADDING;

        mRenderNode = RenderNode.create(getClass().getName());

        mRenderNode = RenderNode.create(getClass().getName(), this);















        if (!sCompatibilityDone && context != null) {















            final int targetSdkVersion = context.getApplicationInfo().targetSdkVersion;










@@ -4161,7 +4161,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,













     */















    View() {















        mResources = null;













        mRenderNode = RenderNode.create(getClass().getName());













        mRenderNode = RenderNode.create(getClass().getName(), this);















    }





























    private static SparseArray<String> getAttributeMap() {










@@ -15183,9 +15183,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,













     * @param renderNode Existing RenderNode, or {@code null}















     * @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) {













            renderNode = RenderNode.create(drawable.getClass().getName());













            renderNode = RenderNode.create(drawable.getClass().getName(), this);















        }





























        final Rect bounds = drawable.getBounds();










@@ -19911,6 +19911,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,













        boolean mHardwareAccelerated;















        boolean mHardwareAccelerationRequested;















        HardwareRenderer mHardwareRenderer;













        List<RenderNode> mPendingAnimatingRenderNodes;





























        /**















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