copy AnimatorSet and related classes from AOSP

This makes AnimatedVectorDrawableCompat from androidx functional and
probably also helps other animation stuff.

src/api-impl/android/animation/ArgbEvaluator.java

@@ -1,5 +1,9 @@
 package android.animation;
 
-public class ArgbEvaluator {
+public class ArgbEvaluator implements TypeEvaluator {
+
+	public static ArgbEvaluator getInstance() {
+		return null;
+	}
 
 }

src/api-impl/android/animation/PropertyValuesHolder.java

@@ -1,11 +1,141 @@
 package android.animation;
 
+import java.lang.reflect.Method;
+import android.util.Log;
+import android.util.Property;
+
 public class PropertyValuesHolder {
+
+	private float values_float[];
+	private int values_int[];
+	private Object values_object[];
+	private Object value;
+	private String property_name;
+	private Method setter;
+
 	public static PropertyValuesHolder ofFloat(String propertyName, float... values) {
-		return null;
+		PropertyValuesHolder propertyValuesHolder = new PropertyValuesHolder();
+		propertyValuesHolder.values_float = values;
+		propertyValuesHolder.property_name = propertyName;
+		return propertyValuesHolder;
 	}
 
 	public static PropertyValuesHolder ofObject(String propertyName, TypeEvaluator evaluator, Object... values) {
+		PropertyValuesHolder propertyValuesHolder = new PropertyValuesHolder();
+		propertyValuesHolder.values_object = values;
+		propertyValuesHolder.property_name = propertyName;
+		return propertyValuesHolder;
+	}
+
+	public static PropertyValuesHolder ofInt(String propertyName, int... values) {
+		PropertyValuesHolder propertyValuesHolder = new PropertyValuesHolder();
+		propertyValuesHolder.values_int = values;
+		propertyValuesHolder.property_name = propertyName;
+		return propertyValuesHolder;
+	}
+
+	public static PropertyValuesHolder ofFloat(Property property, float... values) {
+		PropertyValuesHolder propertyValuesHolder = new PropertyValuesHolder();
+		propertyValuesHolder.values_float = values;
+		propertyValuesHolder.property_name = property.getName();
+		return propertyValuesHolder;
+	}
+
+	public static PropertyValuesHolder ofObject(Property property, TypeEvaluator evaluator, Object... values) {
+		PropertyValuesHolder propertyValuesHolder = new PropertyValuesHolder();
+		propertyValuesHolder.values_object = values;
+		propertyValuesHolder.property_name = property.getName();
+		return propertyValuesHolder;
+	}
+
+	public static PropertyValuesHolder ofInt(Property property, int... values) {
+		PropertyValuesHolder propertyValuesHolder = new PropertyValuesHolder();
+		propertyValuesHolder.values_int = values;
+		propertyValuesHolder.property_name = property.getName();
+		return propertyValuesHolder;
+	}
+
+	public void setIntValues(int... values) {
+		values_int = values;
+	}
+
+	public void setFloatValues(float... values) {
+		values_float = values;
+	}
+
+	public void setObjectValues(Object... values) {
+		values_object = values;
+	}
+
+	public String getProperty_name() {
+		return property_name;
+	}
+
+	public void setProperty_name(String propertyName) {
+		this.property_name = propertyName;
+	}
+
+	public void setProperty(Property property) {
+		property_name = property.getName();
+	}
+
+	public void init() {}
+
+	public Object getAnimatedValue() {
+		return value;
+	}
+
+	public void setEvaluator(TypeEvaluator value) {}
+
+	public void calculateValue(float fraction) {
+		if (values_object != null) {
+			value = values_object[(int) (fraction * (values_object.length - 1) + 0.5f)];
+		} else if (values_float != null) {
+			int i = (int) (fraction * (values_float.length - 1));
+			float f = fraction * (values_float.length - 1) - i;
+			value = values_float[i] * (1 - f) + ((f!=0.f) ? values_float[i + 1] * f : 0.f);
+		} else if (values_int != null) {
+			int i = (int) (fraction * (values_int.length - 1));
+			float f = fraction * (values_int.length - 1) - i;
+			value = (int)(values_int[i] * (1 - f) + ((f!=0.f) ? values_int[i + 1] * f : 0.f) + 0.5f);
+		} else {
+			Log.e("PropertyValuesHolder", "No values set");
+		}
+	}
+
+	public PropertyValuesHolder clone() {
 		return null;
 	}
+
+	public void setupSetterAndGetter(Object target) {
+		try {
+			Class<?> clazz;
+			if (values_float != null) {
+				clazz = float.class;
+			} else {
+				clazz = values_object[0].getClass();
+			}
+			setter = target.getClass().getMethod("set" + property_name.substring(0, 1).toUpperCase() + property_name.substring(1), clazz);
+		} catch (NoSuchMethodException e) {
+			Log.e("PropertyValuesHolder", "failed to find setter", e);
+		}
+	}
+
+	public void setupStartValue(Object target) {
+	}
+
+	public void setupEndValue(Object target) {
+	}
+
+	public void setAnimatedValue(Object target) {
+		if (setter != null && value != null) {
+			try {
+				setter.invoke(target, value);
+			} catch (ReflectiveOperationException e) {
+				Log.e("PropertyValuesHolder", "failed to invoke setter", e);
+			}
+		} else {
+			Log.e("PropertyValuesHolder", "no setter or value set");
+		}
+	}
 }

src/api-impl/android/util/LongArray.java

@@ -0,0 +1,229 @@
+/*
+ * 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.util;
+
+import java.util.Arrays;
+
+import com.android.internal.util.ArrayUtils;
+
+import android.annotation.Nullable;
+import android.os.Build;
+
+/**
+ * Implements a growing array of long primitives.
+ *
+ * @hide
+ */
+public class LongArray implements Cloneable {
+	private static final int MIN_CAPACITY_INCREMENT = 12;
+
+	private long[] mValues;
+	private int mSize;
+
+	private  LongArray(long[] array, int size) {
+		mValues = array;
+		mSize = size; //Preconditions.checkArgumentInRange(size, 0, array.length, "size");
+	}
+
+	/**
+	 * Creates an empty LongArray with the default initial capacity.
+	 */
+	public LongArray() {
+		this(0);
+	}
+
+	/**
+	 * Creates an empty LongArray with the specified initial capacity.
+	 */
+	public LongArray(int initialCapacity) {
+		if (initialCapacity == 0) {
+			mValues = new long[0];
+		} else {
+			mValues = ArrayUtils.newUnpaddedLongArray(initialCapacity);
+		}
+		mSize = 0;
+	}
+
+	/**
+	 * Creates an LongArray wrapping the given primitive long array.
+	 */
+	public static LongArray wrap(long[] array) {
+		return new LongArray(array, array.length);
+	}
+
+	/**
+	 * Creates an LongArray from the given primitive long array, copying it.
+	 */
+	public static LongArray fromArray(long[] array, int size) {
+		return wrap(Arrays.copyOf(array, size));
+	}
+
+	/**
+	 * Changes the size of this LongArray. If this LongArray is shrinked, the backing array capacity
+	 * is unchanged. If the new size is larger than backing array capacity, a new backing array is
+	 * created from the current content of this LongArray padded with 0s.
+	 */
+	public void resize(int newSize) {
+		// Preconditions.checkArgumentNonnegative(newSize);
+		if (newSize <= mValues.length) {
+			Arrays.fill(mValues, newSize, mValues.length, 0);
+		} else {
+			ensureCapacity(newSize - mSize);
+		}
+		mSize = newSize;
+	}
+
+	/**
+	 * Appends the specified value to the end of this array.
+	 */
+	public void add(long value) {
+		add(mSize, value);
+	}
+
+	/**
+	 * Inserts a value at the specified position in this array. If the specified index is equal to
+	 * the length of the array, the value is added at the end.
+	 *
+	 * @throws IndexOutOfBoundsException when index &lt; 0 || index &gt; size()
+	 */
+	public void add(int index, long value) {
+		ensureCapacity(1);
+		int rightSegment = mSize - index;
+		mSize++;
+		// ArrayUtils.checkBounds(mSize, index);
+
+		if (rightSegment != 0) {
+			// Move by 1 all values from the right of 'index'
+			System.arraycopy(mValues, index, mValues, index + 1, rightSegment);
+		}
+
+		mValues[index] = value;
+	}
+
+	/**
+	 * Adds the values in the specified array to this array.
+	 */
+	public void addAll(LongArray values) {
+		final int count = values.mSize;
+		ensureCapacity(count);
+
+		System.arraycopy(values.mValues, 0, mValues, mSize, count);
+		mSize += count;
+	}
+
+	/**
+	 * Ensures capacity to append at least <code>count</code> values.
+	 */
+	private void ensureCapacity(int count) {
+		final int currentSize = mSize;
+		final int minCapacity = currentSize + count;
+		if (minCapacity >= mValues.length) {
+			final int targetCap = currentSize + (currentSize < (MIN_CAPACITY_INCREMENT / 2) ?
+					MIN_CAPACITY_INCREMENT : currentSize >> 1);
+			final int newCapacity = targetCap > minCapacity ? targetCap : minCapacity;
+			final long[] newValues = ArrayUtils.newUnpaddedLongArray(newCapacity);
+			System.arraycopy(mValues, 0, newValues, 0, currentSize);
+			mValues = newValues;
+		}
+	}
+
+	/**
+	 * Removes all values from this array.
+	 */
+	public void clear() {
+		mSize = 0;
+	}
+
+	@Override
+	public LongArray clone() {
+		LongArray clone = null;
+		try {
+			clone = (LongArray) super.clone();
+			clone.mValues = mValues.clone();
+		} catch (CloneNotSupportedException cnse) {
+			/* ignore */
+		}
+		return clone;
+	}
+
+	/**
+	 * Returns the value at the specified position in this array.
+	 */
+	public long get(int index) {
+		// ArrayUtils.checkBounds(mSize, index);
+		return mValues[index];
+	}
+
+	/**
+	 * Sets the value at the specified position in this array.
+	 */
+	public void set(int index, long value) {
+		// ArrayUtils.checkBounds(mSize, index);
+		mValues[index] = value;
+	}
+
+	/**
+	 * Returns the index of the first occurrence of the specified value in this
+	 * array, or -1 if this array does not contain the value.
+	 */
+	public int indexOf(long value) {
+		final int n = mSize;
+		for (int i = 0; i < n; i++) {
+			if (mValues[i] == value) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	/**
+	 * Removes the value at the specified index from this array.
+	 */
+	public void remove(int index) {
+		// ArrayUtils.checkBounds(mSize, index);
+		System.arraycopy(mValues, index + 1, mValues, index, mSize - index - 1);
+		mSize--;
+	}
+
+	/**
+	 * Returns the number of values in this array.
+	 */
+	public int size() {
+		return mSize;
+	}
+
+	/**
+	 * Returns a new array with the contents of this LongArray.
+	 */
+	public long[] toArray() {
+		return Arrays.copyOf(mValues, mSize);
+	}
+
+	/**
+	 * Test if each element of {@code a} equals corresponding element from {@code b}
+	 */
+	public static boolean elementsEqual(@Nullable LongArray a, @Nullable LongArray b) {
+		if (a == null || b == null) return a == b;
+		if (a.mSize != b.mSize) return false;
+		for (int i = 0; i < a.mSize; i++) {
+			if (a.get(i) != b.get(i)) {
+				return false;
+			}
+		}
+		return true;
+	}
+}

src/api-impl/android/view/ViewAnimationUtils.java

@@ -1,10 +1,11 @@
 package android.view;
 
 import android.animation.Animator;
+import android.animation.ValueAnimator;
 
 public class ViewAnimationUtils {
 
 	public static Animator createCircularReveal(View view, int centerX, int centerY, float startRadius, float endRadius) {
-		return new Animator();
+		return new ValueAnimator();
 	}
 }

src/api-impl/android/view/ViewPropertyAnimator.java

@@ -2,6 +2,7 @@ package android.view;
 
 import android.animation.Animator;
 import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
 import android.os.Handler;
 
 public class ViewPropertyAnimator {
@@ -71,7 +72,7 @@ public class ViewPropertyAnimator {
 			@Override
 			public void run() {
 				if (listener != null)
-					listener.onAnimationEnd(new Animator());
+					listener.onAnimationEnd(new ValueAnimator());
 			}
 		}, startDelay+duration);
 	}

src/api-impl/meson.build

@@ -3,6 +3,7 @@ srcs = [
 	'android/R.java',
 	'android/accounts/Account.java',
 	'android/accounts/AccountManager.java',
+	'android/animation/AnimationHandler.java',
 	'android/animation/Animator.java',
 	'android/animation/AnimatorInflater.java',
 	'android/animation/AnimatorListenerAdapter.java',
@@ -436,6 +437,7 @@ srcs = [
 	'android/util/MathUtils.java',
 	'android/util/LayoutDirection.java',
 	'android/util/Log.java',
+	'android/util/LongArray.java',
 	'android/util/LongSparseArray.java',
 	'android/util/LruCache.java',
 	'android/util/MapCollections.java',