简介

Activity是四大组件中最重要的一个，也是平时开发中接触最多的。与Activity启动行为相关的就是它的启动模式，Standard、SingleTop、SingleTask、SingleInstance这4种launchMode相信大家不陌生，如果不太熟悉可以看这里：

//www.greatytc.com/p/c34483bb5c0f

OK，熟悉了4种launchMode后相信你已经对Activity任务栈有一些理解了，能应对一些常见的开发场景了。然而，除了4种launchMode，还有更复杂的控制Activity行为的方式，那就是给启动Activity的Intent添加flag，使用 Intent.addFlags(int flags) 方法。看一下这个方法的参数，总共有20种：

        Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT,
        Intent.FLAG_ACTIVITY_CLEAR_TASK,
        Intent.FLAG_ACTIVITY_CLEAR_TOP,
        Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET,
        Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS,
        Intent.FLAG_ACTIVITY_FORWARD_RESULT,
        Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY,
        Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT,
        Intent.FLAG_ACTIVITY_MULTIPLE_TASK,
        Intent.FLAG_ACTIVITY_NEW_DOCUMENT,
        Intent.FLAG_ACTIVITY_NEW_TASK,
        Intent.FLAG_ACTIVITY_NO_ANIMATION,
        Intent.FLAG_ACTIVITY_NO_HISTORY,
        Intent.FLAG_ACTIVITY_NO_USER_ACTION,
        Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP,
        Intent.FLAG_ACTIVITY_REORDER_TO_FRONT,
        Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED,
        Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS,
        Intent.FLAG_ACTIVITY_SINGLE_TOP,
        Intent.FLAG_ACTIVITY_TASK_ON_HOME,

这么多估计大家一看就晕了，我一开始也是这样。不过，仔细看每一条的文档，把它添加到你要启动的Activity上，然后观察Activity的行为，这样就容易弄明白它的含义。

分析flags

下面结合动画来分析Intent中添加的flags。

1. FLAG_ACTIVITY_CLEAR_TASK

    /**
     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
     * this flag will cause any existing task that would be associated with the
     * activity to be cleared before the activity is started.  That is, the activity
     * becomes the new root of an otherwise empty task, and any old activities
     * are finished.  This can only be used in conjunction with {@link #FLAG_ACTIVITY_NEW_TASK}.
     */

1. 本flag能造成在新活动启动前，与新活动关联的任务被清空。也就是说，新活动成为新任务的根，旧的活动都被结束了。本flag只能与FLAG_ACTIVITY_NEW_TASK联合使用。

clearTask.gif

public static final int FLAG_ACTIVITY_CLEAR_TASK = 0X00008000;

2. FLAG_ACTIVITY_CLEAR_TOP

    /**
     * If set, and the activity being launched is already running in the
     * current task, then instead of launching a new instance of that activity,
     * all of the other activities on top of it will be closed and this Intent
     * will be delivered to the (now on top) old activity as a new Intent.
     *
     * <p>For example, consider a task consisting of the activities: A, B, C, D.
     * If D calls startActivity() with an Intent that resolves to the component
     * of activity B, then C and D will be finished and B receive the given
     * Intent, resulting in the stack now being: A, B.
     *
     * <p>The currently running instance of activity B in the above example will
     * either receive the new intent you are starting here in its
     * onNewIntent() method, or be itself finished and restarted with the
     * new intent.  If it has declared its launch mode to be "multiple" (the
     * default) and you have not set {@link #FLAG_ACTIVITY_SINGLE_TOP} in
     * the same intent, then it will be finished and re-created; for all other
     * launch modes or if {@link #FLAG_ACTIVITY_SINGLE_TOP} is set then this
     * Intent will be delivered to the current instance's onNewIntent().
     *
     * <p>This launch mode can also be used to good effect in conjunction with
     * {@link #FLAG_ACTIVITY_NEW_TASK}: if used to start the root activity
     * of a task, it will bring any currently running instance of that task
     * to the foreground, and then clear it to its root state.  This is
     * especially useful, for example, when launching an activity from the
     * notification manager.
     *
     * <p>See
     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
     * Stack</a> for more information about tasks.
     */

 1. 新活动已在当前任务中时，在新活动上面的活动会被关闭，新活动不会重新启动，只会接收new intent。
 2. 新活动已在任务最上面时：如果启动模式是"multiple" (默认的)，并且没添加FLAG_ACTIVITY_SINGLE_TOP，那么活动会被销毁重新创建；如果启动模式是其他的，或者添加了FLAG_ACTIVITY_SINGLE_TOP，那么只会调用活动的onNewIntent()。
 3. 跟FLAG_ACTIVITY_NEW_TASK联合使用效果很好：如果用于启动一个任务中的根活动，会把该任务移到前面并清空至root状态。这特别有用，比如用于从notification manager中启动活动。

clearTop.gif

public static final int FLAG_ACTIVITY_CLEAR_TOP = 0x04000000;

3. FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET

    /**
     * @deprecated As of API 21 this performs identically to
     * {@link #FLAG_ACTIVITY_NEW_DOCUMENT} which should be used instead of this.
     */

 1. 已废弃。API 21后用FLAG_ACTIVITY_NEW_DOCUMENT。

clearWhenTaskReset.gif

public static final int FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET = 0x00080000;

4. FLAG_ACTIVITY_MULTIPLE_TASK

    /**
     * This flag is used to create a new task and launch an activity into it.
     * This flag is always paired with either {@link #FLAG_ACTIVITY_NEW_DOCUMENT}
     * or {@link #FLAG_ACTIVITY_NEW_TASK}. In both cases these flags alone would
     * search through existing tasks for ones matching this Intent. Only if no such
     * task is found would a new task be created. When paired with
     * FLAG_ACTIVITY_MULTIPLE_TASK both of these behaviors are modified to skip
     * the search for a matching task and unconditionally start a new task.
     *
     * <strong>When used with {@link #FLAG_ACTIVITY_NEW_TASK} do not use this
     * flag unless you are implementing your own
     * top-level application launcher.</strong>  Used in conjunction with
     * {@link #FLAG_ACTIVITY_NEW_TASK} to disable the
     * behavior of bringing an existing task to the foreground.  When set,
     * a new task is <em>always</em> started to host the Activity for the
     * Intent, regardless of whether there is already an existing task running
     * the same thing.
     *
     * <p><strong>Because the default system does not include graphical task management,
     * you should not use this flag unless you provide some way for a user to
     * return back to the tasks you have launched.</strong>
     *
     * See {@link #FLAG_ACTIVITY_NEW_DOCUMENT} for details of this flag's use for
     * creating new document tasks.
     *
     * <p>This flag is ignored if one of {@link #FLAG_ACTIVITY_NEW_TASK} or
     * {@link #FLAG_ACTIVITY_NEW_DOCUMENT} is not also set.
     *
     * <p>See
     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
     * Stack</a> for more information about tasks.
     *
     * @see #FLAG_ACTIVITY_NEW_DOCUMENT
     * @see #FLAG_ACTIVITY_NEW_TASK
     */

 1. 用于创建一个新任务，并启动一个活动放进去；
总是跟FLAG_ACTIVITY_NEW_DOCUMENT或者FLAG_ACTIVITY_NEW_TASK一起使用；
单独用FLAG_ACTIVITY_NEW_DOCUMENT或者FLAG_ACTIVITY_NEW_TASK时，会在已存在的任务中寻找匹配的Intent，找不到才会创建一个新任务；
使用了本flag不会寻找匹配的Intent，无条件创建一个新任务。
2. **用了FLAG_ACTIVITY_NEW_TASK就不要用本flag，除非你启动的是应用的launcher。** 跟FLAG_ACTIVITY_NEW_TASK联合使用能防止把已存在的任务移到前面，会为新活动创建一个新任务，无论已存在的任务中有没有新活动。
3. 因为默认安卓系统中没有提供可视化的任务管理，所以你不应该使用本flag，除非给用户提供可以回到其他任务的方法。
4. 单独用本flag而不用FLAG_ACTIVITY_NEW_DOCUMENT或者FLAG_ACTIVITY_NEW_TASK是无效的。

multiTask1.gif

multiTask2.gif

public static final int FLAG_ACTIVITY_MULTIPLE_TASK = 0x08000000;

5. FLAG_ACTIVITY_NEW_DOCUMENT

    /**
     * This flag is used to open a document into a new task rooted at the activity launched
     * by this Intent. Through the use of this flag, or its equivalent attribute,
     * {@link android.R.attr#documentLaunchMode} multiple instances of the same activity
     * containing different documents will appear in the recent tasks list.
     *
     * <p>The use of the activity attribute form of this,
     * {@link android.R.attr#documentLaunchMode}, is
     * preferred over the Intent flag described here. The attribute form allows the
     * Activity to specify multiple document behavior for all launchers of the Activity
     * whereas using this flag requires each Intent that launches the Activity to specify it.
     *
     * <p>Note that the default semantics of this flag w.r.t. whether the recents entry for
     * it is kept after the activity is finished is different than the use of
     * {@link #FLAG_ACTIVITY_NEW_TASK} and {@link android.R.attr#documentLaunchMode} -- if
     * this flag is being used to create a new recents entry, then by default that entry
     * will be removed once the activity is finished.  You can modify this behavior with
     * {@link #FLAG_ACTIVITY_RETAIN_IN_RECENTS}.
     *
     * <p>FLAG_ACTIVITY_NEW_DOCUMENT may be used in conjunction with {@link
     * #FLAG_ACTIVITY_MULTIPLE_TASK}. When used alone it is the
     * equivalent of the Activity manifest specifying {@link
     * android.R.attr#documentLaunchMode}="intoExisting". When used with
     * FLAG_ACTIVITY_MULTIPLE_TASK it is the equivalent of the Activity manifest specifying
     * {@link android.R.attr#documentLaunchMode}="always".
     *
     * Refer to {@link android.R.attr#documentLaunchMode} for more information.
     *
     * @see android.R.attr#documentLaunchMode
     * @see #FLAG_ACTIVITY_MULTIPLE_TASK
     */

 1. 本flag会给启动的活动开一个新的任务记录。使用了本flag或documentLaunchMode属性时，相同活动的多实例会在最近任务列表中产生不同的记录。
 2. 使用本flag比使用documentLaunchMode属性更好，因为documentLaunchMode属性会跟活动绑定，而flag只在需要时添加。
 3. 注意本flag的默认词义，活动销毁后最近任务列表中的入口不会移除。这跟使用FLAG_ACTIVITY_NEW_TASK不一样，后者活动销毁后入口会马上移除。你可以用FLAG_ACTIVITY_RETAIN_IN_RECENTS改变这个行为。
 4. 本flag可以跟FLAG_ACTIVITY_MULTIPLE_TASK联合使用。单独使用时跟manifest活动中定义documentLaunchMode="intoExisting"效果相同，联合使用时跟manifest活动中定义documentLaunchMode="always"效果相同。

newDocument.gif

public static final int FLAG_ACTIVITY_NEW_DOCUMENT = FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;

6. FLAG_ACTIVITY_NEW_TASK

    /**
     * If set, this activity will become the start of a new task on this
     * history stack.  A task (from the activity that started it to the
     * next task activity) defines an atomic group of activities that the
     * user can move to.  Tasks can be moved to the foreground and background;
     * all of the activities inside of a particular task always remain in
     * the same order.  See
     * <a href="{@docRoot}guide/topics/fundamentals/tasks-and-back-stack.html">Tasks and Back
     * Stack</a> for more information about tasks.
     *
     * <p>This flag is generally used by activities that want
     * to present a "launcher" style behavior: they give the user a list of
     * separate things that can be done, which otherwise run completely
     * independently of the activity launching them.
     *
     * <p>When using this flag, if a task is already running for the activity
     * you are now starting, then a new activity will not be started; instead,
     * the current task will simply be brought to the front of the screen with
     * the state it was last in.  See {@link #FLAG_ACTIVITY_MULTIPLE_TASK} for a flag
     * to disable this behavior.
     *
     * <p>This flag can not be used when the caller is requesting a result from
     * the activity being launched.
     */

 1. 新活动会成为历史栈中的新任务（一组活动）的开始。
 2. 通常用于具有"launcher"行为的活动：让用户完成一系列事情，完全独立于之前的活动。
 3. 如果新活动已存在于一个为它运行的任务中，那么不会启动，只会把该任务移到屏幕最前。
 4. 如果新活动要返回result给启动自己的活动，就不能用这个flag。

newTask.gif

public static final int FLAG_ACTIVITY_NEW_TASK = 0x10000000;

7. FLAG_ACTIVITY_NO_ANIMATION

    /**
     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
     * this flag will prevent the system from applying an activity transition
     * animation to go to the next activity state.  This doesn't mean an
     * animation will never run -- if another activity change happens that doesn't
     * specify this flag before the activity started here is displayed, then
     * that transition will be used.  This flag can be put to good use
     * when you are going to do a series of activity operations but the
     * animation seen by the user shouldn't be driven by the first activity
     * change but rather a later one.
     */

 1. 本flag会阻止系统展示活动的当前状态到另一个状态之间的转移动画。这并不意味着永远没有动画 -- 如果另一项活动的改变在当前展示的活动启动前发生并且没有使用本flag，那么动画还会展示。当你要进行一系列活动操作，但是用户看到的动画不应该由第一项改变来驱动，而是由下一项。

noAnimation.gif

public static final int FLAG_ACTIVITY_NO_ANIMATION = 0X00010000;

8. FLAG_ACTIVITY_NO_HISTORY

    /**
     * If set, the new activity is not kept in the history stack.  As soon as
     * the user navigates away from it, the activity is finished.  This may also
     * be set with the {@link android.R.styleable#AndroidManifestActivity_noHistory
     * noHistory} attribute.
     *
     * <p>If set, {@link android.app.Activity#onActivityResult onActivityResult()}
     * is never invoked when the current activity starts a new activity which
     * sets a result and finishes.
     */

 1. 新活动不会保留在历史栈中，一旦用户切换到其他页面，新活动会马上销毁。
 2. 旧活动的onActivityResult()方法永远不会被触发。

noHistory.gif

public static final int FLAG_ACTIVITY_NO_HISTORY = 0x40000000;

9. FLAG_ACTIVITY_REORDER_TO_FRONT

    /**
     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
     * this flag will cause the launched activity to be brought to the front of its
     * task's history stack if it is already running.
     *
     * <p>For example, consider a task consisting of four activities: A, B, C, D.
     * If D calls startActivity() with an Intent that resolves to the component
     * of activity B, then B will be brought to the front of the history stack,
     * with this resulting order:  A, C, D, B.
     *
     * This flag will be ignored if {@link #FLAG_ACTIVITY_CLEAR_TOP} is also
     * specified.
     */

 1. 如果新活动已在任务中，用本flag启动会将它移到任务的历史栈的前面。
 2. 如果用了FLAG_ACTIVITY_CLEAR_TOP，本flag就无效。

reorderToFront.gif

public static final int FLAG_ACTIVITY_REORDER_TO_FRONT = 0X00020000;

10. FLAG_ACTIVITY_RETAIN_IN_RECENTS

    /**
     * By default a document created by {@link #FLAG_ACTIVITY_NEW_DOCUMENT} will
     * have its entry in recent tasks removed when the user closes it (with back
     * or however else it may finish()). If you would like to instead allow the
     * document to be kept in recents so that it can be re-launched, you can use
     * this flag. When set and the task's activity is finished, the recents
     * entry will remain in the interface for the user to re-launch it, like a
     * recents entry for a top-level application.
     * <p>
     * The receiving activity can override this request with
     * {@link android.R.attr#autoRemoveFromRecents} or by explcitly calling
     * {@link android.app.Activity#finishAndRemoveTask()
     * Activity.finishAndRemoveTask()}.
     */

 1. 默认情况下由FLAG_ACTIVITY_NEW_DOCUMENT创建的新纪录，用户关闭时（按返回键或其他方式结束）它在最近任务中的入口会被移除。如果你想保留入口，就用本flag。
 2. 接收的活动可以用autoRemoveFromRecents属性或者调用Activity.finishAndRemoveTask()来覆盖本请求。

retainInRecents.gif

public static final int FLAG_ACTIVITY_RETAIN_IN_RECENTS = 0x00002000;

11. FLAG_ACTIVITY_SINGLE_TOP

    /**
     * If set, the activity will not be launched if it is already running
     * at the top of the history stack.
     */

 1. 新活动已存在历史栈的顶端时就不会重新启动。

singleTop.gif

public static final int FLAG_ACTIVITY_SINGLE_TOP = 0x20000000;

12. FLAG_ACTIVITY_FORWARD_RESULT

    /**
     * If set and this intent is being used to launch a new activity from an
     * existing one, then the reply target of the existing activity will be
     * transfered to the new activity.  This way the new activity can call
     * {@link android.app.Activity#setResult} and have that result sent back to
     * the reply target of the original activity.
     */

 1. （当前活动由源活动启动）本intent从当前活动启动新活动时，源活动的接收目标会从当前活动转移为新活动。新活动调用setResult的数据会传送给源活动。

public static final int FLAG_ACTIVITY_FORWARD_RESULT = 0x02000000;

13. FLAG_ACTIVITY_PREVIOUS_IS_TOP

    /**
     * If set and this intent is being used to launch a new activity from an
     * existing one, the current activity will not be counted as the top
     * activity for deciding whether the new intent should be delivered to
     * the top instead of starting a new one.  The previous activity will
     * be used as the top, with the assumption being that the current activity
     * will finish itself immediately.
     */

 1. 本intent从当前活动启动新活动时，当前活动不会被视为顶端活动，不管是决定传intent给顶端还是启动新活动。新活动被当做顶端活动使用，假设当前活动立即销毁了。

public static final int FLAG_ACTIVITY_PREVIOUS_IS_TOP = 0x01000000;

14. FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS

    /**
     * If set, the new activity is not kept in the list of recently launched
     * activities.
     */

 1. 新活动不会保存在最近启动的活动列表中。

public static final int FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS = 0x00800000;

15. FLAG_ACTIVITY_BROUGHT_TO_FRONT

    /**
     * This flag is not normally set by application code, but set for you by
     * the system as described in the
     * {@link android.R.styleable#AndroidManifestActivity_launchMode
     * launchMode} documentation for the singleTask mode.
     */

 1. 本flag一般不由应用代码设置，singleTask模式时系统会给你设置。

public static final int FLAG_ACTIVITY_BROUGHT_TO_FRONT = 0x00400000;

16. FLAG_ACTIVITY_RESET_TASK_IF_NEEDED

    /**
     * If set, and this activity is either being started in a new task or
     * bringing to the top an existing task, then it will be launched as
     * the front door of the task.  This will result in the application of
     * any affinities needed to have that task in the proper state (either
     * moving activities to or from it), or simply resetting that task to
     * its initial state if needed.
     */

 1. 新活动在新任务中启动或者被放到一个已存在任务的顶端时，会被当做任务的前门来启动。这会导致任何相关性的活动在适当状态下需要拥有这个任务（无论移动活动到它里面或者是移走），或者在需要时简单地重置任务到初始状态。

public static final int FLAG_ACTIVITY_RESET_TASK_IF_NEEDED = 0x00200000;

17. FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY

    /**
     * This flag is not normally set by application code, but set for you by
     * the system if this activity is being launched from history
     * (longpress home key).
     */

 1. 本flag一般不由应用代码设置，活动从历史栈中启动（长按home键）时系统会给你设置。

public static final int FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY = 0x00100000;

18. FLAG_ACTIVITY_NO_USER_ACTION

    /**
     * If set, this flag will prevent the normal {@link android.app.Activity#onUserLeaveHint}
     * callback from occurring on the current frontmost activity before it is
     * paused as the newly-started activity is brought to the front.
     *
     * <p>Typically, an activity can rely on that callback to indicate that an
     * explicit user action has caused their activity to be moved out of the
     * foreground. The callback marks an appropriate point in the activity's
     * lifecycle for it to dismiss any notifications that it intends to display
     * "until the user has seen them," such as a blinking LED.
     *
     * <p>If an activity is ever started via any non-user-driven events such as
     * phone-call receipt or an alarm handler, this flag should be passed to {@link
     * Context#startActivity Context.startActivity}, ensuring that the pausing
     * activity does not think the user has acknowledged its notification.
     */

 1. 本flag会阻止当前最前面活动的onUserLeaveHint回调，在它被新启动的活动造成paused状态时。
 2. 通常，一个活动在受到用户操作而从前面移走的时候会调用上面的回调。该回调标志着活动生命周期中的一个点，在该点活动会隐藏它想要显示的”直到用户看到“的东西，比如闪烁的LED灯。
 3. 如果一个活动曾经由非用户驱动的事件比如来电或闹钟启动，应该在startActivity中添加本flag，以保证暂停时活动知道用户并没有看到通知。

public static final int FLAG_ACTIVITY_NO_USER_ACTION = 0x00040000;

19. FLAG_ACTIVITY_TASK_ON_HOME

    /**
     * If set in an Intent passed to {@link Context#startActivity Context.startActivity()},
     * this flag will cause a newly launching task to be placed on top of the current
     * home activity task (if there is one).  That is, pressing back from the task
     * will always return the user to home even if that was not the last activity they
     * saw.   This can only be used in conjunction with {@link #FLAG_ACTIVITY_NEW_TASK}.
     */

 1. 本flag会造成新的启动任务放在当前主页活动任务（如果有的话）的顶端。也就是说，在任务中按返回键总是会回到主页，即使上一个用户看到的活动不是主页。本flag只能与FLAG_ACTIVITY_NEW_TASK联合使用。

public static final int FLAG_ACTIVITY_TASK_ON_HOME = 0X00004000;

20. FLAG_ACTIVITY_LAUNCH_ADJACENT

    /**
     * This flag is only used in split-screen multi-window mode. The new activity will be displayed
     * adjacent to the one launching it. This can only be used in conjunction with
     * {@link #FLAG_ACTIVITY_NEW_TASK}. Also, setting {@link #FLAG_ACTIVITY_MULTIPLE_TASK} is
     * required if you want a new instance of an existing activity to be created.
     */

 1. 本flag只在分屏多窗口模式下使用。新活动会显示在旧活动旁边。本flag只能跟FLAG_ACTIVITY_NEW_TASK联合使用。并且如果你想创建一个已存在活动的新实例，那么要设置FLAG_ACTIVITY_MULTIPLE_TASK。

public static final int FLAG_ACTIVITY_LAUNCH_ADJACENT = 0x00001000

Intent.addFlags() 启动Activity的20种flags全解析