FileDocCategorySizeDatePackage
PropertyValuesHolder.javaAPI DocAndroid 5.1 API73990Thu Mar 12 22:22:08 GMT 2015android.animation

PropertyValuesHolder

public class PropertyValuesHolder extends Object implements Cloneable
This class holds information about a property and the values that that property should take on during an animation. PropertyValuesHolder objects can be used to create animations with ValueAnimator or ObjectAnimator that operate on several different properties in parallel.

Fields Summary
String
mPropertyName
The name of the property associated with the values. This need not be a real property, unless this object is being used with ObjectAnimator. But this is the name by which aniamted values are looked up with getAnimatedValue(String) in ValueAnimator.
protected android.util.Property
mProperty
Method
mSetter
The setter function, if needed. ObjectAnimator hands off this functionality to PropertyValuesHolder, since it holds all of the per-property information. This property is automatically derived when the animation starts in setupSetterAndGetter() if using ObjectAnimator.
private Method
mGetter
The getter function, if needed. ObjectAnimator hands off this functionality to PropertyValuesHolder, since it holds all of the per-property information. This property is automatically derived when the animation starts in setupSetterAndGetter() if using ObjectAnimator. The getter is only derived and used if one of the values is null.
Class
mValueType
The type of values supplied. This information is used both in deriving the setter/getter functions and in deriving the type of TypeEvaluator.
Keyframes
mKeyframes
The set of keyframes (time/value pairs) that define this animation.
private static final TypeEvaluator
sIntEvaluator
private static final TypeEvaluator
sFloatEvaluator
private static Class[]
FLOAT_VARIANTS
private static Class[]
INTEGER_VARIANTS
private static Class[]
DOUBLE_VARIANTS
private static final HashMap
sSetterPropertyMap
private static final HashMap
sGetterPropertyMap
final Object[]
mTmpValueArray
private TypeEvaluator
mEvaluator
The type evaluator used to calculate the animated values. This evaluator is determined automatically based on the type of the start/end objects passed into the constructor, but the system only knows about the primitive types int and float. Any other type will need to set the evaluator to a custom evaluator for that type.
private Object
mAnimatedValue
The value most recently calculated by calculateValue(). This is set during that function and might be retrieved later either by ValueAnimator.animatedValue() or by the property-setting logic in ObjectAnimator.animatedValue().
private TypeConverter
mConverter
Converts from the source Object type to the setter Object type.
Constructors Summary
private PropertyValuesHolder(String propertyName)
Internal utility constructor, used by the factory methods to set the property name.

param
propertyName The name of the property for this holder.


                                
       
        mPropertyName = propertyName;
    
private PropertyValuesHolder(android.util.Property property)
Internal utility constructor, used by the factory methods to set the property.

param
property The property for this holder.

        mProperty = property;
        if (property != null) {
            mPropertyName = property.getName();
        }
    
Methods Summary
voidcalculateValue(float fraction)
Function used to calculate the value according to the evaluator set up for this PropertyValuesHolder object. This function is called by ValueAnimator.animateValue().

param
fraction The elapsed, interpolated fraction of the animation.

        Object value = mKeyframes.getValue(fraction);
        mAnimatedValue = mConverter == null ? value : mConverter.convert(value);
    
public android.animation.PropertyValuesHolderclone()

        try {
            PropertyValuesHolder newPVH = (PropertyValuesHolder) super.clone();
            newPVH.mPropertyName = mPropertyName;
            newPVH.mProperty = mProperty;
            newPVH.mKeyframes = mKeyframes.clone();
            newPVH.mEvaluator = mEvaluator;
            return newPVH;
        } catch (CloneNotSupportedException e) {
            // won't reach here
            return null;
        }
    
private java.lang.ObjectconvertBack(java.lang.Object value)

        if (mConverter != null) {
            if (!(mConverter instanceof BidirectionalTypeConverter)) {
                throw new IllegalArgumentException("Converter "
                        + mConverter.getClass().getName()
                        + " must be a BidirectionalTypeConverter");
            }
            value = ((BidirectionalTypeConverter) mConverter).convertBack(value);
        }
        return value;
    
java.lang.ObjectgetAnimatedValue()
Internal function, called by ValueAnimator and ObjectAnimator, to retrieve the value most recently calculated in calculateValue().

return

        return mAnimatedValue;
    
static java.lang.StringgetMethodName(java.lang.String prefix, java.lang.String propertyName)
Utility method to derive a setter/getter method name from a property name, where the prefix is typically "set" or "get" and the first letter of the property name is capitalized.

param
prefix The precursor to the method name, before the property name begins, typically "set" or "get".
param
propertyName The name of the property that represents the bulk of the method name after the prefix. The first letter of this word will be capitalized in the resulting method name.
return
String the property name converted to a method name according to the conventions specified above.

        if (propertyName == null || propertyName.length() == 0) {
            // shouldn't get here
            return prefix;
        }
        char firstLetter = Character.toUpperCase(propertyName.charAt(0));
        String theRest = propertyName.substring(1);
        return prefix + firstLetter + theRest;
    
private java.lang.reflect.MethodgetPropertyFunction(java.lang.Class targetClass, java.lang.String prefix, java.lang.Class valueType)
Determine the setter or getter function using the JavaBeans convention of setFoo or getFoo for a property named 'foo'. This function figures out what the name of the function should be and uses reflection to find the Method with that name on the target object.

param
targetClass The class to search for the method
param
prefix "set" or "get", depending on whether we need a setter or getter.
param
valueType The type of the parameter (in the case of a setter). This type is derived from the values set on this PropertyValuesHolder. This type is used as a first guess at the parameter type, but we check for methods with several different types to avoid problems with slight mis-matches between supplied values and actual value types used on the setter.
return
Method the method associated with mPropertyName.

        // TODO: faster implementation...
        Method returnVal = null;
        String methodName = getMethodName(prefix, mPropertyName);
        Class args[] = null;
        if (valueType == null) {
            try {
                returnVal = targetClass.getMethod(methodName, args);
            } catch (NoSuchMethodException e) {
                // Swallow the error, log it later
            }
        } else {
            args = new Class[1];
            Class typeVariants[];
            if (valueType.equals(Float.class)) {
                typeVariants = FLOAT_VARIANTS;
            } else if (valueType.equals(Integer.class)) {
                typeVariants = INTEGER_VARIANTS;
            } else if (valueType.equals(Double.class)) {
                typeVariants = DOUBLE_VARIANTS;
            } else {
                typeVariants = new Class[1];
                typeVariants[0] = valueType;
            }
            for (Class typeVariant : typeVariants) {
                args[0] = typeVariant;
                try {
                    returnVal = targetClass.getMethod(methodName, args);
                    if (mConverter == null) {
                        // change the value type to suit
                        mValueType = typeVariant;
                    }
                    return returnVal;
                } catch (NoSuchMethodException e) {
                    // Swallow the error and keep trying other variants
                }
            }
            // If we got here, then no appropriate function was found
        }

        if (returnVal == null) {
            Log.w("PropertyValuesHolder", "Method " +
                    getMethodName(prefix, mPropertyName) + "() with type " + valueType +
                    " not found on target class " + targetClass);
        }

        return returnVal;
    
public java.lang.StringgetPropertyName()
Gets the name of the property that will be animated. This name will be used to derive a setter function that will be called to set animated values. For example, a property name of foo will result in a call to the function setFoo() on the target object. If either valueFrom or valueTo is null, then a getter function will also be derived and called.

        return mPropertyName;
    
voidinit()
Internal function, called by ValueAnimator, to set up the TypeEvaluator that will be used to calculate animated values.

        if (mEvaluator == null) {
            // We already handle int and float automatically, but not their Object
            // equivalents
            mEvaluator = (mValueType == Integer.class) ? sIntEvaluator :
                    (mValueType == Float.class) ? sFloatEvaluator :
                    null;
        }
        if (mEvaluator != null) {
            // KeyframeSet knows how to evaluate the common types - only give it a custom
            // evaluator if one has been set on this class
            mKeyframes.setEvaluator(mEvaluator);
        }
    
private static native voidnCallFloatMethod(java.lang.Object target, long methodID, float arg)

private static native voidnCallFourFloatMethod(java.lang.Object target, long methodID, float arg1, float arg2, float arg3, float arg4)

private static native voidnCallFourIntMethod(java.lang.Object target, long methodID, int arg1, int arg2, int arg3, int arg4)

private static native voidnCallIntMethod(java.lang.Object target, long methodID, int arg)

private static native voidnCallMultipleFloatMethod(java.lang.Object target, long methodID, float[] args)

private static native voidnCallMultipleIntMethod(java.lang.Object target, long methodID, int[] args)

private static native voidnCallTwoFloatMethod(java.lang.Object target, long methodID, float arg1, float arg2)

private static native voidnCallTwoIntMethod(java.lang.Object target, long methodID, int arg1, int arg2)

private static native longnGetFloatMethod(java.lang.Class targetClass, java.lang.String methodName)

private static native longnGetIntMethod(java.lang.Class targetClass, java.lang.String methodName)

private static native longnGetMultipleFloatMethod(java.lang.Class targetClass, java.lang.String methodName, int numParams)

private static native longnGetMultipleIntMethod(java.lang.Class targetClass, java.lang.String methodName, int numParams)

public static android.animation.PropertyValuesHolderofFloat(android.util.Property property, float values)
Constructs and returns a PropertyValuesHolder with a given property and set of float values.

param
property The property being animated. Should not be null.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        return new FloatPropertyValuesHolder(property, values);
    
public static android.animation.PropertyValuesHolderofFloat(java.lang.String propertyName, float values)
Constructs and returns a PropertyValuesHolder with a given property name and set of float values.

param
propertyName The name of the property being animated.
param
values The values that the named property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        return new FloatPropertyValuesHolder(propertyName, values);
    
public static android.animation.PropertyValuesHolderofInt(java.lang.String propertyName, int values)
Constructs and returns a PropertyValuesHolder with a given property name and set of int values.

param
propertyName The name of the property being animated.
param
values The values that the named property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        return new IntPropertyValuesHolder(propertyName, values);
    
public static android.animation.PropertyValuesHolderofInt(android.util.Property property, int values)
Constructs and returns a PropertyValuesHolder with a given property and set of int values.

param
property The property being animated. Should not be null.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        return new IntPropertyValuesHolder(property, values);
    
public static android.animation.PropertyValuesHolderofKeyframe(java.lang.String propertyName, Keyframe values)
Constructs and returns a PropertyValuesHolder object with the specified property name and set of values. These values can be of any type, but the type should be consistent so that an appropriate {@link android.animation.TypeEvaluator} can be found that matches the common type.

If there is only one value, it is assumed to be the end value of an animation, and an initial value will be derived, if possible, by calling a getter function on the object. Also, if any value is null, the value will be filled in when the animation starts in the same way. This mechanism of automatically getting null values only works if the PropertyValuesHolder object is used in conjunction {@link ObjectAnimator}, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

param
propertyName The name of the property associated with this set of values. This can be the actual property name to be used when using a ObjectAnimator object, or just a name used to get animated values, such as if this object is used with an ValueAnimator object.
param
values The set of values to animate between.

        KeyframeSet keyframeSet = KeyframeSet.ofKeyframe(values);
        return ofKeyframes(propertyName, keyframeSet);
    
public static android.animation.PropertyValuesHolderofKeyframe(android.util.Property property, Keyframe values)
Constructs and returns a PropertyValuesHolder object with the specified property and set of values. These values can be of any type, but the type should be consistent so that an appropriate {@link android.animation.TypeEvaluator} can be found that matches the common type.

If there is only one value, it is assumed to be the end value of an animation, and an initial value will be derived, if possible, by calling the property's {@link android.util.Property#get(Object)} function. Also, if any value is null, the value will be filled in when the animation starts in the same way. This mechanism of automatically getting null values only works if the PropertyValuesHolder object is used in conjunction with {@link ObjectAnimator}, since otherwise PropertyValuesHolder has no way of determining what the value should be.

param
property The property associated with this set of values. Should not be null.
param
values The set of values to animate between.

        KeyframeSet keyframeSet = KeyframeSet.ofKeyframe(values);
        return ofKeyframes(property, keyframeSet);
    
static android.animation.PropertyValuesHolderofKeyframes(java.lang.String propertyName, Keyframes keyframes)

        if (keyframes instanceof Keyframes.IntKeyframes) {
            return new IntPropertyValuesHolder(propertyName, (Keyframes.IntKeyframes) keyframes);
        } else if (keyframes instanceof Keyframes.FloatKeyframes) {
            return new FloatPropertyValuesHolder(propertyName,
                    (Keyframes.FloatKeyframes) keyframes);
        } else {
            PropertyValuesHolder pvh = new PropertyValuesHolder(propertyName);
            pvh.mKeyframes = keyframes;
            pvh.mValueType = keyframes.getType();
            return pvh;
        }
    
static android.animation.PropertyValuesHolderofKeyframes(android.util.Property property, Keyframes keyframes)

        if (keyframes instanceof Keyframes.IntKeyframes) {
            return new IntPropertyValuesHolder(property, (Keyframes.IntKeyframes) keyframes);
        } else if (keyframes instanceof Keyframes.FloatKeyframes) {
            return new FloatPropertyValuesHolder(property, (Keyframes.FloatKeyframes) keyframes);
        } else {
            PropertyValuesHolder pvh = new PropertyValuesHolder(property);
            pvh.mKeyframes = keyframes;
            pvh.mValueType = keyframes.getType();
            return pvh;
        }
    
public static android.animation.PropertyValuesHolderofMultiFloat(java.lang.String propertyName, float[][] values)
Constructs and returns a PropertyValuesHolder with a given property name and set of float[] values. At least two float[] values must be supplied, a start and end value. If more values are supplied, the values will be animated from the start, through all intermediate values to the end value. When used with ObjectAnimator, the elements of the array represent the parameters of the setter function.

param
propertyName The name of the property being animated. Can also be the case-sensitive name of the entire setter method. Should not be null.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
FloatArrayEvaluator#FloatArrayEvaluator(float[])
see
ObjectAnimator#ofMultiFloat(Object, String, TypeConverter, TypeEvaluator, Object[])

        if (values.length < 2) {
            throw new IllegalArgumentException("At least 2 values must be supplied");
        }
        int numParameters = 0;
        for (int i = 0; i < values.length; i++) {
            if (values[i] == null) {
                throw new IllegalArgumentException("values must not be null");
            }
            int length = values[i].length;
            if (i == 0) {
                numParameters = length;
            } else if (length != numParameters) {
                throw new IllegalArgumentException("Values must all have the same length");
            }
        }
        FloatArrayEvaluator evaluator = new FloatArrayEvaluator(new float[numParameters]);
        return new MultiFloatValuesHolder(propertyName, null, evaluator, (Object[]) values);
    
public static android.animation.PropertyValuesHolderofMultiFloat(java.lang.String propertyName, android.graphics.Path path)
Constructs and returns a PropertyValuesHolder with a given property name to use as a multi-float setter. The values are animated along the path, with the first parameter of the setter set to the x coordinate and the second set to the y coordinate.

param
propertyName The name of the property being animated. Can also be the case-sensitive name of the entire setter method. Should not be null. The setter must take exactly two float parameters.
param
path The Path along which the values should be animated.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
ObjectAnimator#ofPropertyValuesHolder(Object, PropertyValuesHolder...)

        Keyframes keyframes = KeyframeSet.ofPath(path);
        PointFToFloatArray converter = new PointFToFloatArray();
        return new MultiFloatValuesHolder(propertyName, converter, null, keyframes);
    
public static android.animation.PropertyValuesHolderofMultiFloat(java.lang.String propertyName, TypeConverter converter, TypeEvaluator evaluator, V values)
Constructs and returns a PropertyValuesHolder with a given property and set of Object values for use with ObjectAnimator multi-value setters. The Object values are converted to float[] using the converter.

param
propertyName The property being animated or complete name of the setter. Should not be null.
param
converter Used to convert the animated value to setter parameters.
param
evaluator A TypeEvaluator that will be called on each animation frame to provide the necessary interpolation between the Object values to derive the animated value.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
ObjectAnimator#ofMultiFloat(Object, String, TypeConverter, TypeEvaluator, Object[])

        return new MultiFloatValuesHolder(propertyName, converter, evaluator, values);
    
public static android.animation.PropertyValuesHolderofMultiFloat(java.lang.String propertyName, TypeConverter converter, TypeEvaluator evaluator, Keyframe values)
Constructs and returns a PropertyValuesHolder object with the specified property name or setter name for use in a multi-float setter function using ObjectAnimator. The values can be of any type, but the type should be consistent so that the supplied {@link android.animation.TypeEvaluator} can be used to to evaluate the animated value. The converter converts the values to parameters in the setter function.

At least two values must be supplied, a start and an end value.

param
propertyName The name of the property to associate with the set of values. This may also be the complete name of a setter function.
param
converter Converts values into float parameters for the setter. Can be null if the Keyframes have float[] values.
param
evaluator Used to interpolate between values.
param
values The values at specific fractional times to evaluate between
return
A PropertyValuesHolder for a multi-float parameter setter.

        KeyframeSet keyframeSet = KeyframeSet.ofKeyframe(values);
        return new MultiFloatValuesHolder(propertyName, converter, evaluator, keyframeSet);
    
public static android.animation.PropertyValuesHolderofMultiInt(java.lang.String propertyName, int[][] values)
Constructs and returns a PropertyValuesHolder with a given property name and set of int[] values. At least two int[] values must be supplied, a start and end value. If more values are supplied, the values will be animated from the start, through all intermediate values to the end value. When used with ObjectAnimator, the elements of the array represent the parameters of the setter function.

param
propertyName The name of the property being animated. Can also be the case-sensitive name of the entire setter method. Should not be null.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
IntArrayEvaluator#IntArrayEvaluator(int[])
see
ObjectAnimator#ofMultiInt(Object, String, TypeConverter, TypeEvaluator, Object[])

        if (values.length < 2) {
            throw new IllegalArgumentException("At least 2 values must be supplied");
        }
        int numParameters = 0;
        for (int i = 0; i < values.length; i++) {
            if (values[i] == null) {
                throw new IllegalArgumentException("values must not be null");
            }
            int length = values[i].length;
            if (i == 0) {
                numParameters = length;
            } else if (length != numParameters) {
                throw new IllegalArgumentException("Values must all have the same length");
            }
        }
        IntArrayEvaluator evaluator = new IntArrayEvaluator(new int[numParameters]);
        return new MultiIntValuesHolder(propertyName, null, evaluator, (Object[]) values);
    
public static android.animation.PropertyValuesHolderofMultiInt(java.lang.String propertyName, android.graphics.Path path)
Constructs and returns a PropertyValuesHolder with a given property name to use as a multi-int setter. The values are animated along the path, with the first parameter of the setter set to the x coordinate and the second set to the y coordinate.

param
propertyName The name of the property being animated. Can also be the case-sensitive name of the entire setter method. Should not be null. The setter must take exactly two int parameters.
param
path The Path along which the values should be animated.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
ObjectAnimator#ofPropertyValuesHolder(Object, PropertyValuesHolder...)

        Keyframes keyframes = KeyframeSet.ofPath(path);
        PointFToIntArray converter = new PointFToIntArray();
        return new MultiIntValuesHolder(propertyName, converter, null, keyframes);
    
public static android.animation.PropertyValuesHolderofMultiInt(java.lang.String propertyName, TypeConverter converter, TypeEvaluator evaluator, V values)
Constructs and returns a PropertyValuesHolder with a given property and set of Object values for use with ObjectAnimator multi-value setters. The Object values are converted to int[] using the converter.

param
propertyName The property being animated or complete name of the setter. Should not be null.
param
converter Used to convert the animated value to setter parameters.
param
evaluator A TypeEvaluator that will be called on each animation frame to provide the necessary interpolation between the Object values to derive the animated value.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
ObjectAnimator#ofMultiInt(Object, String, TypeConverter, TypeEvaluator, Object[])
see
ObjectAnimator#ofPropertyValuesHolder(Object, PropertyValuesHolder...)

        return new MultiIntValuesHolder(propertyName, converter, evaluator, values);
    
public static android.animation.PropertyValuesHolderofMultiInt(java.lang.String propertyName, TypeConverter converter, TypeEvaluator evaluator, Keyframe values)
Constructs and returns a PropertyValuesHolder object with the specified property name or setter name for use in a multi-int setter function using ObjectAnimator. The values can be of any type, but the type should be consistent so that the supplied {@link android.animation.TypeEvaluator} can be used to to evaluate the animated value. The converter converts the values to parameters in the setter function.

At least two values must be supplied, a start and an end value.

param
propertyName The name of the property to associate with the set of values. This may also be the complete name of a setter function.
param
converter Converts values into int parameters for the setter. Can be null if the Keyframes have int[] values.
param
evaluator Used to interpolate between values.
param
values The values at specific fractional times to evaluate between
return
A PropertyValuesHolder for a multi-int parameter setter.

        KeyframeSet keyframeSet = KeyframeSet.ofKeyframe(values);
        return new MultiIntValuesHolder(propertyName, converter, evaluator, keyframeSet);
    
public static android.animation.PropertyValuesHolderofObject(java.lang.String propertyName, TypeEvaluator evaluator, java.lang.Object values)
Constructs and returns a PropertyValuesHolder with a given property name and set of Object values. This variant also takes a TypeEvaluator because the system cannot automatically interpolate between objects of unknown type.

param
propertyName The name of the property being animated.
param
evaluator A TypeEvaluator that will be called on each animation frame to provide the necessary interpolation between the Object values to derive the animated value.
param
values The values that the named property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        PropertyValuesHolder pvh = new PropertyValuesHolder(propertyName);
        pvh.setObjectValues(values);
        pvh.setEvaluator(evaluator);
        return pvh;
    
public static android.animation.PropertyValuesHolderofObject(java.lang.String propertyName, TypeConverter converter, android.graphics.Path path)
Constructs and returns a PropertyValuesHolder with a given property name and a Path along which the values should be animated. This variant supports a TypeConverter to convert from PointF to the target type.

The PointF passed to converter or property, if converter is null, is reused on each animation frame and should not be stored by the setter or TypeConverter.

param
propertyName The name of the property being animated.
param
converter Converts a PointF to the type associated with the setter. May be null if conversion is unnecessary.
param
path The Path along which the values should be animated.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        PropertyValuesHolder pvh = new PropertyValuesHolder(propertyName);
        pvh.mKeyframes = KeyframeSet.ofPath(path);
        pvh.mValueType = PointF.class;
        pvh.setConverter(converter);
        return pvh;
    
public static android.animation.PropertyValuesHolderofObject(android.util.Property property, TypeEvaluator evaluator, V values)
Constructs and returns a PropertyValuesHolder with a given property and set of Object values. This variant also takes a TypeEvaluator because the system cannot automatically interpolate between objects of unknown type.

param
property The property being animated. Should not be null.
param
evaluator A TypeEvaluator that will be called on each animation frame to provide the necessary interpolation between the Object values to derive the animated value.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        PropertyValuesHolder pvh = new PropertyValuesHolder(property);
        pvh.setObjectValues(values);
        pvh.setEvaluator(evaluator);
        return pvh;
    
public static android.animation.PropertyValuesHolderofObject(android.util.Property property, TypeConverter converter, TypeEvaluator evaluator, T values)
Constructs and returns a PropertyValuesHolder with a given property and set of Object values. This variant also takes a TypeEvaluator because the system cannot automatically interpolate between objects of unknown type. This variant also takes a TypeConverter to convert from animated values to the type of the property. If only one value is supplied, the TypeConverter must be a {@link android.animation.BidirectionalTypeConverter} to retrieve the current value.

param
property The property being animated. Should not be null.
param
converter Converts the animated object to the Property type.
param
evaluator A TypeEvaluator that will be called on each animation frame to provide the necessary interpolation between the Object values to derive the animated value.
param
values The values that the property will animate between.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.
see
#setConverter(TypeConverter)
see
TypeConverter

        PropertyValuesHolder pvh = new PropertyValuesHolder(property);
        pvh.setConverter(converter);
        pvh.setObjectValues(values);
        pvh.setEvaluator(evaluator);
        return pvh;
    
public static android.animation.PropertyValuesHolderofObject(android.util.Property property, TypeConverter converter, android.graphics.Path path)
Constructs and returns a PropertyValuesHolder with a given property and a Path along which the values should be animated. This variant supports a TypeConverter to convert from PointF to the target type.

The PointF passed to converter or property, if converter is null, is reused on each animation frame and should not be stored by the setter or TypeConverter.

param
property The property being animated. Should not be null.
param
converter Converts a PointF to the type associated with the setter. May be null if conversion is unnecessary.
param
path The Path along which the values should be animated.
return
PropertyValuesHolder The constructed PropertyValuesHolder object.

        PropertyValuesHolder pvh = new PropertyValuesHolder(property);
        pvh.mKeyframes = KeyframeSet.ofPath(path);
        pvh.mValueType = PointF.class;
        pvh.setConverter(converter);
        return pvh;
    
voidsetAnimatedValue(java.lang.Object target)
Internal function to set the value on the target object, using the setter set up earlier on this PropertyValuesHolder object. This function is called by ObjectAnimator to handle turning the value calculated by ValueAnimator into a value set on the object according to the name of the property.

param
target The target object on which the value is set

        if (mProperty != null) {
            mProperty.set(target, getAnimatedValue());
        }
        if (mSetter != null) {
            try {
                mTmpValueArray[0] = getAnimatedValue();
                mSetter.invoke(target, mTmpValueArray);
            } catch (InvocationTargetException e) {
                Log.e("PropertyValuesHolder", e.toString());
            } catch (IllegalAccessException e) {
                Log.e("PropertyValuesHolder", e.toString());
            }
        }
    
public voidsetConverter(TypeConverter converter)
Sets the converter to convert from the values type to the setter's parameter type. If only one value is supplied, converter must be a {@link android.animation.BidirectionalTypeConverter}.

param
converter The converter to use to convert values.

        mConverter = converter;
    
public voidsetEvaluator(TypeEvaluator evaluator)
The TypeEvaluator will be automatically determined based on the type of values supplied to PropertyValuesHolder. The evaluator can be manually set, however, if so desired. This may be important in cases where either the type of the values supplied do not match the way that they should be interpolated between, or if the values are of a custom type or one not currently understood by the animation system. Currently, only values of type float and int (and their Object equivalents: Float and Integer) are correctly interpolated; all other types require setting a TypeEvaluator.

param
evaluator

        mEvaluator = evaluator;
        mKeyframes.setEvaluator(evaluator);
    
public voidsetFloatValues(float values)
Set the animated values for this object to this set of floats. If there is only one value, it is assumed to be the end value of an animation, and an initial value will be derived, if possible, by calling a getter function on the object. Also, if any value is null, the value will be filled in when the animation starts in the same way. This mechanism of automatically getting null values only works if the PropertyValuesHolder object is used in conjunction {@link ObjectAnimator}, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

param
values One or more values that the animation will animate between.

        mValueType = float.class;
        mKeyframes = KeyframeSet.ofFloat(values);
    
public voidsetIntValues(int values)
Set the animated values for this object to this set of ints. If there is only one value, it is assumed to be the end value of an animation, and an initial value will be derived, if possible, by calling a getter function on the object. Also, if any value is null, the value will be filled in when the animation starts in the same way. This mechanism of automatically getting null values only works if the PropertyValuesHolder object is used in conjunction {@link ObjectAnimator}, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

param
values One or more values that the animation will animate between.

        mValueType = int.class;
        mKeyframes = KeyframeSet.ofInt(values);
    
public voidsetKeyframes(Keyframe values)
Set the animated values for this object to this set of Keyframes.

param
values One or more values that the animation will animate between.

        int numKeyframes = values.length;
        Keyframe keyframes[] = new Keyframe[Math.max(numKeyframes,2)];
        mValueType = ((Keyframe)values[0]).getType();
        for (int i = 0; i < numKeyframes; ++i) {
            keyframes[i] = (Keyframe)values[i];
        }
        mKeyframes = new KeyframeSet(keyframes);
    
public voidsetObjectValues(java.lang.Object values)
Set the animated values for this object to this set of Objects. If there is only one value, it is assumed to be the end value of an animation, and an initial value will be derived, if possible, by calling a getter function on the object. Also, if any value is null, the value will be filled in when the animation starts in the same way. This mechanism of automatically getting null values only works if the PropertyValuesHolder object is used in conjunction {@link ObjectAnimator}, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

param
values One or more values that the animation will animate between.

        mValueType = values[0].getClass();
        mKeyframes = KeyframeSet.ofObject(values);
        if (mEvaluator != null) {
            mKeyframes.setEvaluator(mEvaluator);
        }
    
public voidsetProperty(android.util.Property property)
Sets the property that will be animated.

Note that if this PropertyValuesHolder object is used with ObjectAnimator, the property must exist on the target object specified in that ObjectAnimator.

param
property The property being animated.

        mProperty = property;
    
public voidsetPropertyName(java.lang.String propertyName)
Sets the name of the property that will be animated. This name is used to derive a setter function that will be called to set animated values. For example, a property name of foo will result in a call to the function setFoo() on the target object. If either valueFrom or valueTo is null, then a getter function will also be derived and called.

Note that the setter function derived from this property name must take the same parameter type as the valueFrom and valueTo properties, otherwise the call to the setter function will fail.

param
propertyName The name of the property being animated.

        mPropertyName = propertyName;
    
voidsetupEndValue(java.lang.Object target)
This function is called by ObjectAnimator when setting the end values for an animation. The end values are set according to the current values in the target object. The property whose value is extracted is whatever is specified by the propertyName of this PropertyValuesHolder object.

param
target The object which holds the start values that should be set.

        List<Keyframe> keyframes = mKeyframes.getKeyframes();
        if (!keyframes.isEmpty()) {
            setupValue(target, keyframes.get(keyframes.size() - 1));
        }
    
private voidsetupGetter(java.lang.Class targetClass)
Utility function to get the getter from targetClass

        mGetter = setupSetterOrGetter(targetClass, sGetterPropertyMap, "get", null);
    
voidsetupSetter(java.lang.Class targetClass)
Utility function to get the setter from targetClass

param
targetClass The Class on which the requested method should exist.

        Class<?> propertyType = mConverter == null ? mValueType : mConverter.getTargetType();
        mSetter = setupSetterOrGetter(targetClass, sSetterPropertyMap, "set", propertyType);
    
voidsetupSetterAndGetter(java.lang.Object target)
Internal function (called from ObjectAnimator) to set up the setter and getter prior to running the animation. If the setter has not been manually set for this object, it will be derived automatically given the property name, target object, and types of values supplied. If no getter has been set, it will be supplied iff any of the supplied values was null. If there is a null value, then the getter (supplied or derived) will be called to set those null values to the current value of the property on the target object.

param
target The object on which the setter (and possibly getter) exist.

        mKeyframes.invalidateCache();
        if (mProperty != null) {
            // check to make sure that mProperty is on the class of target
            try {
                Object testValue = null;
                List<Keyframe> keyframes = mKeyframes.getKeyframes();
                int keyframeCount = keyframes == null ? 0 : keyframes.size();
                for (int i = 0; i < keyframeCount; i++) {
                    Keyframe kf = keyframes.get(i);
                    if (!kf.hasValue() || kf.valueWasSetOnStart()) {
                        if (testValue == null) {
                            testValue = convertBack(mProperty.get(target));
                        }
                        kf.setValue(testValue);
                        kf.setValueWasSetOnStart(true);
                    }
                }
                return;
            } catch (ClassCastException e) {
                Log.w("PropertyValuesHolder","No such property (" + mProperty.getName() +
                        ") on target object " + target + ". Trying reflection instead");
                mProperty = null;
            }
        }
        // We can't just say 'else' here because the catch statement sets mProperty to null.
        if (mProperty == null) {
            Class targetClass = target.getClass();
            if (mSetter == null) {
                setupSetter(targetClass);
            }
            List<Keyframe> keyframes = mKeyframes.getKeyframes();
            int keyframeCount = keyframes == null ? 0 : keyframes.size();
            for (int i = 0; i < keyframeCount; i++) {
                Keyframe kf = keyframes.get(i);
                if (!kf.hasValue() || kf.valueWasSetOnStart()) {
                    if (mGetter == null) {
                        setupGetter(targetClass);
                        if (mGetter == null) {
                            // Already logged the error - just return to avoid NPE
                            return;
                        }
                    }
                    try {
                        Object value = convertBack(mGetter.invoke(target));
                        kf.setValue(value);
                        kf.setValueWasSetOnStart(true);
                    } catch (InvocationTargetException e) {
                        Log.e("PropertyValuesHolder", e.toString());
                    } catch (IllegalAccessException e) {
                        Log.e("PropertyValuesHolder", e.toString());
                    }
                }
            }
        }
    
private java.lang.reflect.MethodsetupSetterOrGetter(java.lang.Class targetClass, java.util.HashMap propertyMapMap, java.lang.String prefix, java.lang.Class valueType)
Returns the setter or getter requested. This utility function checks whether the requested method exists in the propertyMapMap cache. If not, it calls another utility function to request the Method from the targetClass directly.

param
targetClass The Class on which the requested method should exist.
param
propertyMapMap The cache of setters/getters derived so far.
param
prefix "set" or "get", for the setter or getter.
param
valueType The type of parameter passed into the method (null for getter).
return
Method the method associated with mPropertyName.

        Method setterOrGetter = null;
        synchronized(propertyMapMap) {
            // Have to lock property map prior to reading it, to guard against
            // another thread putting something in there after we've checked it
            // but before we've added an entry to it
            HashMap<String, Method> propertyMap = propertyMapMap.get(targetClass);
            boolean wasInMap = false;
            if (propertyMap != null) {
                wasInMap = propertyMap.containsKey(mPropertyName);
                if (wasInMap) {
                    setterOrGetter = propertyMap.get(mPropertyName);
                }
            }
            if (!wasInMap) {
                setterOrGetter = getPropertyFunction(targetClass, prefix, valueType);
                if (propertyMap == null) {
                    propertyMap = new HashMap<String, Method>();
                    propertyMapMap.put(targetClass, propertyMap);
                }
                propertyMap.put(mPropertyName, setterOrGetter);
            }
        }
        return setterOrGetter;
    
voidsetupStartValue(java.lang.Object target)
This function is called by ObjectAnimator when setting the start values for an animation. The start values are set according to the current values in the target object. The property whose value is extracted is whatever is specified by the propertyName of this PropertyValuesHolder object.

param
target The object which holds the start values that should be set.

        List<Keyframe> keyframes = mKeyframes.getKeyframes();
        if (!keyframes.isEmpty()) {
            setupValue(target, keyframes.get(0));
        }
    
private voidsetupValue(java.lang.Object target, Keyframe kf)
Utility function to set the value stored in a particular Keyframe. The value used is whatever the value is for the property name specified in the keyframe on the target object.

param
target The target object from which the current value should be extracted.
param
kf The keyframe which holds the property name and value.

        if (mProperty != null) {
            Object value = convertBack(mProperty.get(target));
            kf.setValue(value);
        }
        try {
            if (mGetter == null) {
                Class targetClass = target.getClass();
                setupGetter(targetClass);
                if (mGetter == null) {
                    // Already logged the error - just return to avoid NPE
                    return;
                }
            }
            Object value = convertBack(mGetter.invoke(target));
            kf.setValue(value);
        } catch (InvocationTargetException e) {
            Log.e("PropertyValuesHolder", e.toString());
        } catch (IllegalAccessException e) {
            Log.e("PropertyValuesHolder", e.toString());
        }
    
public java.lang.StringtoString()

        return mPropertyName + ": " + mKeyframes.toString();