简述：transitions framework
下面翻译transition为“过渡”，强调动画过程的含义，不过更多时候使用transition单词本身。
Android 4.4.2 (API level 19) 引入了过渡框架，它用来在两个view hierarchies（就是ViewGroup实例）切换时执行改变动画。它通过动态修改views对象的某些property值来实现动画，实际上就是用的属性动画。框架内建了一些transition效果，也可以自定义。并且可以监听transition执行过程/生命周期（Lifecycle callbacks）各种回调。
框架概览
在UI改变时——view hierarchy（视图层级） 发生变化，过渡框架对包含的部分改变了的view对象执行属性动画
来表达这样的视觉提示（visual cues）。
特性
过渡框架包括下面这些特性：
动画组Group-level animations
视图层级发生变化时，可以同时执行多个动画，它们形成动画组，类似AnimationSet。Transition-based animation
Runs animations based on the changes between starting and ending view property values.Built-in animations
Includes predefined animations for common effects such as fade out or movement.Resource file support 支持资源文件方式的使用
Loads view hierarchies and built-in animations from layout resource files.Lifecycle callbacks
Defines callbacks that provide finer control over the animation and hierarchy change process.
框架结构
下图是过渡框架涉及的相关概念和之间的关系：
Scene
一个Scene表示一个view hierarchy，存储对应的views及其property值。
一个Scene必须关联到一个scene-root，它是一个ViewGroup，正是对应view hierarchy要添加到的容器。
Scene可以从layout文件创建（只能是整个布局文件对应的view hierarchy），或者代码生成的View/ViewGroup。
如果仅指定目标Scene，那么框架使用当前scene-root对应的view hierarchy就作为开始的Scene。Transition
表示两个Scene之间的过渡动画，它保存了使用到的animations。TransitionManager用来执行专场效果。TransitionListener用来实现对过渡过程的监听。
存在的限制
SurfaceView非UI线程不保证同步；
AdapterView管理childView行为冲突；
TextView改变尺寸时显示问题；
TextureView非预期效果；
创建Scene
过渡涉及startScene和endScene，它们使用同一个sceneRoot，也就是变化的view hierarchy是在一个ViewGroup下的。
startScene可以不指定，那么就默认是当前view hierarchy。
如果连续执行多个Scene之前的切换，那么上一个endScene就是当前的startScene。
可以通过代码或layout文件创建Scene。
- 代码文件，生成需要的ViewGroup对象即可，适合“动态创建”界面这样的需求。
Scene mScene;
// Obtain the scene root element
mSceneRoot = (ViewGroup) mSomeLayoutElement;
// Obtain the view hierarchy to add as a child of
// the scene root when this scene is entered
mViewHierarchy = (ViewGroup) someOtherLayoutElement;
// Create a scene
mScene = new Scene(mSceneRoot, mViewHierarchy);
- layout文件
/**
* Returns a Scene described by the resource file associated with the given
* <code>layoutId</code> parameter. If such a Scene has already been created for
* the given <code>sceneRoot</code>, that same Scene will be returned.
* This caching of layoutId-based scenes enables sharing of common scenes
* between those created in code and those referenced by {@link TransitionManager}
* XML resource files.
*
* @param sceneRoot The root of the hierarchy in which scene changes
* and transitions will take place.
* @param layoutId The id of a standard layout resource file.
* @param context The context used in the process of inflating
* the layout resource.
* @return The scene for the given root and layout id
*/
public static Scene getSceneForLayout(ViewGroup sceneRoot, int layoutId, Context context);
NOTE:
The framework creates the scene from the entire view hierarchy in the file; you can not create a scene from part of a layout file.
Create Scene Actions
使用Scene.setExitAction() or Scene.setEnterAction() ，传递定义的Runnable实例。
可以执行一些操作，比如修改ListView等。
Note:
Do not use scene actions to pass data between views in the starting and ending scenes. For more information, see Defining Transition Lifecycle Callbacks.
应用Transition
创建好startScene、endScene后，在改变UI的逻辑的地方，就可以执行Transition来开启专场动画了。
创建Transition
- 资源文件
在res/transition/目录下，创建表示Transition的文件，资源文件的方式更加复用而且简单。
这种方式和定义动画文件的机制类似。
如res/transition/fade_transition.xml：
<fade xmlns:android="http://schemas.android.com/apk/res/android" />
然后加载它：
Transition mFadeTransition =
TransitionInflater.from(this).
inflateTransition(R.transition.fade_transition);
- 代码方式
例如：
Transition mFadeTransition = new Fade();
预提供的类型有ChangeBounds, ChangeClipBounds, ChangeImageTransform, ChangeTransform, TransitionSet, Visibility详见API文档。
开启过渡
使用下面的方法TransitionManager.go()：
/**
* Convenience method to simply change to the given scene using
* the given transition.
*
* <p>Passing in <code>null</code> for the transition parameter will
* result in the scene changing without any transition running, and is
* equivalent to calling {@link Scene#exit()} on the scene root's
* current scene, followed by {@link Scene#enter()} on the scene
* specified by the <code>scene</code> parameter.</p>
*
* @param scene The Scene to change to
* @param transition The transition to use for this scene change. A
* value of null causes the scene change to happen with no transition.
*/
public static void go(Scene scene, Transition transition)
它有一个不含参数transition的重载，默认会使用AutoTransition。
选择指定的目标view
默认情况下Transition的执行是针对Scene关联的view hierarchy中的所有views执行的。
可以通过Transition的方法removeTarget()、addTarget()来指定它影响的view。
比如若ListView不能通过框架正常完成过渡效果，那么移除它。
动画组：同时执行多个过渡效果
<transitionSet xmlns:android="http://schemas.android.com/apk/res/android"
android:transitionOrdering="sequential">
<fade android:fadingMode="fade_out" />
<changeBounds />
<fade android:fadingMode="fade_in" />
</transitionSet>
对应一个TransitionSet ，它是Transition的子类。
单Scene的过渡
如果UI在变化前后差距很小，例如就是同一个ViewGroup的简单的addView()/removeView()那么，此时可以不去执行像startScene、endScene那样的变化，使用delayed transition来在view hierarchy变化的时候开启过渡：
// Start recording changes to the view hierarchy
TransitionManager.beginDelayedTransition(mRootView, mFade);
// Add the new TextView to the view hierarchy
mRootView.addView(mLabelText);
// When the system redraws the screen to show this update,
// the framework will animate the addition as a fade in
Transition Lifecycle Callbacks
调用public Transition addListener (Transition.TransitionListener listener)。
回调方法见Transition.TransitionListener。
自定义Transition
A custom transition, like one of the built-in transition types, applies animations to child views of both the starting and ending scenes. Unlike built-in transition types, however, you have to provide the code that captures property values and generates animations. You may also want to define a subset of target views for your animation.
定义Transition子类
public class CustomTransition extends Transition {
@Override
public void captureStartValues(TransitionValues values) {}
@Override
public void captureEndValues(TransitionValues values) {}
@Override
public Animator createAnimator(ViewGroup sceneRoot,
TransitionValues startValues,
TransitionValues endValues) {}
}
方法captureStartValues()和captureEndValues()用来获取startScene、endScene关联的view的property值。可以对关心的view的属性值进行记录。
类似下面这样：
public class CustomTransition extends Transition {
// Define a key for storing a property value in
// TransitionValues.values with the syntax
// package_name:transition_class:property_name to avoid collisions
private static final String PROPNAME_BACKGROUND =
"com.example.android.customtransition:CustomTransition:background";
@Override
public void captureStartValues(TransitionValues transitionValues) {
// Call the convenience method captureValues
captureValues(transitionValues);
}
// For the view in transitionValues.view, get the values you
// want and put them in transitionValues.values
private void captureValues(TransitionValues transitionValues) {
// Get a reference to the view
View view = transitionValues.view;
// Store its background property in the values map
transitionValues.values.put(PROPNAME_BACKGROUND, view.getBackground());
}
...
}
TransitionValues是一个非常简单的数据结构，它保存和view关联的属性值，startScene和endScene分别使用一个TransitionValues对象来记录view hierarchy的各个view的状态。
要记录的“property_name”需要保存唯一，因为可能和其它Transition冲突，建议格式是：package_name:transition_name:property_name。
创建自定义Animator
过渡框架中的Transition使用属性动画作为动画机制的实现。
子自定义Transition重写createAnimator()方法来提供需要的动画逻辑，工作就是根据startValues和endValues来创建Animator。
针对有些view的过渡只在endScene或者startScene中有，所以startValues和endValues可能为null。
框架会为每一个动画的view创建一个Animator，也就是调用一次createAnimator()。
下面是一个案例ChangeColor.java：
public class ChangeColor extends Transition {
/** Key to store a color value in TransitionValues object */
private static final String PROPNAME_BACKGROUND = "customtransition:change_color:background";
// BEGIN_INCLUDE (capture_values)
/**
* Convenience method: Add the background Drawable property value
* to the TransitionsValues.value Map for a target.
*/
private void captureValues(TransitionValues values) {
// Capture the property values of views for later use
values.values.put(PROPNAME_BACKGROUND, values.view.getBackground());
}
@Override
public void captureStartValues(TransitionValues transitionValues) {
captureValues(transitionValues);
}
// Capture the value of the background drawable property for a target in the ending Scene.
@Override
public void captureEndValues(TransitionValues transitionValues) {
captureValues(transitionValues);
}
// END_INCLUDE (capture_values)
// BEGIN_INCLUDE (create_animator)
// Create an animation for each target that is in both the starting and ending Scene. For each
// pair of targets, if their background property value is a color (rather than a graphic),
// create a ValueAnimator based on an ArgbEvaluator that interpolates between the starting and
// ending color. Also create an update listener that sets the View background color for each
// animation frame
@Override
public Animator createAnimator(ViewGroup sceneRoot,
TransitionValues startValues, TransitionValues endValues) {
// This transition can only be applied to views that are on both starting and ending scenes.
if (null == startValues || null == endValues) {
return null;
}
// Store a convenient reference to the target. Both the starting and ending layout have the
// same target.
final View view = endValues.view;
// Store the object containing the background property for both the starting and ending
// layouts.
Drawable startBackground = (Drawable) startValues.values.get(PROPNAME_BACKGROUND);
Drawable endBackground = (Drawable) endValues.values.get(PROPNAME_BACKGROUND);
// This transition changes background colors for a target. It doesn't animate any other
// background changes. If the property isn't a ColorDrawable, ignore the target.
if (startBackground instanceof ColorDrawable && endBackground instanceof ColorDrawable) {
ColorDrawable startColor = (ColorDrawable) startBackground;
ColorDrawable endColor = (ColorDrawable) endBackground;
// If the background color for the target in the starting and ending layouts is
// different, create an animation.
if (startColor.getColor() != endColor.getColor()) {
// Create a new Animator object to apply to the targets as the transitions framework
// changes from the starting to the ending layout. Use the class ValueAnimator,
// which provides a timing pulse to change property values provided to it. The
// animation runs on the UI thread. The Evaluator controls what type of
// interpolation is done. In this case, an ArgbEvaluator interpolates between two
// #argb values, which are specified as the 2nd and 3rd input arguments.
ValueAnimator animator = ValueAnimator.ofObject(new ArgbEvaluator(),
startColor.getColor(), endColor.getColor());
// Add an update listener to the Animator object.
animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
Object value = animation.getAnimatedValue();
// Each time the ValueAnimator produces a new frame in the animation, change
// the background color of the target. Ensure that the value isn't null.
if (null != value) {
view.setBackgroundColor((Integer) value);
}
}
});
// Return the Animator object to the transitions framework. As the framework changes
// between the starting and ending layouts, it applies the animation you've created.
return animator;
}
}
// For non-ColorDrawable backgrounds, we just return null, and no animation will take place.
return null;
}
// END_INCLUDE (create_animator)
}
自定义Transition的使用和内建的Fade、ChangeBounds等是完全相同的。
（本文使用Atom编写）