概述

本文主要分享Activity的啟動(dòng)流程，主要分析Application與Activity分別是如何被加載的，下面我們就通過(guò)閱讀源碼分析

Application的加載過(guò)程

這里需要從應(yīng)用入口ActivityThread開始分析，追溯到main方法，找到如下關(guān)鍵代碼：

public static void main(String[] args) {
    ...   
    ActivityThread thread = new ActivityThread();
    thread.attach(false, startSeq);
    ...
}

追溯到ActivityThread中的attach方法，找到如下關(guān)鍵代碼：

 private void attach(boolean system, long startSeq) {
    ...
    final IActivityManager mgr = ActivityManager.getService();
    try {
        mgr.attachApplication(mAppThread, startSeq);
    } catch (RemoteException ex) {
        throw ex.rethrowFromSystemServer();
    }
    ...
}

public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

private static final Singleton<IActivityManager> IActivityManagerSingleton =
    new Singleton<IActivityManager>() {
        @Override
        protected IActivityManager create() {
            final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
            final IActivityManager am = IActivityManager.Stub.asInterface(b);
            return am;
        }
    };

由上述代碼可知attach方法中進(jìn)行了跨進(jìn)程調(diào)用，而IActivityManager是系統(tǒng)進(jìn)程在本地的代理，而對(duì)應(yīng)的系統(tǒng)進(jìn)程為ActivityManagerService，追溯attachApplication方法：

 public final void attachApplication(IApplicationThread thread, long startSeq) {
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final int callingUid = Binder.getCallingUid();
        final long origId = Binder.clearCallingIdentity();
        attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        Binder.restoreCallingIdentity(origId);
    }
}

attachApplication方法又調(diào)用了attachApplicationLocked方法，注意方法中以下兩個(gè)關(guān)鍵點(diǎn)：

private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid, int callingUid, long startSeq) {
       ...       
            
      //關(guān)鍵點(diǎn)一：Application的初始化
       thread.bindApplication(processName, appInfo, providers,
                app.instr.mClass,
                profilerInfo, app.instr.mArguments,
                app.instr.mWatcher,
                app.instr.mUiAutomationConnection, testMode,
                mBinderTransactionTrackingEnabled, enableTrackAllocation,
                isRestrictedBackupMode || !normalMode, app.persistent,
                new Configuration(getGlobalConfiguration()), app.compat,
                getCommonServicesLocked(app.isolated),
                mCoreSettingsObserver.getCoreSettingsLocked(),
                buildSerial, isAutofillCompatEnabled);
                    
         //關(guān)鍵點(diǎn)二：Activity的初始化
         if (normalMode) {
        try {
            if (mStackSupervisor.attachApplicationLocked(app)) {
                didSomething = true;
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }           
   ...           
}

這里先分析關(guān)鍵點(diǎn)一，由于IApplicationThread在ActivityThread中實(shí)現(xiàn)，所以回歸到ActivityThread類，分析bindApplication方法：

 public final void bindApplication(String processName, ApplicationInfo appInfo,
                List<ProviderInfo> providers, ComponentName instrumentationName,
                ProfilerInfo profilerInfo, Bundle instrumentationArgs,
                IInstrumentationWatcher instrumentationWatcher,
                IUiAutomationConnection instrumentationUiConnection, int debugMode,
                boolean enableBinderTracking, boolean trackAllocation,
                boolean isRestrictedBackupMode, boolean persistent, Configuration config,
                CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
                String buildSerial, boolean autofillCompatibilityEnabled) {
            ...  
            AppBindData data = new AppBindData();
            data.processName = processName;
            data.appInfo = appInfo;
            data.providers = providers;
            data.instrumentationName = instrumentationName;
            data.instrumentationArgs = instrumentationArgs;
            data.instrumentationWatcher = instrumentationWatcher;
            data.instrumentationUiAutomationConnection = instrumentationUiConnection;
            data.debugMode = debugMode;
            data.enableBinderTracking = enableBinderTracking;
            data.trackAllocation = trackAllocation;
            data.restrictedBackupMode = isRestrictedBackupMode;
            data.persistent = persistent;
            data.config = config;
            data.compatInfo = compatInfo;
            data.initProfilerInfo = profilerInfo;
            data.buildSerial = buildSerial;
            data.autofillCompatibilityEnabled = autofillCompatibilityEnabled;
            //關(guān)鍵點(diǎn)：通過(guò)處理HandlerH.BIND_APPLICATION類型消息  
            sendMessage(H.BIND_APPLICATION, data);
        }

有源碼可知，bindApplication通過(guò)Handler發(fā)生Application綁定消息并進(jìn)行處理，處理的方法為handleBindApplication，關(guān)鍵代碼如下：

 private void handleBindApplication(AppBindData data) {
    ...
     try {
        mInstrumentation.onCreate(data.instrumentationArgs);
    }catch (Exception e) {
        throw new RuntimeException(
            "Exception thrown in onCreate() of "
            + data.instrumentationName + ": " + e.toString(), e);
    }
    try {
        mInstrumentation.callApplicationOnCreate(app);
    } catch (Exception e) {
        if (!mInstrumentation.onException(app, e)) {
            throw new RuntimeException(
              "Unable to create application " + app.getClass().getName()
              + ": " + e.toString(), e);
        }
    }
    ...
 }

public void callApplicationOnCreate(Application app) {
    app.onCreate();
}

由源碼可知Application的初始化是通過(guò)調(diào)用Instrumentation類中的callApplicationOnCreate方法進(jìn)而調(diào)用了app.onCreate()完成初始化工作，到這里Application的加載過(guò)程就分析完了

Activity的加載過(guò)程

這里緊接著上面attachApplicationLocked方法中的關(guān)鍵點(diǎn)二繼續(xù)分析，進(jìn)入ActivityStackSupervisor類的attachApplicationLocked方法：

 boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
 ...
   for (int i = 0; i < size; i++) {
        final ActivityRecord activity = mTmpActivityList.get(i);
        if (activity.app == null && app.uid == activity.info.applicationInfo.uid
                && processName.equals(activity.processName)) {
            try {
                if (realStartActivityLocked(activity, app,
                        top == activity /* andResume */, true /* checkConfig */)) {
                    didSomething = true;
                }
            } catch (RemoteException e) {
                Slog.w(TAG, "Exception in new application when starting activity "
                        + top.intent.getComponent().flattenToShortString(), e);
                throw e;
            }
        }
    }
  }
 ...
 }

attachApplicationLocked方法又調(diào)用了realStartActivityLocked方法，關(guān)鍵代碼如下：

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
            boolean andResume, boolean checkConfig) throws RemoteException {
            
 ...
 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);
     ...
 }

追溯到ClientLifecycleManager類中的scheduleTransaction方法：

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();
    if (!(client instanceof Binder)) {
        // If client is not an instance of Binder - it's a remote call and at this point it is
        // safe to recycle the object. All objects used for local calls will be recycled after
        // the transaction is executed on client in ActivityThread.
        transaction.recycle();
    }
}

繼續(xù)追溯到ClientTransaction類中的schedule方法：

public void schedule() throws RemoteException {
    mClient.scheduleTransaction(this);
}

由源碼可知，chedule()又調(diào)用了IApplicationThread的scheduleTransaction方法，這里回到ActivityThread繼續(xù)分析：

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

由上述源碼可知，方法內(nèi)發(fā)送了EXECUTE_TRANSACTION類型消息，而對(duì)于的處理是在TransactionExecutor類中的execute方法：

 public void execute(ClientTransaction transaction) {
     
        executeCallbacks(transaction);

        executeLifecycleState(transaction);
 }

execute方法中分別調(diào)用了executeCallbacks和executeLifecycleState，這里先分析executeCallbacks方法：

public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i);
        log("Resolving callback: " + item);
        final int postExecutionState = item.getPostExecutionState();
        final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                item.getPostExecutionState());
        if (closestPreExecutionState != UNDEFINED) {
            cycleToPath(r, closestPreExecutionState);
        }

        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
        ...      
    }
}

方法的內(nèi)部實(shí)現(xiàn)是遍歷List<ClientTransactionItem>中的元素并逐個(gè)執(zhí)行execute方法，而通過(guò)上面分析可知getCallbacks()中添加的元素為ActivityLifecycleItem，進(jìn)入exexute方法：

 public void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
    Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
    ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
            mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
            mPendingResults, mPendingNewIntents, mIsForward,
            mProfilerInfo, client);
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}

通過(guò)方法實(shí)現(xiàn)可知，方法內(nèi)部調(diào)用了IApplicationThread的handleLaunchActivity方法，這里再次回到ActivityThread進(jìn)行分析：

public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
                
    final Activity a = performLaunchActivity(r, customIntent);
     return a;
}

進(jìn)入performLaunchActivity方法，閱讀以下關(guān)鍵代碼：

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            if (!mInstrumentation.onException(activity, e)) {
                throw new RuntimeException(
                    "Unable to instantiate activity " + component
                    + ": " + e.toString(), e);
            }
        }
        
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
        
         return activity;
}

public void callActivityOnCreate(Activity activity, Bundle icicle,
            PersistableBundle persistentState) {
        prePerformCreate(activity);
        activity.performCreate(icicle, persistentState);
        postPerformCreate(activity);
    }

 final void performCreate(Bundle icicle, PersistableBundle persistentState) {
        mCanEnterPictureInPicture = true;
        restoreHasCurrentPermissionRequest(icicle);
        if (persistentState != null) {
            onCreate(icicle, persistentState);
        } else {
            onCreate(icicle);
        }
        writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
        mActivityTransitionState.readState(icicle);

        mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
                com.android.internal.R.styleable.Window_windowNoDisplay, false);
        mFragments.dispatchActivityCreated();
        mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
    }

通過(guò)上面的關(guān)鍵代碼可知，Activity是通過(guò)反射進(jìn)行創(chuàng)建的，創(chuàng)建完成后再通過(guò)Instrumentation類調(diào)用自身的onCreate方法完成初始化，到這里Activity的加載流程就分析完了，通過(guò)分析我們可以看到這個(gè)過(guò)程中涉及到的類非常多，但是閱讀源碼本身就是一件繁瑣的事，只要抓住主干，一步步去分析，就會(huì)慢慢明白了。