深入排查 FLAG 导致的 Activity 无法正常启动

发表于 3年以前 | 总阅读数：337 次

深入源码排查 FLAG_ACTIVITY_NEW_TASK 导致的 Activity 无法正常启动

引言

众所周知 Android 中 Activity 有四种启动模式，决定了是否创建新的 Activity 实例或复用当前实例。但是实际上 Activity 的启动十分复杂，不单单是 android:launchMode 就能决定的，多个 Intent Flag 都能改变启动的行为模式，除此之外还会根据 android:taskAffinity 的值来判断对应任务栈是否存在。

基本 LaunchMode 行为模式

首先复习一下最基本的 LaunchMode 行为模式：

standard：默认值，每次启动都会创建一个新的 Activity 实例。
singleTop：如果待启动 Activity 处于栈顶则重用实例回调其 onNewIntent() 方法，否则新建实例。
singleTask：如果已有任务栈中存在该 Activity 实例，则将实例之上的其他 Activity 清空并回调实例的 onNewIntent() 方法，否则新建栈创建 Activity 实例。
singleInstance：在单独一个栈中创建，该栈不会再创建其他 Activity，当系统中存在实例时回调实例的 onNewIntent() 方法。

这是我们最熟知的启动模式，但是需要注意的是：上述行为模式仅限于未添加任何 Flag，并且没有改变 taskAffinity 的前提下。

Service 启动 Activity

如前所述，如果单纯的 Activity 启动 Activiy 且不添加任何 Flag 是没问题的，但是如果我们使用 Service 启动 Activity 就会遇到一个异常，在 Framework（本文 Framework 源码均来自 Android 11 版本）的源码中会抛出异常：

//android.app.ContextImpl
@Override
public void startActivity(Intent intent, Bundle options) {
    ……
    if ((intent.getFlags() & Intent.FLAG_ACTIVITY_NEW_TASK) == 0
            && (targetSdkVersion < Build.VERSION_CODES.N || targetSdkVersion >= Build.VERSION_CODES.P)
            && (options == null || ActivityOptions.fromBundle(options).getLaunchTaskId() == -1)) {
        throw new AndroidRuntimeException(
                "Calling startActivity() from outside of an Activity "
                        + " context requires the FLAG_ACTIVITY_NEW_TASK flag."
                        + " Is this really what you want?");
    }
    ……
}

所以在 Service 中启动 Activity 必须添加 FLAG_ACTIVITY_NEW_TASK，原因也很简单，每个 Activity 启动都需要一个任务栈，非 Activity 的 context 存在后台启动的可能，而此时前台是其他 App 的任务栈，甚至我们的 App 根本没有创建过任务栈，为了防止这些无法预料的情况出现，被强制要求添加这个 Flag。

standard 是四种启动模式中最简单也最常见的，其他三种各有各的流程，唯独 standard 直接简单粗暴创建一个新的实例放到栈顶。那么问题来了，是否所有的 standard 都能创建一个新的实例呢？

无法启动的 `standard` Activity

复现流程

将所有不影响异常的业务代码删除之后得到的最精简复现流程如下：

Service 附加 FLAG_ACTIVITY_NEW_TASK 启动 A_Activity：

  startActivity(Intent(this, AActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })

A_Activity 启动 B_Activity：

  startActivity(Intent(this, BActivity::class.java))

Service 附加 FLAG_ACTIVITY_NEW_TASK 启动 A_Activity：

  startActivity(Intent(this, AActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })

会发现 A_Activity 无法被启动，A_Activity 和 B_Activity 均未回调 onCreate、onResume 或者 onNewIntent 等生命周期函数，也没有任何 Crash 或者 ANR 的日志发生，点击 B_Activity 可以正常操作。

原因推测

首先排除 Service 的 Context 的原因，因为我们可以构造如下流程，实验会发现 A_Activity 依然无法启动：

MainActivity 中先 finish 后附加 FLAG_ACTIVITY_NEW_TASK 启动 A_Activity：

  finish()
startActivity(Intent(this, AActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })

A_Activity 启动 B_Activity：

  startActivity(Intent(this, BActivity::class.java))

B_Activity 附加 FLAG_ACTIVITY_NEW_TASK 启动 A_Activity：

  startActivity(Intent(this, AActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })

那么从使用排除法得到 FLAG_ACTIVITY_NEW_TASK 有可能是原因了。另外细心观察上面的步骤，会发现第一步先 finish 再 startActivity，如果去掉 finish 做实验会发现其实可以成功启动 A_Activity，那么另一个原因应该就是 finish 了。

源码追踪

startActivityInner

Framework 的 Activity 启动源码非常繁杂，但是真正对 Activity 栈进行操作的函数是 ActivityStarter#startActivityInner，所以我们将着重分析这个方法。

//com.android.server.wm.ActivityStarter
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
        IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
        int startFlags, boolean doResume, ActivityOptions options, Task inTask,
        boolean restrictedBgActivity, NeededUriGrants intentGrants) {
    setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
            voiceInteractor, restrictedBgActivity);

    // 计算 Activity 的启动 Flag
    computeLaunchingTaskFlags();
    ……
    // 确定是否将新 Activity 插入现有任务栈中，如果是则返回对应的 ActivityRecord，否则返回 null
    final Task reusedTask = getReusableTask();
    ……
    // 计算是否存在可用的任务栈
    final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
    final boolean newTask = targetTask == null;
    mTargetTask = targetTask;

    computeLaunchParams(r, sourceRecord, targetTask);

    // 检查是否允许在给定任务栈或者新栈上启动 Activity
    int startResult = isAllowedToStart(r, newTask, targetTask);
    if (startResult != START_SUCCESS) {
        return startResult;
    }

    final ActivityRecord targetTaskTop = newTask ? null : targetTask.getTopNonFinishingActivity();
    if (targetTaskTop != null) {
        // 为了这次启动回收目标任务栈
        startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
        if (startResult != START_SUCCESS) {
            return startResult;
        }
    } else {
        mAddingToTask = true;
    }
    ……
}

由于 startActivityInner 方法依然比较长，所以将只看几个可能产生影响的地方，对任务栈有影响的关键方法是 getReusableTask 和 recycleTask。

getReusableTask

首先先看看 getReusableTask 的源码：

//com.android.server.wm.ActivityStarter
private Task getReusableTask() {
    // 新 Activity 放到现有任务栈中的条件：
    // 1. Flags 包含 FLAG_ACTIVITY_NEW_TASK 但是不包含 FLAG_ACTIVITY_MULTIPLE_TASK
    // 2. launchMode 是 singleInstance 或 singleTask
    boolean putIntoExistingTask = ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0 &&
            (mLaunchFlags & FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
            || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK);
    putIntoExistingTask &= mInTask == null && mStartActivity.resultTo == null;
    ActivityRecord intentActivity = null;
    if (putIntoExistingTask) {
        if (LAUNCH_SINGLE_INSTANCE == mLaunchMode) {
            // singleInstance 相关
            intentActivity = mRootWindowContainer.findActivity(mIntent, mStartActivity.info,
                    mStartActivity.isActivityTypeHome());
        } else if ((mLaunchFlags & FLAG_ACTIVITY_LAUNCH_ADJACENT) != 0) {
            // 分屏相关
            intentActivity = mRootWindowContainer.findActivity(mIntent, mStartActivity.info,
                    !(LAUNCH_SINGLE_TASK == mLaunchMode));
        } else {
            // 除上述情况之外的情况寻找最合适的任务栈
            intentActivity =
                    mRootWindowContainer.findTask(mStartActivity, mPreferredTaskDisplayArea);
        }
    }
    ……
    return intentActivity != null ? intentActivity.getTask() : null;
}

根据上述源码，由于我们的 Flags 中包含 FLAG_ACTIVITY_NEW_TASK 但是不包含 FLAG_ACTIVITY_MULTIPLE_TASK，所以会从现有的任务栈中寻找一个最合适的任务栈并将待启动的 Activity 插入其中，在我们举的例子中，会获取到 B_Activity 所在的任务栈。

recycleTask

接着来看看 recycleTask 的源码：

//com.android.server.wm.ActivityStarter
int recycleTask(Task targetTask, ActivityRecord targetTaskTop, Task reusedTask,
        NeededUriGrants intentGrants) {
    // 不同用户下不回收任务栈，直接启动 Activity 并添加到任务栈中
    if (targetTask.mUserId != mStartActivity.mUserId) {
        mTargetStack = targetTask.getStack();
        mAddingToTask = true;
        // 第一处 return
        return START_SUCCESS;
    }
    ……
    setTargetStackIfNeeded(targetTaskTop);
    ……
    // START_FLAG_ONLY_IF_NEEDED 表示启动和被启动者是同一个
    if ((mStartFlags & START_FLAG_ONLY_IF_NEEDED) != 0) {
        if (!mMovedToFront && mDoResume) {
            ……
            mTargetStack.moveToFront("intentActivityFound");
        }
        resumeTargetStackIfNeeded();
        // 第二处 return
        return START_RETURN_INTENT_TO_CALLER;
    }

    complyActivityFlags(targetTask,
            reusedTask != null ? reusedTask.getTopNonFinishingActivity() : null, intentGrants);
    ……
    if (mAddingToTask) {
        // 第三处 return
        return START_SUCCESS;
    }
    ……
    resumeTargetStackIfNeeded();
    mLastStartActivityRecord =
            targetTaskTop.finishing ? targetTask.getTopNonFinishingActivity() : targetTaskTop;
    // 第四处 return
    return mMovedToFront ? START_TASK_TO_FRONT : START_DELIVERED_TO_TOP;
}

根据单步调试，我们可以知道 recycleTask 返回的结果是 START_DELIVERED_TO_TOP，在 startActivityInner 中 recycleTask 部分的相关代码是：

//com.android.server.wm.ActivityStarter#startActivityInner
startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
if (startResult != START_SUCCESS) {
    return startResult;
}

即根本没有运行 startActivityInner 后半部分代码，启动失败原因就在于此，因此不再逐一解析 recycleTask，而是着眼于为何没有返回 START_SUCCESS，可以逐一寻找 recycleTask 中所有 return 的地方：

同一用户环境下，因此不会返回 START_SUCCESS
START_FLAG_ONLY_IF_NEEDED 表示启动和被启动者是同一个 Activity，因此不会返回 START_RETURN_INTENT_TO_CALLER
根据 mAddingToTask 是否为 true 来确定是否返回 START_SUCCESS，关联方法是 complyActivityFlags，此处需要分析一下为何 mAddingToTask 为 false
根据 mMovedToFront 判断返回为 START_TASK_TO_FRONT 还是 START_DELIVERED_TO_TOP，关联的方法是 setTargetStackIfNeeded，由于上一步已经断绝了返回 START_SUCCESS 的可能，无法正常创建一个 Activity 实例了，就不再分析此方法。

complyActivityFlags

//com.android.server.wm.ActivityStarter
private void complyActivityFlags(Task targetTask, ActivityRecord reusedActivity,
        NeededUriGrants intentGrants) {
    ActivityRecord targetTaskTop = targetTask.getTopNonFinishingActivity();
    final boolean resetTask =
            reusedActivity != null && (mLaunchFlags & FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0;
    if (resetTask) {
        targetTaskTop = mTargetStack.resetTaskIfNeeded(targetTaskTop, mStartActivity);
    }

    if ((mLaunchFlags & (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK))
            == (FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK)) {
        // 如果设置了 FLAG_ACTIVITY_NEW_TASK 和 FLAG_ACTIVITY_CLEAR_TASK
        // 清除目标任务栈上所有的 Activity，并将待启动 Activity 的 intent 信息设置给目标任务栈
        targetTask.performClearTaskLocked();
        targetTask.setIntent(mStartActivity);
        mAddingToTask = true;
    } else if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0
            || isDocumentLaunchesIntoExisting(mLaunchFlags)
            || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
        // 如果设置了 FLAG_ACTIVITY_CLEAR_TOP；文档模式；launchMode 是 singleInstance 或 singleTask
        // 清除待启动 Activity 在任务栈之上的所有 Activity
        final ActivityRecord top = targetTask.performClearTaskForReuseLocked(mStartActivity,
                mLaunchFlags);

        if (targetTaskTop.getTask() == null) {
            targetTask.addChild(targetTaskTop);
        }

        if (top != null) {
            if (top.isRootOfTask()) {
                top.getTask().setIntent(mStartActivity);
            }
            deliverNewIntent(top, intentGrants);
        } else {
            mAddingToTask = true;
            if (targetTask.getStack() == null) {
                mTargetStack =
                        getLaunchStack(mStartActivity, mLaunchFlags, null /* task */, mOptions);
                mTargetStack.addChild(targetTask, !mLaunchTaskBehind /* toTop */,
                        (mStartActivity.info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0);
            }
        }
    } else if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) == 0 && !mAddingToTask
            && (mLaunchFlags & FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {
        // 如果设置了 FLAG_ACTIVITY_REORDER_TO_FRONT、没有设置 FLAG_ACTIVITY_CLEAR_TOP 且待启动 Activity 已经在运行中
        // 将待启动 Activity 提到栈顶并回调 onNewIntent
        final ActivityRecord act =
                targetTask.findActivityInHistory(mStartActivity.mActivityComponent);
        if (act != null) {
            final Task task = act.getTask();
            task.moveActivityToFrontLocked(act);
            act.updateOptionsLocked(mOptions);
            deliverNewIntent(act, intentGrants);
            mTargetStack.mLastPausedActivity = null;
        } else {
            mAddingToTask = true;
        }
    } else if (mStartActivity.mActivityComponent.equals(targetTask.realActivity)) {
        // 待启动 Activity 的完整组件名如果和目标栈启动栈的 Activity 相同
        if (targetTask == mInTask) {
            // 目标任务栈和指定任务栈相同
            // 不新建 Activity 实例
        } else if (((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0
                        || LAUNCH_SINGLE_TOP == mLaunchMode)
                && targetTaskTop.mActivityComponent.equals(mStartActivity.mActivityComponent)
                && mStartActivity.resultTo == null) {
            // singleTop 模式下
            // 回调 onNewIntent
            if (targetTaskTop.isRootOfTask()) {
                targetTaskTop.getTask().setIntent(mStartActivity);
            }
            deliverNewIntent(targetTaskTop, intentGrants);
        } else if (!targetTask.isSameIntentFilter(mStartActivity)) {
            // 目标任务栈和待启动 Activity 的 Intent Filter 不同
            // 新建 Activity 实例
            mAddingToTask = true;
        } else if (reusedActivity == null) {
            // 没用复用的 Activity
            // 新建 Activity 实例
            mAddingToTask = true;
        }
    } else if (!resetTask) {
        // 一般从快捷图标或通知中启动
        // 需要添加新的 Activity 到 Task 最上面
        mAddingToTask = true;
    } else if (!targetTask.rootWasReset) {
        // 希望把待启动 Activity 放到目标任务栈底部，但是现在的代码结构做不到，只把待启动 Activity 的 Intent 设置给目标任务栈
        targetTask.setIntent(mStartActivity);
    }
}

当我们单步调试进 complyActivityFlags 会发现，只设置了 FLAG_ACTIVITY_NEW_TASK，没有设置 FLAG_ACTIVITY_CLEAR_TASK、FLAG_ACTIVITY_CLEAR_TOP、FLAG_ACTIVITY_REORDER_TO_FRONT；启动模式是 standard；虽然待启动 Activity 的完整组件名如果和目标栈启动栈的 Activity 相同，但是却又不符合下面的所有判断；虽然可以进入 !resetTask 的分支却被上一个分支截胡……总之完美避过了所有能正常启动的 case。

resumeTopActivityInnerLocked

那么不能创建新的 Activity 实例会发生什么呢，这就需要关注 recycleTask 中的一个方法：resumeTargetStackIfNeeded，位于 complyActivityFlags 之后，用于将目标返回栈栈顶的 Activity 回调 onResume 方法，即虽然没有启动 A_Activity，但是把 B_Activity 给重新可见了。由于调用链路过长不多分析，但是层层调用后有一点需要关注，在 ActivityStack#resumeTopActivityInnerLocked 中：

//com.android.server.wm.ActivityStack#resumeTopActivityInnerLocked
if (mResumedActivity == next && next.isState(RESUMED)
        && taskDisplayArea.allResumedActivitiesComplete()) {
    executeAppTransition(options);
    if (DEBUG_STATES) Slog.d(TAG_STATES,
            "resumeTopActivityLocked: Top activity resumed " + next);
    return false;
}

B_Activity 本身就是 RESUMED 状态，所以会进入这个分支，不再继续 resumeTopActivityInnerLocked 后面的回调 onResume 逻辑直接返回。这就解释了为何 B_Activity 没有生命周期变化。

原因总结

我们原因推测时猜想 FLAG_ACTIVITY_NEW_TASK 可以得到证实，那么猜想 MainActivity 的 finish 是在哪里造成影响的呢？其实是 complyActivityFlags 的分支顺序，如果不 finish，目标任务栈启动栈的 Activity 是 MainActivity，跟 A_Activity 不同名，所以会进入 !resetTask 分支，但是如果 finish 掉 MainActivity，目标任务栈启动栈的 Activity 就是第一次启动的 A_Activity，会被截胡而无法进入 !resetTask 分支。

简单总结一下就是因为启动 Flag，启动模式，现有栈的情况种种机缘巧合，让分支逐一落空导致没有任何 Activity 被启动，既不会回调 onNewIntent 也不会新建一个 Activity 实例。原本会将目标返回栈栈顶的 Activity（即 B_Activity）重新 resume，但是巧合的是 B_Activity 本来就是 RESUMED 状态，所以也就不会回调 B_Activity 的 onResume。种种巧合之下的结果就是看上去什么都没有发生，新启动的 Activity 没有启动，上一个 Activity 的生命周期也不会发生变化。

解决办法

梳理清楚了流程解决方案就很简单了，很多地方都有能打破这种奇葩 case 的可能，让 startActivityInner 正常进行后面的逻辑处理，仅列举几个简单的方法，根据自身的业务自行处理：

使得 getReusableTask 中 putIntoExistingTask 为 false：比如设置第二次启动 A_Activity 的 Flag 为 FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_MULTIPLE_TASK；或者如果在允许的条件下（比如不是复现流程时的 Service 中启动），直接去掉 FLAG_ACTIVITY_NEW_TASK 即可。
只要让 complyActivityFlags 能进入 mAddingToTask 为 true 的 case ，这里分支非常多，所以方案也更多：比如设置第二次启动 A_Activity 的 Flag 为 FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK；或者就像前面分析 finish 的影响，注意栈的情况不要使得启动栈的 Activity 和待启动的 Activity 相同。

再现异常

复现流程

根据我们的业务需求，我们选择的方案如下：

Service 附加 FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK 启动 A_Activity，A_Activity 的 launchMode 为 singleInstance：

  startActivity(Intent(this, AActivity::class.java).apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK) })

A_Activity 启动 B_Activity：

  finish()//注：此处 finish 和异常无关，仅为业务需求，即使去掉也会发生异常
startActivity(Intent(this, BActivity::class.java))

同步骤 1 启动 A_Activity。
同步骤 2 启动 B_Activity。

此时会出现 B_Activity 没有新建实例，而是会回调 onRestart 启动了第一次创建的 B_Activity。

源码追踪

根据上面的分析我们轻车熟路了，这又是某些 case 下没有创建 B_Activity 的实例而直接回调的 onResume 导致的。但是之前无法启动 A_Activity 是因为添加了 FLAG_ACTIVITY_NEW_TASK，然而现在启动 B_Activity 可什么 Flag 都没加，就是最简单的 startActivity，B_Activity的 launchMode 也是最基本的 standard。

其实原因依然隐藏在源码中，startActivityInner 会调用 computeLaunchingTaskFlags 来计算启动时的 Flag：

private void computeLaunchingTaskFlags() {
    ……
    if (mInTask == null) {
        if (mSourceRecord == null) {
            if ((mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) == 0 && mInTask == null) {
                Slog.w(TAG, "startActivity called from non-Activity context; forcing " +
                        "Intent.FLAG_ACTIVITY_NEW_TASK for: " + mIntent);
                mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
            }
        } else if (mSourceRecord.launchMode == LAUNCH_SINGLE_INSTANCE) {
            mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
        } else if (isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) {
            mLaunchFlags |= FLAG_ACTIVITY_NEW_TASK;
        }
    }
}

在不指定启动栈时，三种情况下系统会默认给 Flag 加上 FLAG_ACTIVITY_NEW_TASK:

没有源 Activity（比如A启动B，则A为源 Activity）
源 Activity 的 launchMode 是 singleInstance
待启动 Activity 的 launchMode 是 singleInstance 或 singleTask

原因就显而易见了，我们的 A_Activity 的 launchMode 是singleInstance，所以系统给 Flag 加上了 FLAG_ACTIVITY_NEW_TASK，于是又回到了之前分析的场景中。

解决办法

解决办法上一个场景中也给出了，启动 B_Activity 时加上 FLAG_ACTIVITY_MULTIPLE_TASK即可：

finish()//注：此处 finish 和异常无关，仅为业务需求
startActivity(
    Intent(this, BActivity::class.java)
        .apply { addFlags(Intent.FLAG_ACTIVITY_MULTIPLE_TASK) })

总结

Activity 启动这块是非常复杂的，影响的因素也非常多，上面的两个场景还是属于比较简单的，仅仅是 FLAG_ACTIVITY_NEW_TASK 就造成了这么多的问题，而且看起都非常诡异难以排查，更不用说各种启动模式和 Flag 叠加时可能会遇到更多的坑点，不过一旦遇到了这些神坑，其实深入源码去研究有时候反而能更快得到结论。