Interpolator time interpolation class defines the speed of animation transformation. Acceleration, deceleration and repetition of alpha/scale/translate/rotate animation can be achieved. The Interpolator class is actually an empty interface inherited from TimeInterpolator, which allows animation to perform non-linear motion transformation, such as acceleration and speed limit. There is only one method float in the interface. getInterpolation(float input) method. The incoming value is a value of 0.0 to 1.0, and the return value can be less than 0.0 or greater than 1.0.

Common inheritance classes

1. Accelerate Decelerate Interpolator================================= Animation starts and ends at a slower rate change, accelerating in the middle.
2. Accelerate Interpolator================================================= where the animation starts, the rate changes slowly and then starts to accelerate.  
3. AnticipateInterpolator ============================================== Starts backward and then flings forward.
4. Anticipate Overshoot Interpolator================================ Starts backward and then throws forward a certain value and returns the final value.
5. BounceInterpolator=============================================== pops up at the end of the animation.
6. Cycle Interpolator========================================== The number of times the animation is played in a loop, and the rate changes along the sinusoidal curve.
7. Decelerate Interpolator================================================== Fast and slow at the beginning of the animation.
8. Linear Interpolator================================================ changes at a constant rate.
9. Overshoot Interpolator================================================= Throw forward a certain value and return to the original position.
10. Path Interpolator================================================================= New, that is, you can define the path coordinates and then run according to the path coordinates; note that the coordinates are not XY, but one-way, that is, I can bounce back from 0 to 1, then 0.5 to 0.7 to 0.3, until the end of the time.

Several commonly used interpolator source codes:

Linear Interpolator Linear Interpolator, which returns the input value directly.

DecelerateInterpolator

Animation attributes can be set by XML, and mFactor variables can be set by XML. The default value is 1.0; the larger the value, the faster it changes; the result is that it starts faster, and the result is slower. getInterpolation(float) describes a parabolic equation in a junior high school.

Version implementation of C++:

1. float Elastic::easeIn (float t, float b , float c, float d) {  
2.  <span style="white-space:pre">   </span>if (t==0) return b;  if ((t/=d)==1) return b+c;    
3.  <span style="white-space:pre">   </span>float p=d*.3f;  
4.  <span style="white-space:pre">   </span>float a=c;   
5.  <span style="white-space:pre">   </span>float s=p/4;  
6.  <span style="white-space:pre">   </span>float postFix =a*pow(2,10*(t-=1)); // this is a fix, again, with post-increment operators  
7.  <span style="white-space:pre">   </span>return -(postFix * sin((t*d-s)*(2*PI)/p )) + b;  
8. }  
9.    
10. float Elastic::easeOut(float t,float b , float c, float d) {  
11.  if (t==0) return b;  if ((t/=d)==1) return b+c;    
12.  float p=d*.3f;  
13.  float a=c;   
14.  float s=p/4;  
15.  return (a*pow(2,-10*t) * sin( (t*d-s)*(2*PI)/p ) + c + b);   
16. }  
17.    
18. float Elastic::easeInOut(float t,float b , float c, float d) {  
19.  if (t==0) return b;  if ((t/=d/2)==2) return b+c;   
20.  float p=d*(.3f*1.5f);  
21.  float a=c;   
22.  float s=p/4;  
23.    
24.  if (t < 1) {  
25.  float postFix =a*pow(2,10*(t-=1)); // postIncrement is evil  
26.  return -.5f*(postFix* sin( (t*d-s)*(2*PI)/p )) + b;  
27.  }   
28.  float postFix =  a*pow(2,-10*(t-=1)); // postIncrement is evil  
29.  return postFix * sin( (t*d-s)*(2*PI)/p )*.5f + c + b;  
30. }  

Meaning of the parameter:

• t - Current time in animation
• b - Start Value
• c - End Value
• d - Total time of animation

Look at the first three lines of Java:

1. public class Sine {  
2.       
3.     public static float  easeIn(float t,float b , float c, float d) {  
4.         return -c * (float)Math.cos(t/d * (Math.PI/2)) + c + b;  
5.     }  
6.       
7.     public static float  easeOut(float t,float b , float c, float d) {  
8.         return c * (float)Math.sin(t/d * (Math.PI/2)) + b;    
9.     }  
10.       
11.     public static float  easeInOut(float t,float b , float c, float d) {  
12.         return -c/2 * ((float)Math.cos(Math.PI*t/d) - 1) + b;  
13.     }  
14.       
15. }  

Although there are Java, but how to use this ah, with the above Interpolator how to connect ah?

A simple method: first, set the total time of d to a fixed value of 1.0, the start value of b to 0.0, and the end value to 1.0, then t as float get Interpolation (float input) in the above Interpolator; pass in the value, then you can not use it.

Take a Case.

1. /** 
2.  * Created by Qiujuer on 2015/1/5. 
3.  */  
4. public class InSineInterpolator implements Interpolator{  
5.     public static float  easeIn(float t,float b , float c, float d) {  
6.         return -c * (float)Math.cos(t/d * (Math.PI/2)) + c + b;  
7.     }  
8.   
9.     @Override  
10.     public float getInterpolation(float input) {  
11.         return easeIn(input, 0, 1, 1);  
12.     }  
13. }  

Use

1. //AnimatorSet  
2. mAnimatorSet = new AnimatorSet();  
3. mAnimatorSet.playTogether(aPaintX, aPaintY, aRadius, aBackground);  
4. mAnimatorSet.setInterpolator(new InSineInterpolator());  
5. mAnimatorSet.start();  

It can be seen that the use of Android is exactly the same as that of Android. Of course, this is only a Case. You can encapsulate it freely in the specific use, provided that you don't change the main part.