belongs to Maven artifact com.android.support:support-dynamic-animation:28.0.0-alpha1
SpringAnimation
  public
  
  final
  
  class
  SpringAnimation
  
  
  
  
    extends DynamicAnimation<SpringAnimation>
  
  
  
  
  
  
| java.lang.Object | ||
| ↳ | android.support.animation.DynamicAnimation<android.support.animation.SpringAnimation> | |
| ↳ | android.support.animation.SpringAnimation | |
SpringAnimation is an animation that is driven by a SpringForce. The spring force defines
 the spring's stiffness, damping ratio, as well as the rest position. Once the SpringAnimation is
 started, on each frame the spring force will update the animation's value and velocity.
 The animation will continue to run until the spring force reaches equilibrium. If the spring used
 in the animation is undamped, the animation will never reach equilibrium. Instead, it will
 oscillate forever.
 
Developer Guides
To create a simple SpringAnimation that uses the default SpringForce:
// Create an animation to animate view's X property, set the rest position of the // default spring to 0, and start the animation with a starting velocity of 5000 (pixel/s). final SpringAnimation anim = new SpringAnimation(view, DynamicAnimation.X, 0) .setStartVelocity(5000); anim.start();
Alternatively, a SpringAnimation can take a pre-configured SpringForce, and
 use that to drive the animation. 
// Create a low stiffness, low bounce spring at position 0. SpringForce spring = new SpringForce(0) .setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY) .setStiffness(SpringForce.STIFFNESS_LOW); // Create an animation to animate view's scaleY property, and start the animation using // the spring above and a starting value of 0.5. Additionally, constrain the range of value for // the animation to be non-negative, effectively preventing any spring overshoot. final SpringAnimation anim = new SpringAnimation(view, DynamicAnimation.SCALE_Y) .setMinValue(0).setSpring(spring).setStartValue(1); anim.start();
Summary
| Inherited constants | 
|---|
|  From
  class 
    android.support.animation.DynamicAnimation
   | 
| Inherited fields | 
|---|
|  From
  class 
    android.support.animation.DynamicAnimation
   | 
| Public constructors | |
|---|---|
| 
      SpringAnimation(FloatValueHolder floatValueHolder)
      This creates a SpringAnimation that animates a  | |
| 
      SpringAnimation(K object, FloatPropertyCompat<K> property)
      This creates a SpringAnimation that animates the property of the given object. | |
| 
      SpringAnimation(K object, FloatPropertyCompat<K> property, float finalPosition)
      This creates a SpringAnimation that animates the property of the given object. | |
| Public methods | |
|---|---|
| 
        
        
        
        
        
        void | 
      animateToFinalPosition(float finalPosition)
      Updates the final position of the spring. | 
| 
        
        
        
        
        
        boolean | 
      canSkipToEnd()
      Queries whether the spring can eventually come to the rest position. | 
| 
        
        
        
        
        
        SpringForce | 
      getSpring()
      Returns the spring that the animation uses for animations. | 
| 
        
        
        
        
        
        SpringAnimation | 
      setSpring(SpringForce force)
      Uses the given spring as the force that drives this animation. | 
| 
        
        
        
        
        
        void | 
      skipToEnd()
      Skips to the end of the animation. | 
| 
        
        
        
        
        
        void | 
      start()
      Starts an animation. | 
| Inherited methods | |
|---|---|
|  From
class 
  
    android.support.animation.DynamicAnimation
  
 | |
|  From
class 
  
    java.lang.Object
  
 | |
Public constructors
SpringAnimation
SpringAnimation (FloatValueHolder floatValueHolder)
This creates a SpringAnimation that animates a FloatValueHolder instance. During
 the animation, the FloatValueHolder instance will be updated via
 setValue(float) each frame. The caller can obtain the up-to-date
 animation value via getValue().
 
Note: changing the value in the FloatValueHolder via
 setValue(float) outside of the animation during an
 animation run will not have any effect on the on-going animation.
| Parameters | |
|---|---|
| floatValueHolder | FloatValueHolder: the property to be animated | 
SpringAnimation
SpringAnimation (K object, 
                FloatPropertyCompat<K> property)This creates a SpringAnimation that animates the property of the given object.
 Note, a spring will need to setup through setSpring(SpringForce) before
 the animation starts.
| Parameters | |
|---|---|
| object | K: the Object whose property will be animated | 
| property | FloatPropertyCompat: the property to be animated | 
SpringAnimation
SpringAnimation (K object, 
                FloatPropertyCompat<K> property, 
                float finalPosition)This creates a SpringAnimation that animates the property of the given object. A Spring will
 be created with the given final position and default stiffness and damping ratio.
 This spring can be accessed and reconfigured through setSpring(SpringForce).
| Parameters | |
|---|---|
| object | K: the Object whose property will be animated | 
| property | FloatPropertyCompat: the property to be animated | 
| finalPosition | float: the final position of the spring to be created. | 
Public methods
animateToFinalPosition
void animateToFinalPosition (float finalPosition)
Updates the final position of the spring.
When the animation is running, calling this method would assume the position change of the spring as a continuous movement since last frame, which yields more accurate results than changing the spring position directly throughsetFinalPosition(float).
 
 If the animation hasn't started, calling this method will change the spring position, and
 immediately start the animation.
    | Parameters | |
|---|---|
| finalPosition | float: rest position of the spring | 
canSkipToEnd
boolean canSkipToEnd ()
Queries whether the spring can eventually come to the rest position.
| Returns | |
|---|---|
| boolean | trueif the spring is damped, otherwisefalse | 
getSpring
SpringForce getSpring ()
Returns the spring that the animation uses for animations.
| Returns | |
|---|---|
| SpringForce | the spring that the animation uses for animations | 
setSpring
SpringAnimation setSpring (SpringForce force)
Uses the given spring as the force that drives this animation. If this spring force has its parameters re-configured during the animation, the new configuration will be reflected in the animation immediately.
| Parameters | |
|---|---|
| force | SpringForce: a pre-defined spring force that drives the animation | 
| Returns | |
|---|---|
| SpringAnimation | the animation that the spring force is set on | 
skipToEnd
void skipToEnd ()
Skips to the end of the animation. If the spring is undamped, an
 IllegalStateException will be thrown, as the animation would never reach to an end.
 It is recommended to check canSkipToEnd() before calling this method. This method
 should only be called on main thread. If animation is not running, no-op.
| Throws | |
|---|---|
| IllegalStateException | if the spring is undamped (i.e. damping ratio = 0) | 
| AndroidRuntimeException | if this method is not called on the main thread | 
start
void start ()
Starts an animation. If the animation has already been started, no op. Note that calling
 start() will not immediately set the property value to start value of the animation.
 The property values will be changed at each animation pulse, which happens before the draw
 pass. As a result, the changes will be reflected in the next frame, the same as if the values
 were set immediately. This method should only be called on main thread.
