LayoutTransition

APPEARING

public static final int APPEARING

A flag indicating the animation that runs on those items that are appearing in the container.

Constant Value: 2 (0x00000002)

CHANGE_APPEARING

public static final int CHANGE_APPEARING

A flag indicating the animation that runs on those items that are changing due to a new item appearing in the container.

Constant Value: 0 (0x00000000)

CHANGE_DISAPPEARING

public static final int CHANGE_DISAPPEARING

A flag indicating the animation that runs on those items that are changing due to an item disappearing from the container.

Constant Value: 1 (0x00000001)

CHANGING

public static final int CHANGING

A flag indicating the animation that runs on those items that are changing due to a layout change not caused by items being added to or removed from the container. This transition type is not enabled by default; it can be enabled via enableTransitionType(int).

Constant Value: 4 (0x00000004)

DISAPPEARING

public static final int DISAPPEARING

A flag indicating the animation that runs on those items that are disappearing from the container.

Constant Value: 3 (0x00000003)

LayoutTransition

public LayoutTransition ()

Constructs a LayoutTransition object. By default, the object will listen to layout events on any ViewGroup that it is set on and will run default animations for each type of layout event.

addChild

public void addChild (ViewGroup parent, 
                View child)

This method is called by ViewGroup when a child view is about to be added to the container. This callback starts the process of a transition; we grab the starting values, listen for changes to all of the children of the container, and start appropriate animations.

addTransitionListener

public void addTransitionListener (LayoutTransition.TransitionListener listener)

Add a listener that will be called when the bounds of the view change due to layout processing.

disableTransitionType

public void disableTransitionType (int transitionType)

Disables the specified transitionType for this LayoutTransition object. By default, all transition types except CHANGING are enabled.

enableTransitionType

public void enableTransitionType (int transitionType)

Enables the specified transitionType for this LayoutTransition object. By default, a LayoutTransition listens for changes in children being added/remove/hidden/shown in the container, and runs the animations associated with those events. That is, all transition types besides CHANGING are enabled by default. You can also enable CHANGING animations by calling this method with the CHANGING transitionType.

getAnimator

public Animator getAnimator (int transitionType)

Gets the animation used during one of the transition types that may run.

getDuration

public long getDuration (int transitionType)

Gets the duration on one of the animation objects used by this transition. The transitionType parameter determines the animation whose duration is returned.

getInterpolator

public TimeInterpolator getInterpolator (int transitionType)

Gets the interpolator on one of the animation objects used by this transition. The transitionType parameter determines the animation whose interpolator is returned.

getStagger

public long getStagger (int transitionType)

Gets the length of time to delay between starting each animation during one of the change animations.

getStartDelay

public long getStartDelay (int transitionType)

Gets the start delay on one of the animation objects used by this transition. The transitionType parameter determines the animation whose start delay is returned.

getTransitionListeners

public List<LayoutTransition.TransitionListener> getTransitionListeners ()

Gets the current list of listeners for layout changes.

hideChild

public void hideChild (ViewGroup parent, 
                View child)

This method was deprecated in API level 16.
Use hideChild(android.view.ViewGroup, android.view.View, int).

hideChild

public void hideChild (ViewGroup parent, 
                View child, 
                int newVisibility)

This method is called by ViewGroup when a child view is about to be hidden in container. This callback starts the process of a transition; we grab the starting values, listen for changes to all of the children of the container, and start appropriate animations.

isChangingLayout

public boolean isChangingLayout ()

Returns true if animations are running which animate layout-related properties. This essentially means that either CHANGE_APPEARING or CHANGE_DISAPPEARING animations are running, since these animations operate on layout-related properties.

isRunning

public boolean isRunning ()

Returns true if any of the animations in this transition are currently running.

isTransitionTypeEnabled

public boolean isTransitionTypeEnabled (int transitionType)

Returns whether the specified transitionType is enabled for this LayoutTransition object. By default, all transition types except CHANGING are enabled.

removeChild

public void removeChild (ViewGroup parent, 
                View child)

This method is called by ViewGroup when a child view is about to be removed from the container. This callback starts the process of a transition; we grab the starting values, listen for changes to all of the children of the container, and start appropriate animations.

removeTransitionListener

public void removeTransitionListener (LayoutTransition.TransitionListener listener)

Remove a listener for layout changes.

setAnimateParentHierarchy

public void setAnimateParentHierarchy (boolean animateParentHierarchy)

This flag controls whether CHANGE_APPEARING or CHANGE_DISAPPEARING animations will cause the default changing animation to be run on the parent hierarchy as well. This allows containers of transitioning views to also transition, which may be necessary in situations where the containers bounds change between the before/after states and may clip their children during the transition animations. For example, layouts with wrap_content will adjust their bounds according to the dimensions of their children.

The default changing transitions animate the bounds and scroll positions of the target views. These are the animations that will run on the parent hierarchy, not the custom animations that happen to be set on the transition. This allows custom behavior for the children of the transitioning container, but uses standard behavior of resizing/rescrolling on any changing parents.

setAnimator

public void setAnimator (int transitionType, 
                Animator animator)

Sets the animation used during one of the transition types that may run. Any Animator object can be used, but to be most useful in the context of layout transitions, the animation should either be a ObjectAnimator or a AnimatorSet of animations including PropertyAnimators. Also, these ObjectAnimator objects should be able to get and set values on their target objects automatically. For example, a ObjectAnimator that animates the property "left" is able to set and get the left property from the View objects being animated by the layout transition. The transition works by setting target objects and properties dynamically, according to the pre- and post-layoout values of those objects, so having animations that can handle those properties appropriately will work best for custom animation. The dynamic setting of values is only the case for the CHANGE animations; the APPEARING and DISAPPEARING animations are simply run with the values they have.

It is also worth noting that any and all animations (and their underlying PropertyValuesHolder objects) will have their start and end values set according to the pre- and post-layout values. So, for example, a custom animation on "alpha" as the CHANGE_APPEARING animation will inherit the real value of alpha on the target object (presumably 1) as its starting and ending value when the animation begins. Animations which need to use values at the beginning and end that may not match the values queried when the transition begins may need to use a different mechanism than a standard ObjectAnimator object.

setDuration

public void setDuration (int transitionType, 
                long duration)

Sets the duration on one of the animation objects used by this transition. The transitionType parameter determines the animation whose duration is being set.

setDuration

public void setDuration (long duration)

Sets the duration to be used by all animations of this transition object. If you want to set the duration of just one of the animations in particular, use the setDuration(int, long) method.

setInterpolator

public void setInterpolator (int transitionType, 
                TimeInterpolator interpolator)

Sets the interpolator on one of the animation objects used by this transition. The transitionType parameter determines the animation whose interpolator is being set.

setStagger

public void setStagger (int transitionType, 
                long duration)

Sets the length of time to delay between starting each animation during one of the change animations.

setStartDelay

public void setStartDelay (int transitionType, 
                long delay)

Sets the start delay on one of the animation objects used by this transition. The transitionType parameter determines the animation whose start delay is being set.

showChild

public void showChild (ViewGroup parent, 
                View child)

This method was deprecated in API level 16.
Use showChild(android.view.ViewGroup, android.view.View, int).

showChild

public void showChild (ViewGroup parent, 
                View child, 
                int oldVisibility)

This method is called by ViewGroup when a child view is about to be made visible in the container. This callback starts the process of a transition; we grab the starting values, listen for changes to all of the children of the container, and start appropriate animations.