How to start next activity if the top activity is stopped/killed

In Android system, activities are managed with stack/task model.

Sometimes the top activity may stop due to crash, ANR, app OTA, LMK, .... In this situation, AMS have to remove the top activity and start another activity as top.

1. Back trace

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityManagerService.startProcessLocked(ActivityManagerService.java:3220)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityManagerService.startProcessLocked(ActivityManagerService.java:3165)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityManagerService.startProcessLocked(ActivityManagerService.java:3043)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStackSupervisor.startSpecificActivityLocked(ActivityStackSupervisor.java:1352)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStack.resumeTopActivityInnerLocked(ActivityStack.java:2023)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStack.resumeTopActivityLocked(ActivityStack.java:1547)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStack.resumeTopActivityLocked(ActivityStack.java:1530)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStack.finishCurrentActivityLocked(ActivityStack.java:2996)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStack.finishActivityLocked(ActivityStack.java:2924)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStack.forceStopPackageLocked(ActivityStack.java:4091)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityStackSupervisor.forceStopPackageLocked(ActivityStackSupervisor.java:2567)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityManagerService.forceStopPackageLocked(ActivityManagerService.java:6228)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityManagerService.access$400(ActivityManagerService.java:279)

04-16 18:58:52.646 523 552 W ActivityManager: at
com.android.server.am.ActivityManagerService$MainHandler.handleMessage(ActivityManagerService.java:1702)

04-16 18:58:52.646 523 552 W ActivityManager: at android.os.Handler.dispatchMessage(Handler.java:102)

04-16 18:58:52.646 523 552 W ActivityManager: at android.os.Looper.loop(Looper.java:135)

04-16 18:58:52.646 523 552 W ActivityManager: at android.os.HandlerThread.run(HandlerThread.java:61)

04-16 18:58:52.646 523 552 W ActivityManager: at com.android.server.ServiceThread.run(ServiceThread.java:46)

2. How to select next activity

It is implemented in ActivityStack.resumeTopActivityInnerLocked method.

1554    final boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {
1555        if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen("");
1556Return if AMS not ready
1557        if (!mService.mBooting && !mService.mBooted) {
1558            // Not ready yet!
1559            return false;
1560        }
1561
1562        ActivityRecord parent = mActivityContainer.mParentActivity;
1563        if ((parent != null && parent.state != ActivityState.RESUMED) ||
1564                !mActivityContainer.isAttachedLocked()) {
1565            // Do not resume this stack if its parent is not resumed.
1566            // TODO: If in a loop, make sure that parent stack resumeTopActivity is called 1st.
1567            return false;
1568        }
1569
1570        cancelInitializingActivities();
1571Find the next non-finish activity in current stack. Search activity from top task to bottom task.
1572        // Find the first activity that is not finishing.
1573        final ActivityRecord next = topRunningActivityOnStackLocked(null);
1574
1575        // Remember how we'll process this pause/resume situation, and ensure
1576        // that the state is reset however we wind up proceeding.
1577        final boolean userLeaving = mStackSupervisor.mUserLeaving;
1578        mStackSupervisor.mUserLeaving = false;
1579Resume launcher instead if there is no non-finish activity in current stack
1580        final TaskRecord prevTask = prev != null ? prev.task : null;
1581        if (next == null) {
1582            // There are no more activities!  Let's just start up the
1583            // Launcher...
1584            ActivityOptions.abort(options);
1585            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: No more activities go home");
1586            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1587            // Only resume home if on home display
1588            final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?
1589                    HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();
1590            return isOnHomeDisplay() &&
1591                    mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "noMoreActivities");
1592        }
1593
1594        next.delayedResume = false;
1619        // If the top activity is the resumed one, nothing to do.
1620        if (mResumedActivity == next && next.state == ActivityState.RESUMED &&
1621                    mStackSupervisor.allResumedActivitiesComplete()) {
1622            // Make sure we have executed any pending transitions, since there
1623            // should be nothing left to do at this point.
1624            mWindowManager.executeAppTransition();
1625            mNoAnimActivities.clear();
1626            ActivityOptions.abort(options);
1627            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Top activity resumed " + next);
1628            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1629            return false;
1630        }
1631
1632        final TaskRecord nextTask = next.task;
1633        if (prevTask != null && prevTask.stack == this &&
1634                prevTask.isOverHomeStack() && prev.finishing && prev.frontOfTask) {
1635            if (DEBUG_STACK)  mStackSupervisor.validateTopActivitiesLocked();
1636            if (prevTask == nextTask) {
1637                prevTask.setFrontOfTask();
1638            } else if (prevTask != topTask()) {
1639                // This task is going away but it was supposed to return to the home stack.
1640                // Now the task above it has to return to the home task instead.
1641                final int taskNdx = mTaskHistory.indexOf(prevTask) + 1;
1642                mTaskHistory.get(taskNdx).setTaskToReturnTo(HOME_ACTIVITY_TYPE);
1643            } else if (!isOnHomeDisplay()) {
1644                return false;
1645            } else if (!isHomeStack()){
1646                if (DEBUG_STATES) Slog.d(TAG,
1647                        "resumeTopActivityLocked: Launching home next");
1648                final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?
1649                        HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();
1650                return mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "prevFinished");
1651            }
1652        }
1653
1654        // If we are sleeping, and there is no resumed activity, and the top
1655        // activity is paused, well that is the state we want.
1656        if (mService.isSleepingOrShuttingDown()
1657                && mLastPausedActivity == next
1658                && mStackSupervisor.allPausedActivitiesComplete()) {
1659            // Make sure we have executed any pending transitions, since there
1660            // should be nothing left to do at this point.
1661            mWindowManager.executeAppTransition();
1662            mNoAnimActivities.clear();
1663            ActivityOptions.abort(options);
1664            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Going to sleep and all paused");
1665            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1666            return false;
1667        }
1668
1669        // Make sure that the user who owns this activity is started.  If not,
1670        // we will just leave it as is because someone should be bringing
1671        // another user's activities to the top of the stack.
1672        if (mService.mStartedUsers.get(next.userId) == null) {
1673            Slog.w(TAG, "Skipping resume of top activity " + next
1674                    + ": user " + next.userId + " is stopped");
1675            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1676            return false;
1677        }
1678
1679        // The activity may be waiting for stop, but that is no longer
1680        // appropriate for it.
1681        mStackSupervisor.mStoppingActivities.remove(next);
1682        mStackSupervisor.mGoingToSleepActivities.remove(next);
1683        next.sleeping = false;
1684        mStackSupervisor.mWaitingVisibleActivities.remove(next);
1685
1686        if (DEBUG_SWITCH) Slog.v(TAG, "Resuming " + next);
1687
1688        // If we are currently pausing an activity, then don't do anything
1689        // until that is done.
1690        if (!mStackSupervisor.allPausedActivitiesComplete()) {
1691            if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG,
1692                    "resumeTopActivityLocked: Skip resume: some activity pausing.");
1693            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1694            return false;
1695        }
1725
1726        // We need to start pausing the current activity so the top one
1727        // can be resumed...
1728        boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;
1729        boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);
1730        if (mResumedActivity != null) {
1731            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity);
1732            pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);
1733        }
1734        if (pausing) {
1735            if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG,
1736                    "resumeTopActivityLocked: Skip resume: need to start pausing");
1737            // At this point we want to put the upcoming activity's process
1738            // at the top of the LRU list, since we know we will be needing it
1739            // very soon and it would be a waste to let it get killed if it
1740            // happens to be sitting towards the end.
1741            if (next.app != null && next.app.thread != null) {
1742                mService.updateLruProcessLocked(next.app, true, null);
1743            }
1744            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1745            return true;
1746        }
1747
1748        // If the most recent activity was noHistory but was only stopped rather
1749        // than stopped+finished because the device went to sleep, we need to make
1750        // sure to finish it as we're making a new activity topmost.
1751        if (mService.isSleeping() && mLastNoHistoryActivity != null &&
1752                !mLastNoHistoryActivity.finishing) {
1753            if (DEBUG_STATES) Slog.d(TAG, "no-history finish of " + mLastNoHistoryActivity +
1754                    " on new resume");
1755            requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,
1756                    null, "no-history", false);
1757            mLastNoHistoryActivity = null;
1758        }
1759
1760        if (prev != null && prev != next) {
1761            if (!prev.waitingVisible && next != null && !next.nowVisible) {
1762                prev.waitingVisible = true;
1763                mStackSupervisor.mWaitingVisibleActivities.add(prev);
1764                if (DEBUG_SWITCH) Slog.v(
1765                        TAG, "Resuming top, waiting visible to hide: " + prev);
1766            } else {
1767                // The next activity is already visible, so hide the previous
1768                // activity's windows right now so we can show the new one ASAP.
1769                // We only do this if the previous is finishing, which should mean
1770                // it is on top of the one being resumed so hiding it quickly
1771                // is good.  Otherwise, we want to do the normal route of allowing
1772                // the resumed activity to be shown so we can decide if the
1773                // previous should actually be hidden depending on whether the
1774                // new one is found to be full-screen or not.
1775                if (prev.finishing) {
1776                    mWindowManager.setAppVisibility(prev.appToken, false);
1777                    if (DEBUG_SWITCH) Slog.v(TAG, "Not waiting for visible to hide: "
1778                            + prev + ", waitingVisible="
1779                            + (prev != null ? prev.waitingVisible : null)
1780                            + ", nowVisible=" + next.nowVisible);
1781                } else {
1782                    if (DEBUG_SWITCH) Slog.v(TAG, "Previous already visible but still waiting to hide: "
1783                        + prev + ", waitingVisible="
1784                        + (prev != null ? prev.waitingVisible : null)
1785                        + ", nowVisible=" + next.nowVisible);
1786                }
1787            }
1788        }
1789
1790        // Launching this app's activity, make sure the app is no longer
1791        // considered stopped.
1792        try {
1793            AppGlobals.getPackageManager().setPackageStoppedState(
1794                    next.packageName, false, next.userId); /* TODO: Verify if correct userid */
1795        } catch (RemoteException e1) {
1796        } catch (IllegalArgumentException e) {
1797            Slog.w(TAG, "Failed trying to unstop package "
1798                    + next.packageName + ": " + e);
1799        }
1800
1801        // We are starting up the next activity, so tell the window manager
1802        // that the previous one will be hidden soon.  This way it can know
1803        // to ignore it when computing the desired screen orientation.
1804        boolean anim = true;
1810        if (prev != null) {
1811            if (prev.finishing) {
1812                if (DEBUG_TRANSITION) Slog.v(TAG,
1813                        "Prepare close transition: prev=" + prev);
1814                if (mNoAnimActivities.contains(prev)) {
1815                    anim = false;
1816                    mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
1817                } else {
1818                    mWindowManager.prepareAppTransition(prev.task == next.task
1819                            ? AppTransition.TRANSIT_ACTIVITY_CLOSE
1820                            : AppTransition.TRANSIT_TASK_CLOSE, false);
1821                }
1822                mWindowManager.setAppWillBeHidden(prev.appToken);
1823                mWindowManager.setAppVisibility(prev.appToken, false);
1824            } else {
1825                if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: prev=" + prev);
1826                if (mNoAnimActivities.contains(next)) {
1827                    anim = false;
1828                    mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
1829                } else {
1830                    mWindowManager.prepareAppTransition(prev.task == next.task
1831                            ? AppTransition.TRANSIT_ACTIVITY_OPEN
1832                            : next.mLaunchTaskBehind
1833                                    ? AppTransition.TRANSIT_TASK_OPEN_BEHIND
1834                                    : AppTransition.TRANSIT_TASK_OPEN, false);
1835                }
1836            }
1841        } else {
1842            if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: no previous");
1843            if (mNoAnimActivities.contains(next)) {
1844                anim = false;
1845                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);
1846            } else {
1847                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_ACTIVITY_OPEN, false);
1848            }
1849        }
1850
1851        Bundle resumeAnimOptions = null;
1852        if (anim) {
1853            ActivityOptions opts = next.getOptionsForTargetActivityLocked();
1854            if (opts != null) {
1855                resumeAnimOptions = opts.toBundle();
1856            }
1857            next.applyOptionsLocked();
1858        } else {
1859            next.clearOptionsLocked();
1860        }
1861
1862        ActivityStack lastStack = mStackSupervisor.getLastStack();
1863        if (next.app != null && next.app.thread != null) {
1871
1872            if (DEBUG_SWITCH) Slog.v(TAG, "Resume running: " + next);
1873
1874            // This activity is now becoming visible.
1875            mWindowManager.setAppVisibility(next.appToken, true);
1876
1877            // schedule launch ticks to collect information about slow apps.
1878            next.startLaunchTickingLocked();
1879
1880            ActivityRecord lastResumedActivity =
1881                    lastStack == null ? null :lastStack.mResumedActivity;
1882            ActivityState lastState = next.state;
1883
1884            mService.updateCpuStats();
1885
1886            if (DEBUG_STATES) Slog.v(TAG, "Moving to RESUMED: " + next + " (in existing)");
1887            next.state = ActivityState.RESUMED;
1888            mResumedActivity = next;
1889            next.task.touchActiveTime();
1890            mService.addRecentTaskLocked(next.task);
1891            mService.updateLruProcessLocked(next.app, true, null);
1892            updateLRUListLocked(next);
1893            mService.updateOomAdjLocked();
1894
1895            // Have the window manager re-evaluate the orientation of
1896            // the screen based on the new activity order.
1897            boolean notUpdated = true;
1898            if (mStackSupervisor.isFrontStack(this)) {
1899                Configuration config = mWindowManager.updateOrientationFromAppTokens(
1900                        mService.mConfiguration,
1901                        next.mayFreezeScreenLocked(next.app) ? next.appToken : null);
1902                if (config != null) {
1903                    next.frozenBeforeDestroy = true;
1904                }
1905                notUpdated = !mService.updateConfigurationLocked(config, next, false, false);
1906            }
1907
1908            if (notUpdated) {
1909                // The configuration update wasn't able to keep the existing
1910                // instance of the activity, and instead started a new one.
1911                // We should be all done, but let's just make sure our activity
1912                // is still at the top and schedule another run if something
1913                // weird happened.
1914                ActivityRecord nextNext = topRunningActivityLocked(null);
1915                if (DEBUG_SWITCH || DEBUG_STATES) Slog.i(TAG,
1916                        "Activity config changed during resume: " + next
1917                        + ", new next: " + nextNext);
1918                if (nextNext != next) {
1919                    // Do over!
1920                    mStackSupervisor.scheduleResumeTopActivities();
1921                }
1922                if (mStackSupervisor.reportResumedActivityLocked(next)) {
1923                    mNoAnimActivities.clear();
1924                    if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1925                    return true;
1926                }
1927                if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1928                return false;
1929            }
1930
1931            try {
1932                // Deliver all pending results.
1933                ArrayList<ResultInfo> a = next.results;
1934                if (a != null) {
1935                    final int N = a.size();
1936                    if (!next.finishing && N > 0) {
1937                        if (DEBUG_RESULTS) Slog.v(
1938                                TAG, "Delivering results to " + next
1939                                + ": " + a);
1940                        next.app.thread.scheduleSendResult(next.appToken, a);
1941                    }
1942                }
1943
1944                if (next.newIntents != null) {
1945                    next.app.thread.scheduleNewIntent(next.newIntents, next.appToken);
1946                }
1947
1948                EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY, next.userId,
1949                        System.identityHashCode(next), next.task.taskId, next.shortComponentName);
1954
1955                next.sleeping = false;
1956                mService.showAskCompatModeDialogLocked(next);
1957                next.app.pendingUiClean = true;
1958                next.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_TOP);
1959                next.clearOptionsLocked();
1960                next.app.thread.scheduleResumeActivity(next.appToken, next.app.repProcState,
1961                        mService.isNextTransitionForward(), resumeAnimOptions);
1962
1963                mStackSupervisor.checkReadyForSleepLocked();
1964
1965                if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Resumed " + next);
1966            } catch (Exception e) {
1967                // Whoops, need to restart this activity!
1968                if (DEBUG_STATES) Slog.v(TAG, "Resume failed; resetting state to "
1969                        + lastState + ": " + next);
1970                next.state = lastState;
1971                if (lastStack != null) {
1972                    lastStack.mResumedActivity = lastResumedActivity;
1973                }
1974                Slog.i(TAG, "Restarting because process died: " + next);
1975                if (!next.hasBeenLaunched) {
1976                    next.hasBeenLaunched = true;
1977                } else  if (SHOW_APP_STARTING_PREVIEW && lastStack != null &&
1978                        mStackSupervisor.isFrontStack(lastStack)) {
1979                    mWindowManager.setAppStartingWindow(
1980                            next.appToken, next.packageName, next.theme,
1981                            mService.compatibilityInfoForPackageLocked(next.info.applicationInfo),
1982                            next.nonLocalizedLabel, next.labelRes, next.icon, next.logo,
1983                            next.windowFlags, null, true);
1984                }
1985                mStackSupervisor.startSpecificActivityLocked(next, true, false);
1986                if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
1987                return true;
1988            }
1989
1990            // From this point on, if something goes wrong there is no way
1991            // to recover the activity.
1992            try {
1993                next.visible = true;
1994                completeResumeLocked(next);
1995            } catch (Exception e) {
1996                // If any exception gets thrown, toss away this
1997                // activity and try the next one.
1998                Slog.w(TAG, "Exception thrown during resume of " + next, e);
1999                requestFinishActivityLocked(next.appToken, Activity.RESULT_CANCELED, null,
2000                        "resume-exception", true);
2001                if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
2002                return true;
2003            }
2004            next.stopped = false;
2006        } else {
2007            // Whoops, need to restart this activity!
2008            if (!next.hasBeenLaunched) {
2009                next.hasBeenLaunched = true;
2010            } else {
2011                if (SHOW_APP_STARTING_PREVIEW) {
2012                    mWindowManager.setAppStartingWindow(
2013                            next.appToken, next.packageName, next.theme,
2014                            mService.compatibilityInfoForPackageLocked(
2015                                    next.info.applicationInfo),
2016                            next.nonLocalizedLabel,
2017                            next.labelRes, next.icon, next.logo, next.windowFlags,
2018                            null, true);
2019                }
2020                if (DEBUG_SWITCH) Slog.v(TAG, "Restarting: " + next);
2021            }
2022            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Restarting " + next);
2023            mStackSupervisor.startSpecificActivityLocked(next, true, true);
2024        }
2025
2026        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
2027
2034        return true;
2035    }