Java tutorial
/* * Copyright 2015 Google Inc. * * 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.bachhuberdesign.deckbuildergwent.util; import android.animation.Animator; import android.animation.TimeInterpolator; import android.annotation.TargetApi; import android.os.Build; import android.support.annotation.NonNull; import android.support.v4.view.animation.FastOutLinearInInterpolator; import android.support.v4.view.animation.FastOutSlowInInterpolator; import android.support.v4.view.animation.LinearOutSlowInInterpolator; import android.transition.Transition; import android.util.ArrayMap; import android.util.FloatProperty; import android.util.IntProperty; import android.util.Property; import android.view.animation.Interpolator; import android.view.animation.LinearInterpolator; import java.util.ArrayList; /** * Utility methods for working with animations. */ @TargetApi(Build.VERSION_CODES.LOLLIPOP) public class AnimUtils { private AnimUtils() { } private static Interpolator fastOutSlowIn; private static Interpolator fastOutLinearIn; private static Interpolator linearOutSlowIn; private static Interpolator linear; @NonNull public static Interpolator getFastOutSlowInInterpolator() { if (fastOutSlowIn == null) { fastOutSlowIn = new FastOutSlowInInterpolator(); } return fastOutSlowIn; } @NonNull public static Interpolator getFastOutLinearInInterpolator() { if (fastOutLinearIn == null) { fastOutLinearIn = new FastOutLinearInInterpolator(); } return fastOutLinearIn; } @NonNull public static Interpolator getLinearOutSlowInInterpolator() { if (linearOutSlowIn == null) { linearOutSlowIn = new LinearOutSlowInInterpolator(); } return linearOutSlowIn; } @NonNull public static Interpolator getLinearInterpolator() { if (linear == null) { linear = new LinearInterpolator(); } return linear; } /** * Linear interpolate between a and b with parameter t. */ public static float lerp(float a, float b, float t) { return a + (b - a) * t; } /** * A delegate for creating a {@link Property} of <code>int</code> type. */ public static abstract class IntProp<T> { public final String name; public IntProp(String name) { this.name = name; } public abstract void set(T object, int value); public abstract int get(T object); } /** * The animation framework has an optimization for <code>Properties</code> of type * <code>int</code> but it was only made public in API24, so wrap the impl in our own type * and conditionally create the appropriate type, delegating the implementation. */ public static <T> Property<T, Integer> createIntProperty(final IntProp<T> impl) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { return new IntProperty<T>(impl.name) { @Override public Integer get(T object) { return impl.get(object); } @Override public void setValue(T object, int value) { impl.set(object, value); } }; } else { return new Property<T, Integer>(Integer.class, impl.name) { @Override public Integer get(T object) { return impl.get(object); } @Override public void set(T object, Integer value) { impl.set(object, value); } }; } } /** * A delegate for creating a {@link Property} of <code>float</code> type. */ public static abstract class FloatProp<T> { public final String name; protected FloatProp(String name) { this.name = name; } public abstract void set(T object, float value); public abstract float get(T object); } /** * The animation framework has an optimization for <code>Properties</code> of type * <code>float</code> but it was only made public in API24, so wrap the impl in our own type * and conditionally create the appropriate type, delegating the implementation. */ public static <T> Property<T, Float> createFloatProperty(final FloatProp<T> impl) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { return new FloatProperty<T>(impl.name) { @Override public Float get(T object) { return impl.get(object); } @Override public void setValue(T object, float value) { impl.set(object, value); } }; } else { return new Property<T, Float>(Float.class, impl.name) { @Override public Float get(T object) { return impl.get(object); } @Override public void set(T object, Float value) { impl.set(object, value); } }; } } /** * https://halfthought.wordpress.com/2014/11/07/reveal-transition/ * <p/> * Interrupting Activity transitions can yield an OperationNotSupportedException when the * transition tries to pause the animator. Yikes! We can fix this by wrapping the Animator: */ @TargetApi(Build.VERSION_CODES.KITKAT) public static class NoPauseAnimator extends Animator { private final Animator mAnimator; private final ArrayMap<AnimatorListener, AnimatorListener> mListeners = new ArrayMap<>(); public NoPauseAnimator(Animator animator) { mAnimator = animator; } @Override public void addListener(AnimatorListener listener) { AnimatorListener wrapper = new AnimatorListenerWrapper(this, listener); if (!mListeners.containsKey(listener)) { mListeners.put(listener, wrapper); mAnimator.addListener(wrapper); } } @Override public void cancel() { mAnimator.cancel(); } @Override public void end() { mAnimator.end(); } @Override public long getDuration() { return mAnimator.getDuration(); } @Override public TimeInterpolator getInterpolator() { return mAnimator.getInterpolator(); } @Override public void setInterpolator(TimeInterpolator timeInterpolator) { mAnimator.setInterpolator(timeInterpolator); } @Override public ArrayList<AnimatorListener> getListeners() { return new ArrayList<>(mListeners.keySet()); } @Override public long getStartDelay() { return mAnimator.getStartDelay(); } @Override public void setStartDelay(long delayMS) { mAnimator.setStartDelay(delayMS); } @Override public boolean isPaused() { return mAnimator.isPaused(); } @Override public boolean isRunning() { return mAnimator.isRunning(); } @Override public boolean isStarted() { return mAnimator.isStarted(); } /* We don't want to override pause or resume methods because we don't want them * to affect mAnimator. public void pause(); public void resume(); public void addPauseListener(AnimatorPauseListener listener); public void removePauseListener(AnimatorPauseListener listener); */ @Override public void removeAllListeners() { mListeners.clear(); mAnimator.removeAllListeners(); } @Override public void removeListener(AnimatorListener listener) { AnimatorListener wrapper = mListeners.get(listener); if (wrapper != null) { mListeners.remove(listener); mAnimator.removeListener(wrapper); } } @Override public Animator setDuration(long durationMS) { mAnimator.setDuration(durationMS); return this; } @Override public void setTarget(Object target) { mAnimator.setTarget(target); } @Override public void setupEndValues() { mAnimator.setupEndValues(); } @Override public void setupStartValues() { mAnimator.setupStartValues(); } @Override public void start() { mAnimator.start(); } } public static class AnimatorListenerWrapper implements Animator.AnimatorListener { private final Animator mAnimator; private final Animator.AnimatorListener mListener; AnimatorListenerWrapper(Animator animator, Animator.AnimatorListener listener) { mAnimator = animator; mListener = listener; } @Override public void onAnimationStart(Animator animator) { mListener.onAnimationStart(mAnimator); } @Override public void onAnimationEnd(Animator animator) { mListener.onAnimationEnd(mAnimator); } @Override public void onAnimationCancel(Animator animator) { mListener.onAnimationCancel(mAnimator); } @Override public void onAnimationRepeat(Animator animator) { mListener.onAnimationRepeat(mAnimator); } } @TargetApi(Build.VERSION_CODES.KITKAT) public static abstract class TransitionEndListener implements Transition.TransitionListener { public abstract void onTransitionCompleted(Transition transition); @Override public void onTransitionStart(Transition transition) { } @Override public void onTransitionEnd(Transition transition) { onTransitionCompleted(transition); } @Override public void onTransitionCancel(Transition transition) { onTransitionCompleted(transition); } @Override public void onTransitionPause(Transition transition) { } @Override public void onTransitionResume(Transition transition) { } } }