AnticipateOvershootInterpolator.java revision d422dc358f0100106dc07d7b903201eb9b043b11
1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.view.animation; 18 19import android.content.Context; 20import android.content.res.Resources; 21import android.content.res.Resources.Theme; 22import android.content.res.TypedArray; 23import android.util.AttributeSet; 24 25import com.android.internal.view.animation.HasNativeInterpolator; 26import com.android.internal.view.animation.NativeInterpolatorFactory; 27import com.android.internal.view.animation.NativeInterpolatorFactoryHelper; 28 29import static com.android.internal.R.styleable.AnticipateOvershootInterpolator_extraTension; 30import static com.android.internal.R.styleable.AnticipateOvershootInterpolator_tension; 31import static com.android.internal.R.styleable.AnticipateOvershootInterpolator; 32 33/** 34 * An interpolator where the change starts backward then flings forward and overshoots 35 * the target value and finally goes back to the final value. 36 */ 37@HasNativeInterpolator 38public class AnticipateOvershootInterpolator extends BaseInterpolator 39 implements NativeInterpolatorFactory { 40 private final float mTension; 41 42 public AnticipateOvershootInterpolator() { 43 mTension = 2.0f * 1.5f; 44 } 45 46 /** 47 * @param tension Amount of anticipation/overshoot. When tension equals 0.0f, 48 * there is no anticipation/overshoot and the interpolator becomes 49 * a simple acceleration/deceleration interpolator. 50 */ 51 public AnticipateOvershootInterpolator(float tension) { 52 mTension = tension * 1.5f; 53 } 54 55 /** 56 * @param tension Amount of anticipation/overshoot. When tension equals 0.0f, 57 * there is no anticipation/overshoot and the interpolator becomes 58 * a simple acceleration/deceleration interpolator. 59 * @param extraTension Amount by which to multiply the tension. For instance, 60 * to get the same overshoot as an OvershootInterpolator with 61 * a tension of 2.0f, you would use an extraTension of 1.5f. 62 */ 63 public AnticipateOvershootInterpolator(float tension, float extraTension) { 64 mTension = tension * extraTension; 65 } 66 67 public AnticipateOvershootInterpolator(Context context, AttributeSet attrs) { 68 this(context.getResources(), context.getTheme(), attrs); 69 } 70 71 /** @hide */ 72 public AnticipateOvershootInterpolator(Resources res, Theme theme, AttributeSet attrs) { 73 TypedArray a; 74 if (theme != null) { 75 a = theme.obtainStyledAttributes(attrs, AnticipateOvershootInterpolator, 0, 0); 76 } else { 77 a = res.obtainAttributes(attrs, AnticipateOvershootInterpolator); 78 } 79 80 mTension = a.getFloat(AnticipateOvershootInterpolator_tension, 2.0f) * 81 a.getFloat(AnticipateOvershootInterpolator_extraTension, 1.5f); 82 setChangingConfiguration(a.getChangingConfigurations()); 83 a.recycle(); 84 } 85 86 private static float a(float t, float s) { 87 return t * t * ((s + 1) * t - s); 88 } 89 90 private static float o(float t, float s) { 91 return t * t * ((s + 1) * t + s); 92 } 93 94 public float getInterpolation(float t) { 95 // a(t, s) = t * t * ((s + 1) * t - s) 96 // o(t, s) = t * t * ((s + 1) * t + s) 97 // f(t) = 0.5 * a(t * 2, tension * extraTension), when t < 0.5 98 // f(t) = 0.5 * (o(t * 2 - 2, tension * extraTension) + 2), when t <= 1.0 99 if (t < 0.5f) return 0.5f * a(t * 2.0f, mTension); 100 else return 0.5f * (o(t * 2.0f - 2.0f, mTension) + 2.0f); 101 } 102 103 /** @hide */ 104 @Override 105 public long createNativeInterpolator() { 106 return NativeInterpolatorFactoryHelper.createAnticipateOvershootInterpolator(mTension); 107 } 108} 109