Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright (C) 2010 The Android Open Source Project
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.actionbarsherlock.internal.nineoldandroids.animation;
  
  //import android.util.FloatProperty;
  //import android.util.IntProperty;
  import android.util.Log;
  //import android.util.Property;
  
  import java.util.HashMap;
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.
  
  @SuppressWarnings({"rawtypes""unchecked"})
  public class PropertyValuesHolder implements Cloneable {

    
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.
  
      String mPropertyName;

    

Hide:
  
      //protected Property mProperty;
  
    
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.
  
      Method mSetter = null;

    
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.
  
      private Method mGetter = null;

    
The type of values supplied. This information is used both in deriving the setter/getter functions and in deriving the type of TypeEvaluator.
  
      Class mValueType;

    
The set of keyframes (time/value pairs) that define this animation.
  
      KeyframeSet mKeyframeSet = null;
  
  
      // type evaluators for the primitive types handled by this implementation
      private static final TypeEvaluator sIntEvaluator = new IntEvaluator();
      private static final TypeEvaluator sFloatEvaluator = new FloatEvaluator();
  
      // We try several different types when searching for appropriate setter/getter functions.
      // The caller may have supplied values in a type that does not match the setter/getter
      // functions (such as the integers 0 and 1 to represent floating point values for alpha).
      // Also, the use of generics in constructors means that we end up with the Object versions
      // of primitive types (Float vs. float). But most likely, the setter/getter functions
      // will take primitive types instead.
      // So we supply an ordered array of other types to try before giving up.
      private static Class[] FLOAT_VARIANTS = {float.classFloat.classdouble.classint.class,
              Double.classInteger.class};
      private static Class[] INTEGER_VARIANTS = {int.classInteger.classfloat.classdouble.class,
              Float.classDouble.class};
      private static Class[] DOUBLE_VARIANTS = {double.classDouble.classfloat.classint.class,
              Float.classInteger.class};
  
      // These maps hold all property entries for a particular class. This map
      // is used to speed up property/setter/getter lookups for a given class/property
      // combination. No need to use reflection on the combination more than once.
     private static final HashMap<ClassHashMap<StringMethod>> sSetterPropertyMap =
             new HashMap<ClassHashMap<StringMethod>>();
     private static final HashMap<ClassHashMap<StringMethod>> sGetterPropertyMap =
             new HashMap<ClassHashMap<StringMethod>>();
 
     // This lock is used to ensure that only one thread is accessing the property maps
     // at a time.
 
     // Used to pass single value to varargs parameter in setter invocation
     final Object[] mTmpValueArray = new Object[1];

    
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 TypeEvaluator mEvaluator;

    
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 Object mAnimatedValue;

    
Internal utility constructor, used by the factory methods to set the property name.

Parameters:
propertyName The name of the property for this holder.
 
     private PropertyValuesHolder(String propertyName) {
          = propertyName;
     }

    
Internal utility constructor, used by the factory methods to set the property.

Parameters:
property The property for this holder.
 
     //private PropertyValuesHolder(Property property) {
     //    mProperty = property;
     //    if (property != null) {
     //        mPropertyName = property.getName();
     //    }
     //}
 
    
Constructs and returns a PropertyValuesHolder with a given property name and set of int values.

Parameters:
propertyName The name of the property being animated.
values The values that the named property will animate between.
Returns:
PropertyValuesHolder The constructed PropertyValuesHolder object.
 
     public static PropertyValuesHolder ofInt(String propertyNameint... values) {
         return new IntPropertyValuesHolder(propertyNamevalues);
     }

    
Constructs and returns a PropertyValuesHolder with a given property and set of int values.

Parameters:
property The property being animated. Should not be null.
values The values that the property will animate between.
Returns:
PropertyValuesHolder The constructed PropertyValuesHolder object.
 
     //public static PropertyValuesHolder ofInt(Property<?, Integer> property, int... values) {
     //    return new IntPropertyValuesHolder(property, values);
     //}
 
    
Constructs and returns a PropertyValuesHolder with a given property name and set of float values.

Parameters:
propertyName The name of the property being animated.
values The values that the named property will animate between.
Returns:
PropertyValuesHolder The constructed PropertyValuesHolder object.
 
     public static PropertyValuesHolder ofFloat(String propertyNamefloat... values) {
         return new FloatPropertyValuesHolder(propertyNamevalues);
     }

    
Constructs and returns a PropertyValuesHolder with a given property and set of float values.

Parameters:
property The property being animated. Should not be null.
values The values that the property will animate between.
Returns:
PropertyValuesHolder The constructed PropertyValuesHolder object.
 
     //public static PropertyValuesHolder ofFloat(Property<?, Float> property, float... values) {
     //    return new FloatPropertyValuesHolder(property, 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.

Parameters:
propertyName The name of the property being animated.
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.
values The values that the named property will animate between.
Returns:
PropertyValuesHolder The constructed PropertyValuesHolder object.
 
     public static PropertyValuesHolder ofObject(String propertyNameTypeEvaluator evaluator,
             Object... values) {
         PropertyValuesHolder pvh = new PropertyValuesHolder(propertyName);
         pvh.setObjectValues(values);
         pvh.setEvaluator(evaluator);
         return pvh;
     }

    
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.

Parameters:
property The property being animated. Should not be null.
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.
values The values that the property will animate between.
Returns:
PropertyValuesHolder The constructed PropertyValuesHolder object.
 
     //public static <V> PropertyValuesHolder ofObject(Property property,
     //        TypeEvaluator<V> evaluator, V... values) {
     //    PropertyValuesHolder pvh = new PropertyValuesHolder(property);
     //    pvh.setObjectValues(values);
     //    pvh.setEvaluator(evaluator);
     //    return pvh;
     //}
 
    
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 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 com.actionbarsherlock.internal.nineoldandroids.animation.ObjectAnimator, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

Parameters:
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.
values The set of values to animate between.
 
     public static PropertyValuesHolder ofKeyframe(String propertyNameKeyframe... values) {
         KeyframeSet keyframeSet = KeyframeSet.ofKeyframe(values);
         if (keyframeSet instanceof IntKeyframeSet) {
             return new IntPropertyValuesHolder(propertyName, (IntKeyframeSetkeyframeSet);
         } else if (keyframeSet instanceof FloatKeyframeSet) {
             return new FloatPropertyValuesHolder(propertyName, (FloatKeyframeSetkeyframeSet);
         }
         else {
             PropertyValuesHolder pvh = new PropertyValuesHolder(propertyName);
             pvh.mKeyframeSet = keyframeSet;
             pvh.mValueType = values[0].getType();
             return pvh;
         }
     }

    
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 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 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 ObjectAnimator, since otherwise PropertyValuesHolder has no way of determining what the value should be.

Parameters:
property The property associated with this set of values. Should not be null.
values The set of values to animate between.
 
     //public static PropertyValuesHolder ofKeyframe(Property property, Keyframe... values) {
     //    KeyframeSet keyframeSet = KeyframeSet.ofKeyframe(values);
     //    if (keyframeSet instanceof IntKeyframeSet) {
     //        return new IntPropertyValuesHolder(property, (IntKeyframeSet) keyframeSet);
     //    } else if (keyframeSet instanceof FloatKeyframeSet) {
     //        return new FloatPropertyValuesHolder(property, (FloatKeyframeSet) keyframeSet);
     //    }
     //    else {
     //        PropertyValuesHolder pvh = new PropertyValuesHolder(property);
     //        pvh.mKeyframeSet = keyframeSet;
     //        pvh.mValueType = ((Keyframe)values[0]).getType();
     //        return pvh;
     //    }
     //}
 
    
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 com.actionbarsherlock.internal.nineoldandroids.animation.ObjectAnimator, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

Parameters:
values One or more values that the animation will animate between.
 
     public void setIntValues(int... values) {
          = int.class;
          = KeyframeSet.ofInt(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 com.actionbarsherlock.internal.nineoldandroids.animation.ObjectAnimator, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

Parameters:
values One or more values that the animation will animate between.
 
     public void setFloatValues(float... values) {
          = float.class;
          = KeyframeSet.ofFloat(values);
     }

    
Set the animated values for this object to this set of Keyframes.

Parameters:
values One or more values that the animation will animate between.
 
     public void setKeyframes(Keyframe... values) {
         int numKeyframes = values.length;
         Keyframe keyframes[] = new Keyframe[Math.max(numKeyframes,2)];
          = values[0].getType();
         for (int i = 0; i < numKeyframes; ++i) {
             keyframes[i] = values[i];
         }
          = new KeyframeSet(keyframes);
     }

    
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 com.actionbarsherlock.internal.nineoldandroids.animation.ObjectAnimator, and with a getter function derived automatically from propertyName, since otherwise PropertyValuesHolder has no way of determining what the value should be.

Parameters:
values One or more values that the animation will animate between.
 
     public void setObjectValues(Object... values) {
          = values[0].getClass();
          = KeyframeSet.ofObject(values);
     }

    
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.

Parameters:
targetClass The class to search for the method
prefix "set" or "get", depending on whether we need a setter or getter.
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.
Returns:
Method the method associated with mPropertyName.
 
     private Method getPropertyFunction(Class targetClassString prefixClass valueType) {
         // TODO: faster implementation...
         Method returnVal = null;
         String methodName = getMethodName(prefix);
         Class args[] = null;
         if (valueType == null) {
             try {
                 returnVal = targetClass.getMethod(methodNameargs);
             } catch (NoSuchMethodException e) {
                 Log.e("PropertyValuesHolder"targetClass.getSimpleName() + " - " +
                         "Couldn't find no-arg method for property " +  + ": " + e);
             }
         } else {
             args = new Class[1];
             Class typeVariants[];
             if (.equals(Float.class)) {
                 typeVariants = ;
             } else if (.equals(Integer.class)) {
                 typeVariants = ;
             } else if (.equals(Double.class)) {
                 typeVariants = ;
             } else {
                 typeVariants = new Class[1];
                 typeVariants[0] = ;
             }
             for (Class typeVariant : typeVariants) {
                 args[0] = typeVariant;
                 try {
                     returnVal = targetClass.getMethod(methodNameargs);
                     // change the value type to suit
                      = typeVariant;
                     return returnVal;
                 } catch (NoSuchMethodException e) {
                     // Swallow the error and keep trying other variants
                 }
             }
             // If we got here, then no appropriate function was found
             Log.e("PropertyValuesHolder",
                     "Couldn't find " + prefix + "ter property " +  +
                             " for " + targetClass.getSimpleName() +
                             " with value type ");
         }
 
         return returnVal;
     }


    
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.

Parameters:
targetClass The Class on which the requested method should exist.
propertyMapMap The cache of setters/getters derived so far.
prefix "set" or "get", for the setter or getter.
valueType The type of parameter passed into the method (null for getter).
Returns:
Method the method associated with mPropertyName.
 
     private Method setupSetterOrGetter(Class targetClass,
             HashMap<ClassHashMap<StringMethod>> propertyMapMap,
             String prefixClass valueType) {
         Method setterOrGetter = null;
         try {
             // 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
             .writeLock().lock();
             HashMap<StringMethodpropertyMap = propertyMapMap.get(targetClass);
             if (propertyMap != null) {
                 setterOrGetter = propertyMap.get();
             }
             if (setterOrGetter == null) {
                 setterOrGetter = getPropertyFunction(targetClassprefixvalueType);
                 if (propertyMap == null) {
                     propertyMap = new HashMap<StringMethod>();
                     propertyMapMap.put(targetClasspropertyMap);
                 }
                 propertyMap.put(setterOrGetter);
             }
         } finally {
             .writeLock().unlock();
         }
         return setterOrGetter;
     }

    
Utility function to get the setter from targetClass

Parameters:
targetClass The Class on which the requested method should exist.
 
     void setupSetter(Class targetClass) {
          = setupSetterOrGetter(targetClass"set");
     }

    
Utility function to get the getter from targetClass
 
     private void setupGetter(Class targetClass) {
          = setupSetterOrGetter(targetClass"get"null);
     }

    
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.

Parameters:
target The object on which the setter (and possibly getter) exist.
 
     void setupSetterAndGetter(Object target) {
         //if (mProperty != null) {
         //    // check to make sure that mProperty is on the class of target
         //    try {
         //        Object testValue = mProperty.get(target);
         //        for (Keyframe kf : mKeyframeSet.mKeyframes) {
         //            if (!kf.hasValue()) {
         //                kf.setValue(mProperty.get(target));
         //            }
         //        }
         //        return;
         //    } catch (ClassCastException e) {
         //        Log.e("PropertyValuesHolder","No such property (" + mProperty.getName() +
         //                ") on target object " + target + ". Trying reflection instead");
         //        mProperty = null;
         //    }
         //}
         Class targetClass = target.getClass();
         if ( == null) {
             setupSetter(targetClass);
         }
         for (Keyframe kf : .) {
             if (!kf.hasValue()) {
                 if ( == null) {
                     setupGetter(targetClass);
                 }
                 try {
                     kf.setValue(.invoke(target));
                 } catch (InvocationTargetException e) {
                     Log.e("PropertyValuesHolder"e.toString());
                 } catch (IllegalAccessException e) {
                     Log.e("PropertyValuesHolder"e.toString());
                 }
             }
         }
     }

    
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.

Parameters:
target The target object from which the current value should be extracted.
kf The keyframe which holds the property name and value.
 
     private void setupValue(Object targetKeyframe kf) {
         //if (mProperty != null) {
         //    kf.setValue(mProperty.get(target));
         //}
         try {
             if ( == null) {
                 Class targetClass = target.getClass();
                 setupGetter(targetClass);
             }
             kf.setValue(.invoke(target));
         } catch (InvocationTargetException e) {
             Log.e("PropertyValuesHolder"e.toString());
         } catch (IllegalAccessException e) {
             Log.e("PropertyValuesHolder"e.toString());
         }
     }

    
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.

Parameters:
target The object which holds the start values that should be set.
 
     void setupStartValue(Object target) {
         setupValue(target..get(0));
     }

    
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.

Parameters:
target The object which holds the start values that should be set.
 
     void setupEndValue(Object target) {
         setupValue(target..get(..size() - 1));
     }
 
     @Override
     public PropertyValuesHolder clone() {
         try {
             PropertyValuesHolder newPVH = (PropertyValuesHoldersuper.clone();
             newPVH.mPropertyName = ;
             //newPVH.mProperty = mProperty;
             newPVH.mKeyframeSet = .clone();
             newPVH.mEvaluator = ;
             return newPVH;
         } catch (CloneNotSupportedException e) {
             // won't reach here
             return null;
         }
     }

    
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.

Parameters:
target The target object on which the value is set
 
     void setAnimatedValue(Object target) {
         //if (mProperty != null) {
         //    mProperty.set(target, getAnimatedValue());
         //}
         if ( != null) {
             try {
                 [0] = getAnimatedValue();
                 .invoke(target);
             } catch (InvocationTargetException e) {
                 Log.e("PropertyValuesHolder"e.toString());
             } catch (IllegalAccessException e) {
                 Log.e("PropertyValuesHolder"e.toString());
             }
         }
     }

    
Internal function, called by ValueAnimator, to set up the TypeEvaluator that will be used to calculate animated values.
 
     void init() {
         if ( == null) {
             // We already handle int and float automatically, but not their Object
             // equivalents
              = ( == Integer.class) ?  :
                     ( == Float.class) ?  :
                     null;
         }
         if ( != null) {
             // KeyframeSet knows how to evaluate the common types - only give it a custom
             // evaluator if one has been set on this class
             .setEvaluator();
         }
     }

    
The TypeEvaluator will the 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.

Parameters:
evaluator
 
     public void setEvaluator(TypeEvaluator evaluator) {
          = evaluator;
         .setEvaluator(evaluator);
     }

    
Function used to calculate the value according to the evaluator set up for this PropertyValuesHolder object. This function is called by ValueAnimator.animateValue().

Parameters:
fraction The elapsed, interpolated fraction of the animation.
 
     void calculateValue(float fraction) {
          = .getValue(fraction);
     }

    
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.

Parameters:
propertyName The name of the property being animated.
 
     public void setPropertyName(String propertyName) {
          = propertyName;
     }

    
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.

Parameters:
property The property being animated.
 
     //public void setProperty(Property property) {
     //    mProperty = property;
     //}
 
    
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.
 
     public String getPropertyName() {
         return ;
     }

    
Internal function, called by ValueAnimator and ObjectAnimator, to retrieve the value most recently calculated in calculateValue().

Returns:
 
     Object getAnimatedValue() {
         return ;
     }
 
     @Override
     public String toString() {
         return  + ": " + .toString();
     }

    
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.

Parameters:
prefix The precursor to the method name, before the property name begins, typically "set" or "get".
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.
Returns:
String the property name converted to a method name according to the conventions specified above.
 
     static String getMethodName(String prefixString propertyName) {
         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;
     }
 
     static class IntPropertyValuesHolder extends PropertyValuesHolder {
 
         // Cache JNI functions to avoid looking them up twice
         //private static final HashMap<Class, HashMap<String, Integer>> sJNISetterPropertyMap =
         //        new HashMap<Class, HashMap<String, Integer>>();
         //int mJniSetter;
         //private IntProperty mIntProperty;
 
         int mIntAnimatedValue;
 
         public IntPropertyValuesHolder(String propertyNameIntKeyframeSet keyframeSet) {
             super(propertyName);
              = int.class;
              = keyframeSet;
              = (IntKeyframeSet;
         }
 
         //public IntPropertyValuesHolder(Property property, IntKeyframeSet keyframeSet) {
         //    super(property);
         //    mValueType = int.class;
         //    mKeyframeSet = keyframeSet;
         //    mIntKeyframeSet = (IntKeyframeSet) mKeyframeSet;
         //    if (property instanceof  IntProperty) {
         //        mIntProperty = (IntProperty) mProperty;
         //    }
         //}
 
         public IntPropertyValuesHolder(String propertyNameint... values) {
             super(propertyName);
             setIntValues(values);
         }
 
         //public IntPropertyValuesHolder(Property property, int... values) {
         //    super(property);
         //    setIntValues(values);
         //    if (property instanceof  IntProperty) {
         //        mIntProperty = (IntProperty) mProperty;
         //    }
         //}
 
         @Override
         public void setIntValues(int... values) {
             super.setIntValues(values);
              = (IntKeyframeSet;
         }
 
         @Override
         void calculateValue(float fraction) {
              = .getIntValue(fraction);
         }
 
         @Override
         Object getAnimatedValue() {
             return ;
         }
 
         @Override
         public IntPropertyValuesHolder clone() {
             IntPropertyValuesHolder newPVH = (IntPropertyValuesHoldersuper.clone();
             newPVH.mIntKeyframeSet = (IntKeyframeSetnewPVH.mKeyframeSet;
             return newPVH;
         }

        
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.

Parameters:
target The target object on which the value is set
 
         @Override
         void setAnimatedValue(Object target) {
             //if (mIntProperty != null) {
             //    mIntProperty.setValue(target, mIntAnimatedValue);
             //    return;
             //}
             //if (mProperty != null) {
             //    mProperty.set(target, mIntAnimatedValue);
             //    return;
             //}
             //if (mJniSetter != 0) {
             //    nCallIntMethod(target, mJniSetter, mIntAnimatedValue);
             //    return;
             //}
             if ( != null) {
                 try {
                     [0] = ;
                     .invoke(target);
                 } catch (InvocationTargetException e) {
                     Log.e("PropertyValuesHolder"e.toString());
                 } catch (IllegalAccessException e) {
                     Log.e("PropertyValuesHolder"e.toString());
                 }
             }
         }
 
         @Override
         void setupSetter(Class targetClass) {
             //if (mProperty != null) {
             //    return;
             //}
             // Check new static hashmap<propName, int> for setter method
             //try {
             //    mPropertyMapLock.writeLock().lock();
             //    HashMap<String, Integer> propertyMap = sJNISetterPropertyMap.get(targetClass);
             //    if (propertyMap != null) {
             //        Integer mJniSetterInteger = propertyMap.get(mPropertyName);
             //        if (mJniSetterInteger != null) {
             //            mJniSetter = mJniSetterInteger;
             //        }
             //    }
             //    if (mJniSetter == 0) {
             //        String methodName = getMethodName("set", mPropertyName);
             //        mJniSetter = nGetIntMethod(targetClass, methodName);
             //        if (mJniSetter != 0) {
             //            if (propertyMap == null) {
             //                propertyMap = new HashMap<String, Integer>();
             //                sJNISetterPropertyMap.put(targetClass, propertyMap);
             //            }
             //            propertyMap.put(mPropertyName, mJniSetter);
             //        }
             //    }
             //} catch (NoSuchMethodError e) {
             //    Log.d("PropertyValuesHolder",
             //            "Can't find native method using JNI, use reflection" + e);
             //} finally {
             //    mPropertyMapLock.writeLock().unlock();
             //}
             //if (mJniSetter == 0) {
                 // Couldn't find method through fast JNI approach - just use reflection
                 super.setupSetter(targetClass);
             //}
         }
     }
 
     static class FloatPropertyValuesHolder extends PropertyValuesHolder {
 
         // Cache JNI functions to avoid looking them up twice
         //private static final HashMap<Class, HashMap<String, Integer>> sJNISetterPropertyMap =
         //        new HashMap<Class, HashMap<String, Integer>>();
         //int mJniSetter;
         //private FloatProperty mFloatProperty;
 
         float mFloatAnimatedValue;
 
         public FloatPropertyValuesHolder(String propertyNameFloatKeyframeSet keyframeSet) {
             super(propertyName);
              = float.class;
              = keyframeSet;
              = (FloatKeyframeSet;
         }
 
         //public FloatPropertyValuesHolder(Property property, FloatKeyframeSet keyframeSet) {
         //    super(property);
         //    mValueType = float.class;
         //    mKeyframeSet = keyframeSet;
         //    mFloatKeyframeSet = (FloatKeyframeSet) mKeyframeSet;
         //    if (property instanceof FloatProperty) {
         //        mFloatProperty = (FloatProperty) mProperty;
         //    }
         //}
 
         public FloatPropertyValuesHolder(String propertyNamefloat... values) {
             super(propertyName);
             setFloatValues(values);
         }
 
         //public FloatPropertyValuesHolder(Property property, float... values) {
         //    super(property);
         //    setFloatValues(values);
         //    if (property instanceof  FloatProperty) {
         //        mFloatProperty = (FloatProperty) mProperty;
         //    }
         //}
 
         @Override
         public void setFloatValues(float... values) {
             super.setFloatValues(values);
              = (FloatKeyframeSet;
         }
 
         @Override
         void calculateValue(float fraction) {
              = .getFloatValue(fraction);
         }
 
         @Override
         Object getAnimatedValue() {
             return ;
         }
 
         @Override
         public FloatPropertyValuesHolder clone() {
             FloatPropertyValuesHolder newPVH = (FloatPropertyValuesHoldersuper.clone();
             newPVH.mFloatKeyframeSet = (FloatKeyframeSetnewPVH.mKeyframeSet;
             return newPVH;
         }

        
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.

Parameters:
target The target object on which the value is set
 
         @Override
         void setAnimatedValue(Object target) {
             //if (mFloatProperty != null) {
             //    mFloatProperty.setValue(target, mFloatAnimatedValue);
             //    return;
             //}
             //if (mProperty != null) {
             //    mProperty.set(target, mFloatAnimatedValue);
             //    return;
             //}
             //if (mJniSetter != 0) {
             //    nCallFloatMethod(target, mJniSetter, mFloatAnimatedValue);
             //    return;
             //}
             if ( != null) {
                 try {
                     [0] = ;
                     .invoke(target);
                 } catch (InvocationTargetException e) {
                     Log.e("PropertyValuesHolder"e.toString());
                 } catch (IllegalAccessException e) {
                     Log.e("PropertyValuesHolder"e.toString());
                 }
             }
         }
 
         @Override
         void setupSetter(Class targetClass) {
             //if (mProperty != null) {
             //    return;
             //}
             // Check new static hashmap<propName, int> for setter method
             //try {
             //    mPropertyMapLock.writeLock().lock();
             //    HashMap<String, Integer> propertyMap = sJNISetterPropertyMap.get(targetClass);
             //    if (propertyMap != null) {
             //        Integer mJniSetterInteger = propertyMap.get(mPropertyName);
             //        if (mJniSetterInteger != null) {
             //            mJniSetter = mJniSetterInteger;
             //        }
             //    }
             //    if (mJniSetter == 0) {
             //        String methodName = getMethodName("set", mPropertyName);
             //        mJniSetter = nGetFloatMethod(targetClass, methodName);
             //        if (mJniSetter != 0) {
             //            if (propertyMap == null) {
             //                propertyMap = new HashMap<String, Integer>();
             //                sJNISetterPropertyMap.put(targetClass, propertyMap);
             //            }
             //            propertyMap.put(mPropertyName, mJniSetter);
             //        }
             //    }
             //} catch (NoSuchMethodError e) {
             //    Log.d("PropertyValuesHolder",
             //            "Can't find native method using JNI, use reflection" + e);
             //} finally {
             //    mPropertyMapLock.writeLock().unlock();
             //}
            //if (mJniSetter == 0) {
                // Couldn't find method through fast JNI approach - just use reflection
                super.setupSetter(targetClass);
            //}
        }
    }
    //native static private int nGetIntMethod(Class targetClass, String methodName);
    //native static private int nGetFloatMethod(Class targetClass, String methodName);
    //native static private void nCallIntMethod(Object target, int methodID, int arg);
    //native static private void nCallFloatMethod(Object target, int methodID, float arg);
New to GrepCode? Check out our FAQ X