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

Commit ff941dcd authored by John Reck's avatar John Reck
Browse files

Animator start value... 

Change-Id: Ifd35ed95a28c625086d7fa97764fe63ab4a997f1
parent 951ecb77

core/java/android/view/RenderNodeAnimator.java

+9 −15
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ import android.graphics.Canvas; 
import android.graphics.CanvasProperty;

import android.graphics.Paint;

import android.util.SparseIntArray;

import android.util.TimeUtils;



import com.android.internal.util.VirtualRefBasePtr;

import com.android.internal.view.animation.FallbackLUTInterpolator;
@@ -72,10 +71,6 @@ public final class RenderNodeAnimator { 
        put(ViewPropertyAnimator.ALPHA, ALPHA);

    }};



    // Keep in sync DeltaValueType in Animator.h

    public static final int DELTA_TYPE_ABSOLUTE = 0;

    public static final int DELTA_TYPE_DELTA = 1;



    private VirtualRefBasePtr mNativePtr;



    private RenderNode mTarget;
@@ -86,22 +81,21 @@ public final class RenderNodeAnimator { 
        return sViewPropertyAnimatorMap.get(viewProperty);

    }



    public RenderNodeAnimator(int property, int deltaType, float deltaValue) {

    public RenderNodeAnimator(int property, float finalValue) {

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

                property, deltaType, deltaValue));

                property, finalValue));

    }



    public RenderNodeAnimator(CanvasProperty<Float> property, int deltaType, float deltaValue) {

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

        init(nCreateCanvasPropertyFloatAnimator(

                new WeakReference<RenderNodeAnimator>(this),

                property.getNativeContainer(), deltaType, deltaValue));

                property.getNativeContainer(), finalValue));

    }



    public RenderNodeAnimator(CanvasProperty<Paint> property, int paintField,

            int deltaType, float deltaValue) {

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

        init(nCreateCanvasPropertyPaintAnimator(

                new WeakReference<RenderNodeAnimator>(this),

                property.getNativeContainer(), paintField, deltaType, deltaValue));

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

    }



    private void init(long ptr) {
@@ -182,11 +176,11 @@ public final class RenderNodeAnimator { 
    }



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

            int property, int deltaValueType, float deltaValue);

            int property, float deltaValue);

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

            long canvasProperty, int deltaValueType, float deltaValue);

            long canvasProperty, float deltaValue);

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

            long canvasProperty, int paintField, int deltaValueType, float deltaValue);

            long canvasProperty, int paintField, float deltaValue);

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

    private static native int nGetDuration(long nativePtr);

    private static native void nSetInterpolator(long animPtr, long interpolatorPtr);

core/jni/android_view_RenderNode.cpp

+32 −0
Original line number Diff line number Diff line
@@ -80,6 +80,7 @@ static void android_view_RenderNode_setCaching(JNIEnv* env, 
        jobject clazz, jlong renderNodePtr, jboolean caching) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setCaching(caching);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setStaticMatrix(JNIEnv* env,
@@ -87,6 +88,7 @@ static void android_view_RenderNode_setStaticMatrix(JNIEnv* env, 
    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);

    renderNode->mutateStagingProperties().setStaticMatrix(matrix);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setAnimationMatrix(JNIEnv* env,
@@ -94,24 +96,28 @@ static void android_view_RenderNode_setAnimationMatrix(JNIEnv* env, 
    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);

    renderNode->mutateStagingProperties().setAnimationMatrix(matrix);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setClipToBounds(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, jboolean clipToBounds) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setClipToBounds(clipToBounds);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setProjectBackwards(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, jboolean shouldProject) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setProjectBackwards(shouldProject);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setProjectionReceiver(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setProjectionReceiver(shouldRecieve);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setOutlineRoundRect(JNIEnv* env,
@@ -119,6 +125,7 @@ static void android_view_RenderNode_setOutlineRoundRect(JNIEnv* env, 
        jint right, jint bottom, jfloat radius) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setOutlineConvexPath(JNIEnv* env,
@@ -126,18 +133,21 @@ static void android_view_RenderNode_setOutlineConvexPath(JNIEnv* env, 
    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr);

    renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setOutlineEmpty(JNIEnv* env,

        jobject clazz, jlong renderNodePtr) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().mutableOutline().setEmpty();

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setClipToOutline(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, jboolean clipToOutline) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setRevealClip(JNIEnv* env,
@@ -146,114 +156,133 @@ static void android_view_RenderNode_setRevealClip(JNIEnv* env, 
    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().mutableRevealClip().set(

            shouldClip, inverseClip, x, y, radius);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setAlpha(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float alpha) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setAlpha(alpha);

    renderNode->setPropertyFieldsDirty(RenderNode::ALPHA);

}



static void android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setHasOverlappingRendering(hasOverlappingRendering);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setElevation(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float elevation) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setElevation(elevation);

    renderNode->setPropertyFieldsDirty(RenderNode::Z);

}



static void android_view_RenderNode_setTranslationX(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float tx) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setTranslationX(tx);

    renderNode->setPropertyFieldsDirty(RenderNode::TRANSLATION_X | RenderNode::X);

}



static void android_view_RenderNode_setTranslationY(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float ty) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setTranslationY(ty);

    renderNode->setPropertyFieldsDirty(RenderNode::TRANSLATION_Y | RenderNode::Y);

}



static void android_view_RenderNode_setTranslationZ(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float tz) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setTranslationZ(tz);

    renderNode->setPropertyFieldsDirty(RenderNode::TRANSLATION_Z | RenderNode::Z);

}



static void android_view_RenderNode_setRotation(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float rotation) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setRotation(rotation);

    renderNode->setPropertyFieldsDirty(RenderNode::ROTATION);

}



static void android_view_RenderNode_setRotationX(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float rx) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setRotationX(rx);

    renderNode->setPropertyFieldsDirty(RenderNode::ROTATION_X);

}



static void android_view_RenderNode_setRotationY(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float ry) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setRotationY(ry);

    renderNode->setPropertyFieldsDirty(RenderNode::ROTATION_Y);

}



static void android_view_RenderNode_setScaleX(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float sx) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setScaleX(sx);

    renderNode->setPropertyFieldsDirty(RenderNode::SCALE_X);

}



static void android_view_RenderNode_setScaleY(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float sy) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setScaleY(sy);

    renderNode->setPropertyFieldsDirty(RenderNode::SCALE_Y);

}



static void android_view_RenderNode_setPivotX(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float px) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setPivotX(px);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setPivotY(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float py) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setPivotY(py);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setCameraDistance(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float distance) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setCameraDistance(distance);

    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);

}



static void android_view_RenderNode_setLeft(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, int left) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setLeft(left);

    renderNode->setPropertyFieldsDirty(RenderNode::X);

}



static void android_view_RenderNode_setTop(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, int top) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setTop(top);

    renderNode->setPropertyFieldsDirty(RenderNode::Y);

}



static void android_view_RenderNode_setRight(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, int right) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setRight(right);

    renderNode->setPropertyFieldsDirty(RenderNode::X);

}



static void android_view_RenderNode_setBottom(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, int bottom) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setBottom(bottom);

    renderNode->setPropertyFieldsDirty(RenderNode::Y);

}



static void android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env,
@@ -261,18 +290,21 @@ static void android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env, 
        int right, int bottom) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom);

    renderNode->setPropertyFieldsDirty(RenderNode::X | RenderNode::Y);

}



static void android_view_RenderNode_offsetLeftAndRight(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float offset) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().offsetLeftRight(offset);

    renderNode->setPropertyFieldsDirty(RenderNode::X);

}



static void android_view_RenderNode_offsetTopAndBottom(JNIEnv* env,

        jobject clazz, jlong renderNodePtr, float offset) {

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    renderNode->mutateStagingProperties().offsetTopBottom(offset);

    renderNode->setPropertyFieldsDirty(RenderNode::Y);

}



// ----------------------------------------------------------------------------

core/jni/android_view_RenderNodeAnimator.cpp

+14 −24
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ public: 
        mWeakThis = NULL;

    }



    virtual void onAnimationFinished(BaseAnimator*) {

    virtual void onAnimationFinished(BaseRenderNodeAnimator*) {

        JNIEnv* env = getEnv(mJvm);

        env->CallStaticVoidMethod(

                gRenderNodeAnimatorClassInfo.clazz,
@@ -81,13 +81,6 @@ static inline RenderPropertyAnimator::RenderProperty toRenderProperty(jint prope 
    return static_cast<RenderPropertyAnimator::RenderProperty>(property);

}



static inline RenderPropertyAnimator::DeltaValueType toDeltaType(jint deltaType) {

    LOG_ALWAYS_FATAL_IF(deltaType != RenderPropertyAnimator::DELTA

            && deltaType != RenderPropertyAnimator::ABSOLUTE,

            "Invalid delta type %d", deltaType);

    return static_cast<RenderPropertyAnimator::DeltaValueType>(deltaType);

}



static inline CanvasPropertyPaintAnimator::PaintField toPaintField(jint field) {

    LOG_ALWAYS_FATAL_IF(field < 0

            || field > CanvasPropertyPaintAnimator::ALPHA,
@@ -96,49 +89,46 @@ static inline CanvasPropertyPaintAnimator::PaintField toPaintField(jint field) { 
}



static jlong createAnimator(JNIEnv* env, jobject clazz, jobject weakThis,

        jint propertyRaw, jint deltaTypeRaw, jfloat deltaValue) {

        jint propertyRaw, jfloat finalValue) {

    RenderPropertyAnimator::RenderProperty property = toRenderProperty(propertyRaw);

    RenderPropertyAnimator::DeltaValueType deltaType = toDeltaType(deltaTypeRaw);



    BaseAnimator* animator = new RenderPropertyAnimator(property, deltaType, deltaValue);

    BaseRenderNodeAnimator* animator = new RenderPropertyAnimator(property, finalValue);

    animator->setListener(new AnimationListenerBridge(env, weakThis));

    return reinterpret_cast<jlong>( animator );

}



static jlong createCanvasPropertyFloatAnimator(JNIEnv* env, jobject clazz,

        jobject weakThis, jlong canvasPropertyPtr, jint deltaTypeRaw, jfloat deltaValue) {

    RenderPropertyAnimator::DeltaValueType deltaType = toDeltaType(deltaTypeRaw);

        jobject weakThis, jlong canvasPropertyPtr, jfloat finalValue) {

    CanvasPropertyPrimitive* canvasProperty = reinterpret_cast<CanvasPropertyPrimitive*>(canvasPropertyPtr);

    BaseAnimator* animator = new CanvasPropertyPrimitiveAnimator(canvasProperty, deltaType, deltaValue);

    BaseRenderNodeAnimator* animator = new CanvasPropertyPrimitiveAnimator(canvasProperty, finalValue);

    animator->setListener(new AnimationListenerBridge(env, weakThis));

    return reinterpret_cast<jlong>( animator );

}



static jlong createCanvasPropertyPaintAnimator(JNIEnv* env, jobject clazz,

        jobject weakThis, jlong canvasPropertyPtr, jint paintFieldRaw,

        jint deltaTypeRaw, jfloat deltaValue) {

    RenderPropertyAnimator::DeltaValueType deltaType = toDeltaType(deltaTypeRaw);

        jfloat finalValue) {

    CanvasPropertyPaint* canvasProperty = reinterpret_cast<CanvasPropertyPaint*>(canvasPropertyPtr);

    CanvasPropertyPaintAnimator::PaintField paintField = toPaintField(paintFieldRaw);

    BaseAnimator* animator = new CanvasPropertyPaintAnimator(

            canvasProperty, paintField, deltaType, deltaValue);

    BaseRenderNodeAnimator* animator = new CanvasPropertyPaintAnimator(

            canvasProperty, paintField, finalValue);

    animator->setListener(new AnimationListenerBridge(env, weakThis));

    return reinterpret_cast<jlong>( animator );

}



static void setDuration(JNIEnv* env, jobject clazz, jlong animatorPtr, jint duration) {

    LOG_ALWAYS_FATAL_IF(duration < 0, "Duration cannot be negative");

    BaseAnimator* animator = reinterpret_cast<BaseAnimator*>(animatorPtr);

    BaseRenderNodeAnimator* animator = reinterpret_cast<BaseRenderNodeAnimator*>(animatorPtr);

    animator->setDuration(duration);

}



static jint getDuration(JNIEnv* env, jobject clazz, jlong animatorPtr) {

    BaseAnimator* animator = reinterpret_cast<BaseAnimator*>(animatorPtr);

    BaseRenderNodeAnimator* animator = reinterpret_cast<BaseRenderNodeAnimator*>(animatorPtr);

    return static_cast<jint>(animator->duration());

}



static void setInterpolator(JNIEnv* env, jobject clazz, jlong animatorPtr, jlong interpolatorPtr) {

    BaseAnimator* animator = reinterpret_cast<BaseAnimator*>(animatorPtr);

    BaseRenderNodeAnimator* animator = reinterpret_cast<BaseRenderNodeAnimator*>(animatorPtr);

    Interpolator* interpolator = reinterpret_cast<Interpolator*>(interpolatorPtr);

    animator->setInterpolator(interpolator);

}
@@ -153,9 +143,9 @@ const char* const kClassPathName = "android/view/RenderNodeAnimator"; 


static JNINativeMethod gMethods[] = {

#ifdef USE_OPENGL_RENDERER

    { "nCreateAnimator", "(Ljava/lang/ref/WeakReference;IIF)J", (void*) createAnimator },

    { "nCreateCanvasPropertyFloatAnimator", "(Ljava/lang/ref/WeakReference;JIF)J", (void*) createCanvasPropertyFloatAnimator },

    { "nCreateCanvasPropertyPaintAnimator", "(Ljava/lang/ref/WeakReference;JIIF)J", (void*) createCanvasPropertyPaintAnimator },

    { "nCreateAnimator", "(Ljava/lang/ref/WeakReference;IF)J", (void*) createAnimator },

    { "nCreateCanvasPropertyFloatAnimator", "(Ljava/lang/ref/WeakReference;JF)J", (void*) createCanvasPropertyFloatAnimator },

    { "nCreateCanvasPropertyPaintAnimator", "(Ljava/lang/ref/WeakReference;JIF)J", (void*) createCanvasPropertyPaintAnimator },

    { "nSetDuration", "(JI)V", (void*) setDuration },

    { "nGetDuration", "(J)I", (void*) getDuration },

    { "nSetInterpolator", "(JJ)V", (void*) setInterpolator },

core/jni/android_view_ThreadedRenderer.cpp

+3 −3
Original line number Diff line number Diff line
@@ -92,9 +92,9 @@ private: 


class OnFinishedEvent {

public:

    OnFinishedEvent(BaseAnimator* animator, AnimationListener* listener)

    OnFinishedEvent(BaseRenderNodeAnimator* animator, AnimationListener* listener)

            : animator(animator), listener(listener) {}

    sp<BaseAnimator> animator;

    sp<BaseRenderNodeAnimator> animator;

    sp<AnimationListener> listener;

};
@@ -127,7 +127,7 @@ public: 


    virtual ~RootRenderNode() {}



    virtual void callOnFinished(BaseAnimator* animator, AnimationListener* listener) {

    virtual void callOnFinished(BaseRenderNodeAnimator* animator, AnimationListener* listener) {

        OnFinishedEvent event(animator, listener);

        mOnFinishedEvents.push_back(event);

    }

libs/hwui/Animator.cpp

+69 −76

File changed.

Preview size limit exceeded, changes collapsed.