Activity启动过程分析

/**

 * An entry in the history stack, representing an activity.
 */
final class ActivityRecord {
    final ComponentName realActivity;  // the intent component, or target of an alias.
    final String shortComponentName; // the short component name of the intent
    final String packageName; // the package implementing intent's component
    final String processName; // process where this component wants to run
    final String taskAffinity; // as per ActivityInfo.taskAffinity
    boolean fullscreen; // covers the full screen?
}

final class TaskRecord {

    /** List of all activities in the task arranged in history order */

    final ArrayList<ActivityRecord> mActivities;

}

final class ActivityStack {

    /**

     * The back history of all previous (and possibly still
     * running) activities.  It contains #TaskRecord objects.
     */
    private ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();
}

通常情况下,一个App对应一个ActivityStack,ActivityStatck中会有一个TaskRecord列表,通常列表中仅有一个TaskRecord,维护Activity栈。

一个Activity启动时,归属的TaskRecord,通常是启动它的Activity 对应的TaskRecord。

如ActivtiyA启动ActivityB,那么ActivityB会被保存在ActivityA所属的TaskRecord中。

当一个Activity的launchmode 设置了SingleIntance,那么它启动的时候就会新建一个TaskRecord,这时ActvityStack中就会存在多个TaskRecord 栈结构。

taskAffinity 可以指定Activity需要宿主TaskRecord的名字,当ActivityManagerService发现启动了一个带有 FLAG_ACTIVITY_NEW_TASK 标签的 Activity 时,会先去查找当前AMS中是否存在activity需要的ActivityStack和TaskRecord，如果存在则直接将ActivityRecord添加到对应ActivityStack的TaskRecord中去,否则会先新建一个TaskRecord,然后将ActvityRecord添加到新建的TaskRecord中。

ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)

Display #0 (activities from top to bottom):

  Stack #1:

      TaskRecord{4212758 #173 A=com.sogou.iot.testtouch1 U=0 StackId=1 sz=2}

      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.sogou.iot.testtouch1/.MainActivity }

        Hist #1: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

          Intent { cmp=com.sogou.iot.testtouch1/.SecondActivity }

          ProcessRecord{3fd8bbc 23189:com.sogou.iot.testtouch1/u0a79}

        Hist #0: ActivityRecord{93a3d53 u0 com.sogou.iot.testtouch1/.MainActivity t173}

          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.sogou.iot.testtouch1/.MainActivity bnds=[433,77][644,372] }

          ProcessRecord{3fd8bbc 23189:com.sogou.iot.testtouch1/u0a79}

    Running activities (most recent first):

      TaskRecord{4212758 #173 A=com.sogou.iot.testtouch1 U=0 StackId=1 sz=2}

        Run #1: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

        Run #0: ActivityRecord{93a3d53 u0 com.sogou.iot.testtouch1/.MainActivity t173}

    mResumedActivity: ActivityRecord{4c91dda u0 com.sogou.iot.testtouch1/.SecondActivity t173}

  Stack #0:

      TaskRecord{db2272c #1 A=com.huawei.android.launcher U=0 StackId=0 sz=1}

      Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000300 cmp=com.huawei.android.launcher/.unihome.UniHomeLauncher }

        Hist #0: ActivityRecord{60dec4e u0 com.huawei.android.launcher/.unihome.UniHomeLauncher t1}

          Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000300 cmp=com.huawei.android.launcher/.unihome.UniHomeLauncher }

          ProcessRecord{c03fa2 1781:com.huawei.android.launcher/u0a50}

    Running activities (most recent first):

      TaskRecord{db2272c #1 A=com.huawei.android.launcher U=0 StackId=0 sz=1}

        Run #0: ActivityRecord{60dec4e u0 com.huawei.android.launcher/.unihome.UniHomeLauncher t1}

 private class ApplicationThread extends IApplicationThread.Stub{

 }

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options){

     if (mResumedActivity != null) {

            if (DEBUG_STATES) Slog.d(TAG_STATES,

                    "resumeTopActivityLocked: Pausing " + mResumedActivity);

            pausing |= startPausingLocked(userLeaving, false, next, false);

        }

}

 if (prev.app != null && prev.app.thread != null) {

    mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,

    PauseActivityItem.obtain(prev.finishing, userLeaving,

                                prev.configChangeFlags, pauseImmediately)

                                );

}

public class PauseActivityItem extends ActivityLifecycleItem {

    private static final String TAG = "PauseActivityItem";

    private boolean mFinished;

    private boolean mUserLeaving;

    private int mConfigChanges;

    private boolean mDontReport;

    @Override

    public void execute(ClientTransactionHandler client, IBinder token,

        client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,

                "PAUSE_ACTIVITY_ITEM");

    }

}

public abstract class ActivityLifecycleItem extends ClientTransactionItem {

    @Retention(RetentionPolicy.SOURCE)

    public @interface LifecycleState{}

    public static final int UNDEFINED = -1;

    public static final int PRE_ON_CREATE = 0;

    public static final int ON_CREATE = 1;

    public static final int ON_START = 2;

    public static final int ON_RESUME = 3;

    public static final int ON_PAUSE = 4;

    public static final int ON_STOP = 5;

    public static final int ON_DESTROY = 6;

    public static final int ON_RESTART = 7;

}

public class ClientTransaction implements Parcelable, ObjectPoolItem {

       /** Target client. */

    private IApplicationThread mClient;

}

 public void schedule() throws RemoteException {

        mClient.scheduleTransaction(this);

    }

public abstract class ClientTransactionHandler {

    // Schedule phase related logic and handlers.

    /** Prepare and schedule transaction for execution. */

    void scheduleTransaction(ClientTransaction transaction) {

        transaction.preExecute(this);

        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);

    }

 public void handleMessage(Message msg) {

  case EXECUTE_TRANSACTION:

                    final ClientTransaction transaction = (ClientTransaction) msg.obj;

                    mTransactionExecutor.execute(transaction);

                    break;

    }

    public class TransactionExecutor {

     public void execute(ClientTransaction transaction) {

            executeCallbacks(transaction);

            executeLifecycleState(transaction);

        }

    private void executeLifecycleState(ClientTransaction transaction) {

        final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();

        lifecycleItem.execute(mTransactionHandler, token, mPendingActions);

        lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);

    }

}

 @Override

    public final void activityPaused(IBinder token) {

        final long origId = Binder.clearCallingIdentity();

        synchronized(this) {

            ActivityStack stack = ActivityRecord.getStackLocked(token);

            if (stack != null) {

                stack.activityPausedLocked(token, false);

            }

        }

        Binder.restoreCallingIdentity(origId);

    }

 final void activityPausedLocked(IBinder token, boolean timeout) {

   completePauseLocked(true /* resumeNext */, null /* resumingActivity */);

 }

void startSpecificActivityLocked(ActivityRecord r,

        boolean andResume, boolean checkConfig) {

     //注释一:根据进程名和uuid判断Activity所属的进程是否创建   

    // Is this activity's application already running?

    ProcessRecord app = mService.getProcessRecordLocked(r.processName,

            r.info.applicationInfo.uid, true);

    if (app != null && app.thread != null) {

        try {

            if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0

                    || !"android".equals(r.info.packageName)) {

                // Don't add this if it is a platform component that is marked

                // to run in multiple processes, because this is actually

                // part of the framework so doesn't make sense to track as a

                // separate apk in the process.

                app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,

                        mService.mProcessStats);

            }

            //注释二

            realStartActivityLocked(r, app, andResume, checkConfig);

            return;

        } catch (RemoteException e) {

            Slog.w(TAG, "Exception when starting activity "

                    + r.intent.getComponent().flattenToShortString(), e);

        }

        // If a dead object exception was thrown -- fall through to

        // restart the application.

    }

    //注释三 调用ActivityManagerService 启动activity所在进程

    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,

            "activity", r.intent.getComponent(), false, false, true);

}

  private final boolean attachApplicationLocked(IApplicationThread thread,

            int pid, int callingUid, long startSeq) {

                  // See if the top visible activity is waiting to run in this process...

        if (normalMode) {

            try {

                if (mStackSupervisor.attachApplicationLocked(app)) {

                    didSomething = true;

                }

            } catch (Exception e) {

                Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);

                badApp = true;

            }

        }

}

boolean attachApplicationLocked(ProcessRecord app){

   realStartActivityLocked(activity, app,top == activity /* andResume */, true /* checkConfig */)) {

}

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,

            boolean andResume, boolean checkConfig) throws RemoteException {

                // Create activity launch transaction.

                final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,

                        r.appToken);

                clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),

                        System.identityHashCode(r), r.info,

                        // TODO: Have this take the merged configuration instead of separate global

                        // and override configs.

                        mergedConfiguration.getGlobalConfiguration(),

                        mergedConfiguration.getOverrideConfiguration(), r.compat,

                        r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,

                        r.persistentState, results, newIntents, mService.isNextTransitionForward(),

                        profilerInfo));

                // Set desired final state.

                final ActivityLifecycleItem lifecycleItem;

                if (andResume) {

                    lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());

                } else {

                    lifecycleItem = PauseActivityItem.obtain();

                }

                clientTransaction.setLifecycleStateRequest(lifecycleItem);

                // Schedule transaction.

                mService.getLifecycleManager().scheduleTransaction(clientTransaction);

            }

 /**  Core implementation of activity launch. */

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {

    ActivityInfo aInfo = r.activityInfo;

    //（1）为Activity创建Context

    ContextImpl appContext = createBaseContextForActivity(r);

    Activity activity = null;

    //(2) 通过Instrumentation 创建Activity实例

    activity = mInstrumentation.newActivity( cl, component.getClassName(), r.intent);

        //获取Applciation实例 

    Application app = r.packageInfo.makeApplication(false, mInstrumentation);

    if (activity != null) {

        //(3)调用activity.attach()

        activity.attach(appContext, this, getInstrumentation(), r.token,

                r.ident, app, r.intent, r.activityInfo, title, r.parent,

                r.embeddedID, r.lastNonConfigurationInstances, config,

                r.referrer, r.voiceInteractor, window, r.configCallback);

        if (customIntent != null) {

            activity.mIntent = customIntent;

        }

        int theme = r.activityInfo.getThemeResource();

        if (theme != 0) {

            activity.setTheme(theme);

        }

        //(4) 调用Instrumentation.callActivityOnCreate() 触发Activity生命周期

        if (r.isPersistable()) {

            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);

        } else {

            mInstrumentation.callActivityOnCreate(activity, r.state);

        }

    return activity;

}