Merge "Support for multiple value animations." (7d8589c1) · Commits · e / os / android_frameworks_base

api/current.txt

+22 −0

Original line number	Diff line number	Diff line
		@@ -2442,11 +2442,23 @@ package android.animation {
		method public java.lang.Object evaluate(float, java.lang.Object, java.lang.Object);
		}

		public class FloatArrayEvaluator implements android.animation.TypeEvaluator {
		ctor public FloatArrayEvaluator();
		ctor public FloatArrayEvaluator(float[]);
		method public float[] evaluate(float, float[], float[]);
		}

		public class FloatEvaluator implements android.animation.TypeEvaluator {
		ctor public FloatEvaluator();
		method public java.lang.Float evaluate(float, java.lang.Number, java.lang.Number);
		}

		public class IntArrayEvaluator implements android.animation.TypeEvaluator {
		ctor public IntArrayEvaluator();
		ctor public IntArrayEvaluator(int[]);
		method public int[] evaluate(float, int[], int[]);
		}

		public class IntEvaluator implements android.animation.TypeEvaluator {
		ctor public IntEvaluator();
		method public java.lang.Integer evaluate(float, java.lang.Integer, java.lang.Integer);
		@@ -2519,6 +2531,10 @@ package android.animation {
		method public static android.animation.ObjectAnimator ofFloat(T, android.util.Property<T, java.lang.Float>, float...);
		method public static android.animation.ObjectAnimator ofInt(java.lang.Object, java.lang.String, int...);
		method public static android.animation.ObjectAnimator ofInt(T, android.util.Property<T, java.lang.Integer>, int...);
		method public static android.animation.ObjectAnimator ofMultiFloat(java.lang.Object, java.lang.String, float[][]);
		method public static android.animation.ObjectAnimator ofMultiFloat(java.lang.Object, java.lang.String, android.animation.TypeConverter<T, float[]>, android.animation.TypeEvaluator<T>, T...);
		method public static android.animation.ObjectAnimator ofMultiInt(java.lang.Object, java.lang.String, int[][]);
		method public static android.animation.ObjectAnimator ofMultiInt(java.lang.Object, java.lang.String, android.animation.TypeConverter<T, int[]>, android.animation.TypeEvaluator<T>, T...);
		method public static android.animation.ObjectAnimator ofObject(java.lang.Object, java.lang.String, android.animation.TypeEvaluator, java.lang.Object...);
		method public static android.animation.ObjectAnimator ofObject(T, android.util.Property<T, V>, android.animation.TypeEvaluator<V>, V...);
		method public static android.animation.ObjectAnimator ofObject(T, android.util.Property<T, P>, android.animation.TypeConverter<V, P>, android.animation.TypeEvaluator<V>, V...);
		@@ -2537,6 +2553,12 @@ package android.animation {
		method public static android.animation.PropertyValuesHolder ofInt(android.util.Property<?, java.lang.Integer>, int...);
		method public static android.animation.PropertyValuesHolder ofKeyframe(java.lang.String, android.animation.Keyframe...);
		method public static android.animation.PropertyValuesHolder ofKeyframe(android.util.Property, android.animation.Keyframe...);
		method public static android.animation.PropertyValuesHolder ofMultiFloat(java.lang.String, float[][]);
		method public static android.animation.PropertyValuesHolder ofMultiFloat(java.lang.String, android.animation.TypeConverter<V, float[]>, android.animation.TypeEvaluator<V>, V...);
		method public static android.animation.PropertyValuesHolder ofMultiFloat(java.lang.String, android.animation.TypeConverter<T, float[]>, android.animation.TypeEvaluator<T>, android.animation.Keyframe...);
		method public static android.animation.PropertyValuesHolder ofMultiInt(java.lang.String, int[][]);
		method public static android.animation.PropertyValuesHolder ofMultiInt(java.lang.String, android.animation.TypeConverter<V, int[]>, android.animation.TypeEvaluator<V>, V...);
		method public static android.animation.PropertyValuesHolder ofMultiInt(java.lang.String, android.animation.TypeConverter<T, int[]>, android.animation.TypeEvaluator<T>, android.animation.Keyframe...);
		method public static android.animation.PropertyValuesHolder ofObject(java.lang.String, android.animation.TypeEvaluator, java.lang.Object...);
		method public static android.animation.PropertyValuesHolder ofObject(android.util.Property, android.animation.TypeEvaluator<V>, V...);
		method public static android.animation.PropertyValuesHolder ofObject(android.util.Property<?, V>, android.animation.TypeConverter<T, V>, android.animation.TypeEvaluator<T>, T...);

core/java/android/animation/FloatArrayEvaluator.java

0 → 100644

+77 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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 android.animation;

		/**
		* This evaluator can be used to perform type interpolation between <code>float[]</code> values.
		* Each index into the array is treated as a separate value to interpolate. For example,
		* evaluating <code>{100, 200}</code> and <code>{300, 400}</code> will interpolate the value at
		* the first index between 100 and 300 and the value at the second index value between 200 and 400.
		*/
		public class FloatArrayEvaluator implements TypeEvaluator<float[]> {

		private float[] mArray;

		/**
		* Create a FloatArrayEvaluator that does not reuse the animated value. Care must be taken
		* when using this option because on every evaluation a new <code>float[]</code> will be
		* allocated.
		*
		* @see #FloatArrayEvaluator(float[])
		*/
		public FloatArrayEvaluator() {
		}

		/**
		* Create a FloatArrayEvaluator that reuses <code>reuseArray</code> for every evaluate() call.
		* Caution must be taken to ensure that the value returned from
		* {@link android.animation.ValueAnimator#getAnimatedValue()} is not cached, modified, or
		* used across threads. The value will be modified on each <code>evaluate()</code> call.
		*
		* @param reuseArray The array to modify and return from <code>evaluate</code>.
		*/
		public FloatArrayEvaluator(float[] reuseArray) {
		mArray = reuseArray;
		}

		/**
		* Interpolates the value at each index by the fraction. If
		* {@link #FloatArrayEvaluator(float[])} was used to construct this object,
		* <code>reuseArray</code> will be returned, otherwise a new <code>float[]</code>
		* will be returned.
		*
		* @param fraction The fraction from the starting to the ending values
		* @param startValue The start value.
		* @param endValue The end value.
		* @return A <code>float[]</code> where each element is an interpolation between
		* the same index in startValue and endValue.
		*/
		@Override
		public float[] evaluate(float fraction, float[] startValue, float[] endValue) {
		float[] array = mArray;
		if (array == null) {
		array = new float[startValue.length];
		}

		for (int i = 0; i < array.length; i++) {
		float start = startValue[i];
		float end = endValue[i];
		array[i] = start + (fraction * (end - start));
		}
		return array;
		}
		}

core/java/android/animation/IntArrayEvaluator.java

0 → 100644

+75 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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 android.animation;

		/**
		* This evaluator can be used to perform type interpolation between <code>int[]</code> values.
		* Each index into the array is treated as a separate value to interpolate. For example,
		* evaluating <code>{100, 200}</code> and <code>{300, 400}</code> will interpolate the value at
		* the first index between 100 and 300 and the value at the second index value between 200 and 400.
		*/
		public class IntArrayEvaluator implements TypeEvaluator<int[]> {

		private int[] mArray;

		/**
		* Create an IntArrayEvaluator that does not reuse the animated value. Care must be taken
		* when using this option because on every evaluation a new <code>int[]</code> will be
		* allocated.
		*
		* @see #IntArrayEvaluator(int[])
		*/
		public IntArrayEvaluator() {
		}

		/**
		* Create an IntArrayEvaluator that reuses <code>reuseArray</code> for every evaluate() call.
		* Caution must be taken to ensure that the value returned from
		* {@link android.animation.ValueAnimator#getAnimatedValue()} is not cached, modified, or
		* used across threads. The value will be modified on each <code>evaluate()</code> call.
		*
		* @param reuseArray The array to modify and return from <code>evaluate</code>.
		*/
		public IntArrayEvaluator(int[] reuseArray) {
		mArray = reuseArray;
		}

		/**
		* Interpolates the value at each index by the fraction. If {@link #IntArrayEvaluator(int[])}
		* was used to construct this object, <code>reuseArray</code> will be returned, otherwise
		* a new <code>int[]</code> will be returned.
		*
		* @param fraction The fraction from the starting to the ending values
		* @param startValue The start value.
		* @param endValue The end value.
		* @return An <code>int[]</code> where each element is an interpolation between
		* the same index in startValue and endValue.
		*/
		@Override
		public int[] evaluate(float fraction, int[] startValue, int[] endValue) {
		int[] array = mArray;
		if (array == null) {
		array = new int[startValue.length];
		}
		for (int i = 0; i < array.length; i++) {
		int start = startValue[i];
		int end = endValue[i];
		array[i] = (int) (start + (fraction * (end - start)));
		}
		return array;
		}
		}

core/java/android/animation/ObjectAnimator.java

+95 −0

Original line number	Diff line number	Diff line
		@@ -227,6 +227,53 @@ public final class ObjectAnimator extends ValueAnimator {
		return anim;
		}

		/**
		* Constructs and returns an ObjectAnimator that animates over int values for a multiple
		* parameters setter. Only public methods that take only int parameters are supported.
		* Each <code>int[]</code> contains a complete set of parameters to the setter method.
		* At least two <code>int[]</code> values must be provided, a start and end. More than two
		* values imply a starting value, values to animate through along the way, and an ending
		* value (these values will be distributed evenly across the duration of the animation).
		*
		* @param target The object whose property is to be animated. This object may
		* have a public method on it called <code>setName()</code>, where <code>name</code> is
		* the value of the <code>propertyName</code> parameter. <code>propertyName</code> may also
		* be the case-sensitive complete name of the public setter method.
		* @param propertyName The name of the property being animated or the name of the setter method.
		* @param values A set of values that the animation will animate between over time.
		* @return An ObjectAnimator object that is set up to animate between the given values.
		*/
		public static ObjectAnimator ofMultiInt(Object target, String propertyName, int[][] values) {
		PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiInt(propertyName, values);
		return ofPropertyValuesHolder(target, pvh);
		}

		/**
		* Constructs and returns an ObjectAnimator that animates over values for a multiple int
		* parameters setter. Only public methods that take only int parameters are supported.
		* <p>At least two values must be provided, a start and end. More than two
		* values imply a starting value, values to animate through along the way, and an ending
		* value (these values will be distributed evenly across the duration of the animation).</p>
		*
		* @param target The object whose property is to be animated. This object may
		* have a public method on it called <code>setName()</code>, where <code>name</code> is
		* the value of the <code>propertyName</code> parameter. <code>propertyName</code> may also
		* be the complete name of the public method.
		* @param propertyName The name of the property being animated or the name of the setter method.
		* @param converter Converts T objects into int parameters for the multi-value setter.
		* @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 A set of values that the animation will animate between over time.
		* @return An ObjectAnimator object that is set up to animate between the given values.
		*/
		public static <T> ObjectAnimator ofMultiInt(Object target, String propertyName,
		TypeConverter<T, int[]> converter, TypeEvaluator<T> evaluator, T... values) {
		PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiInt(propertyName, converter,
		evaluator, values);
		return ObjectAnimator.ofPropertyValuesHolder(target, pvh);
		}

		/**
		* Constructs and returns an ObjectAnimator that animates between float values. A single
		* value implies that that value is the one being animated to. Two values imply starting
		@@ -266,6 +313,54 @@ public final class ObjectAnimator extends ValueAnimator {
		return anim;
		}

		/**
		* Constructs and returns an ObjectAnimator that animates over float values for a multiple
		* parameters setter. Only public methods that take only float parameters are supported.
		* Each <code>float[]</code> contains a complete set of parameters to the setter method.
		* At least two <code>float[]</code> values must be provided, a start and end. More than two
		* values imply a starting value, values to animate through along the way, and an ending
		* value (these values will be distributed evenly across the duration of the animation).
		*
		* @param target The object whose property is to be animated. This object may
		* have a public method on it called <code>setName()</code>, where <code>name</code> is
		* the value of the <code>propertyName</code> parameter. <code>propertyName</code> may also
		* be the complete name of the public method.
		* @param propertyName The name of the property being animated or the name of the setter method.
		* @param values A set of values that the animation will animate between over time.
		* @return An ObjectAnimator object that is set up to animate between the given values.
		*/
		public static ObjectAnimator ofMultiFloat(Object target, String propertyName,
		float[][] values) {
		PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiFloat(propertyName, values);
		return ofPropertyValuesHolder(target, pvh);
		}

		/**
		* Constructs and returns an ObjectAnimator that animates over values for a multiple float
		* parameters setter. Only public methods that take only float parameters are supported.
		* <p>At least two values must be provided, a start and end. More than two
		* values imply a starting value, values to animate through along the way, and an ending
		* value (these values will be distributed evenly across the duration of the animation).</p>
		*
		* @param target The object whose property is to be animated. This object may
		* have a public method on it called <code>setName()</code>, where <code>name</code> is
		* the value of the <code>propertyName</code> parameter. <code>propertyName</code> may also
		* be the case-sensitive complete name of the public setter method.
		* @param propertyName The name of the property being animated or the name of the setter method.
		* @param converter Converts T objects into float parameters for the multi-value setter.
		* @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 A set of values that the animation will animate between over time.
		* @return An ObjectAnimator object that is set up to animate between the given values.
		*/
		public static <T> ObjectAnimator ofMultiFloat(Object target, String propertyName,
		TypeConverter<T, float[]> converter, TypeEvaluator<T> evaluator, T... values) {
		PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiFloat(propertyName, converter,
		evaluator, values);
		return ObjectAnimator.ofPropertyValuesHolder(target, pvh);
		}

		/**
		* Constructs and returns an ObjectAnimator that animates between Object values. A single
		* value implies that that value is the one being animated to. Two values imply starting

core/java/android/animation/PropertyValuesHolder.java

+374 −0

File changed.

Preview size limit exceeded, changes collapsed.