android.view.animation.LayoutAnimationController
A layout animation controller is used to animated a layout's, or a view
group's, children. Each child uses the same animation but for every one of
them, the animation starts at a different time. A layout animation controller
is used by ViewGroup to compute the delay by which each
child's animation start must be offset. The delay is computed by using
characteristics of each child, like its index in the view group.
This standard implementation computes the delay by multiplying a fixed
amount of miliseconds by the index of the child in its parent view group.
Subclasses are supposed to override
getDelayForView(android.view.View) to implement a different way
of computing the delay. For instance, a
GridLayoutAnimationController will compute the
delay based on the column and row indices of the child in its parent view
group.
Information used to compute the animation delay of each child are stored
in an instance of
LayoutAnimationController.AnimationParameters,
itself stored in the ViewGroup.LayoutParams of the view.
Nested Classes
Known Direct Subclasses
Summary
XML Attributes
Constants
|
|
|
Value |
|
int |
ORDER_NORMAL |
Distributes the animation delays in the order in which view were added
to their view group. |
0 |
0x00000000 |
int |
ORDER_RANDOM |
Randomly distributes the animation delays. |
2 |
0x00000002 |
int |
ORDER_REVERSE |
Distributes the animation delays in the reverse order in which view were
added to their view group. |
1 |
0x00000001 |
Fields
Public Constructors
Public Methods
Protected Methods
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
toString,
wait,
wait,
wait
Details
XML Attributes
android:animation
Animation to use on each child.
Must be a reference to another resource, in the form "@[+][package:]type:name
"
or to a theme attribute in the form "?[package:][type:]name
".
This corresponds to the global attribute resource symbol animation.
android:animationOrder
The order in which the animations will be started.
Must be one of the following constant values.
Constant | Value | Description |
normal | 0 | Animations are started in the natural order. |
reverse | 1 | Animations are started in the reverse order. |
random | 2 | Animations are started randomly. |
This corresponds to the global attribute resource symbol animationOrder.
android:delay
Fraction of the animation duration used to delay the beginning of
the animation of each child.
May be a floating point value, such as "1.2
".
May be a fractional value, which is a floating point number appended with either % or %p, such as "14.5%
".
The % suffix always means a percentage of the base size; the optional %p suffix provides a size relative to
some parent container.
This may also be a reference to a resource (in the form
"@[package:]type:name
") or
theme attribute (in the form
"?[package:][type:]name
")
containing a value of this type.
This corresponds to the global attribute resource symbol delay.
android:interpolator
Interpolator used to interpolate the delay between the start of
each animation.
Must be a reference to another resource, in the form "@[+][package:]type:name
"
or to a theme attribute in the form "?[package:][type:]name
".
This corresponds to the global attribute resource symbol interpolator.
Constants
public
static
final
int
ORDER_NORMAL
Distributes the animation delays in the order in which view were added
to their view group.
Constant Value:
0
(0x00000000)
public
static
final
int
ORDER_RANDOM
Randomly distributes the animation delays.
Constant Value:
2
(0x00000002)
public
static
final
int
ORDER_REVERSE
Distributes the animation delays in the reverse order in which view were
added to their view group.
Constant Value:
1
(0x00000001)
Fields
protected
Animation
mAnimation
The animation applied on each child of the view group on which this
layout animation controller is set.
The interpolator used to interpolate the delays.
protected
Random
mRandomizer
The randomizer used when the order is set to random. Subclasses should
use this object to avoid creating their own.
Public Constructors
public
LayoutAnimationController(Context context, AttributeSet attrs)
Creates a new layout animation controller from external resources.
Parameters
context
| the Context the view group is running in, through which
it can access the resources |
attrs
| the attributes of the XML tag that is inflating the
layout animation controller
|
public
LayoutAnimationController(Animation animation)
Creates a new layout animation controller with a delay of 50%
and the specified animation.
Parameters
animation
| the animation to use on each child of the view group
|
public
LayoutAnimationController(Animation animation, float delay)
Creates a new layout animation controller with the specified delay
and the specified animation.
Parameters
animation
| the animation to use on each child of the view group |
delay
| the delay by which each child's animation must be offset
|
Public Methods
public
Animation
getAnimation()
Returns the animation applied to each child of the view group on which
this controller is set.
public
final
Animation
getAnimationForView(View view)
Returns the animation to be applied to the specified view. The returned
animation is delayed by an offset computed according to the information
provided by
LayoutAnimationController.AnimationParameters.
This method is called by view groups to obtain the animation to set on
a specific child.
public
float
getDelay()
Returns the delay by which the children's animation are offset. The
delay is expressed as a fraction of the animation duration.
Returns
- a fraction of the animation duration
public
Interpolator
getInterpolator()
Returns the interpolator used to interpolate the delays between the
children.
public
int
getOrder()
Returns the order used to compute the delay of each child's animation.
public
boolean
isDone()
Indicates whether the layout animation is over or not. A layout animation
is considered done when the animation with the longest delay is done.
Returns
- true if all of the children's animations are over, false otherwise
public
void
setAnimation(Context context, int resourceID)
Sets the animation to be run on each child of the view group on which
this layout animation controller is .
Parameters
context
| the context from which the animation must be inflated |
resourceID
| the resource identifier of the animation |
public
void
setAnimation(Animation animation)
Sets the animation to be run on each child of the view group on which
this layout animation controller is .
Parameters
animation
| the animation to run on each child of the view group |
public
void
setDelay(float delay)
Sets the delay, as a fraction of the animation duration, by which the
children's animations are offset. The general formula is:
child animation delay = child index * delay * animation duration
Parameters
delay
| a fraction of the animation duration |
public
void
setInterpolator(Interpolator interpolator)
Sets the interpolator used to interpolate the delays between the
children.
Parameters
interpolator
| the interpolator |
public
void
setInterpolator(Context context, int resourceID)
Sets the interpolator used to interpolate the delays between the
children.
Parameters
context
| the context from which the interpolator must be inflated |
resourceID
| the resource identifier of the interpolator |
public
void
setOrder(int order)
Sets the order used to compute the delay of each child's animation.
public
void
start()
Starts the animation.
public
boolean
willOverlap()
Indicates whether two children's animations will overlap. Animations
overlap when the delay is lower than 100% (or 1.0).
Returns
- true if animations will overlap, false otherwise
Protected Methods
protected
long
getDelayForView(View view)
Returns the amount of milliseconds by which the specified view's
animation must be delayed or offset. Subclasses should override this
method to return a suitable value.
This implementation returns
child animation delay
milliseconds where:
child animation delay = child index * delay
The index is retrieved from the
LayoutAnimationController.AnimationParameters
found in the view's
ViewGroup.LayoutParams.
Parameters
view
| the view for which to obtain the animation's delay |