ActivityThread的main函數(shù)入口

frameworks/base/core/java/android/app/ActivityThread.java
主要操作：創(chuàng)建主線程Looper，創(chuàng)建application，啟動activity

public static void main(String[] args) {

    //各種初始化操作，省略
    
    
    //初始化主線程的Looper，一個線程只能有一個Looper
    Looper.prepareMainLooper();
    
    ActivityThread thread = new ActivityThread();
    /在這里會進(jìn)行創(chuàng)建Application的相關(guān)操作
    thread.attach(false, startSeq);
    
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    //在主線程開啟循環(huán)讀取消息隊列中的消息
    Looper.loop();
}

    
    
private void attach(boolean system, long startSeq) {
    sCurrentActivityThread = this;
    mSystemThread = system;
    if (!system) {
        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
                                                UserHandle.myUserId());
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        //跨進(jìn)程通訊，獲取AMS在APP進(jìn)程的代理
        final IActivityManager mgr = ActivityManager.getService();
        try {
            //調(diào)用attachApplication
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
        // 監(jiān)聽內(nèi)存限制
        BinderInternal.addGcWatcher(new Runnable() {
            @Override public void run() {
                if (!mSomeActivitiesChanged) {
                    return;
                }
                Runtime runtime = Runtime.getRuntime();
                long dalvikMax = runtime.maxMemory();
                long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
                //當(dāng)虛擬機(jī)已使用內(nèi)存超過最大內(nèi)存的四分之三時，ActivityTaskManager釋放一些Activity
                if (dalvikUsed > ((3*dalvikMax)/4)) {
                    mSomeActivitiesChanged = false;
                    try {
                        ActivityTaskManager.getService().releaseSomeActivities(mAppThread);
                    } catch (RemoteException e) {
                        throw e.rethrowFromSystemServer();
                    }
                }
            }
        });
    } else {
        ....
    }

    ViewRootImpl.ConfigChangedCallback configChangedCallback
            = (Configuration globalConfig) -> {
        synchronized (mResourcesManager) {
            ....
        }
    };
    //添加配置回調(diào)
    ViewRootImpl.addConfigCallback(configChangedCallback);
}

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

跨進(jìn)程通訊獲取ActivityManagerService

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

@UnsupportedAppUsage
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;
        }
    };

public final void attachApplication(IApplicationThread thread, long startSeq) {
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final int callingUid = Binder.getCallingUid();
        final long origId = Binder.clearCallingIdentity();
        //傳入進(jìn)程PID，UID
        attachApplicationLocked(thread, callingPid, callingUid, startSeq);
        Binder.restoreCallingIdentity(origId);
    }
}

private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
        int pid, int callingUid, long startSeq) {
    
    //ApplicationThread調(diào)用bindApplication，ApplicationThread是ActivityThread的內(nèi)部類
    thread.bindApplication(processName, appInfo, providerList,···);
    
    //啟動MainActivity，這里和Android 28之前不太一樣
    if (normalMode) {
        try {
            //ActivityTaskManager，這里也是通過binder機(jī)制
            didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
            badApp = true;
        }
    }
    //啟動Service
    if (!badApp) {
        try {
            didSomething |= mServices.attachApplicationLocked(app, processName);
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown starting services in " + app, e);
            badApp = true;
        }
    }
    ...
}

### 創(chuàng)建application

frameworks/base/core/java/android/app/ActivityThread.java#ApplicationThread

給ActivityThread的Handler發(fā)送bindApplication消息

public final void bindApplication(String processName, ApplicationInfo appInfo,
                ProviderInfoList providerList, 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, AutofillOptions autofillOptions,
                ContentCaptureOptions contentCaptureOptions, long[] disabledCompatChanges) {
    if (services != null) {
        ServiceManager.initServiceCache(services);
    }

    setCoreSettings(coreSettings);

    AppBindData data = new AppBindData();
    data.processName = processName;
    data.appInfo = appInfo;
    data.providers = providerList.getList();
    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.autofillOptions = autofillOptions;
    data.contentCaptureOptions = contentCaptureOptions;
    data.disabledCompatChanges = disabledCompatChanges;
    sendMessage(H.BIND_APPLICATION, data);
}

frameworks/base/core/java/android/app/ActivityThread.java#H

Handler接收到消息并處理BindApplication

public void handleMessage(Message msg) {
    switch (msg.what) {
        case BIND_APPLICATION:
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
            AppBindData data = (AppBindData)msg.obj;
            handleBindApplication(data);
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            break;
    }
    
}

各種初始化，創(chuàng)建application實例并調(diào)用application的onCreate

private void handleBindApplication(AppBindData data) {
    //在運(yùn)行時將當(dāng)前執(zhí)行線程注冊為敏感線程
    VMRuntime.registerSensitiveThread();
    ...
    //標(biāo)記進(jìn)程起始時間
    Process.setStartTimes(SystemClock.elapsedRealtime(), SystemClock.uptimeMillis());
    ...
    //設(shè)置進(jìn)程名字
    Process.setArgV0(data.processName);
    
    //設(shè)置一個標(biāo)記位，androidQ及以上版本一些不明確數(shù)組相關(guān)的類會拋出數(shù)組越界異常
    //例如[SparseArray的keyAt和setValueAt在Q之前的版本不會拋出異常](/https://blog.csdn.net/wzz18749670290/article/details/109352466)
    UtilConfig.setThrowExceptionForUpperArrayOutOfBounds(
                data.appInfo.targetSdkVersion >= Build.VERSION_CODES.Q);
    //androidP之前用BitmapFactory解碼Bitmap，會放大density。android P及以后，用ImageDecoder解碼Bitmap，會跳過upscale節(jié)約內(nèi)存
    ImageDecoder.sApiLevel = data.appInfo.targetSdkVersion;
    
    //重置系統(tǒng)時區(qū)
    TimeZone.setDefault(null);
    //斷點(diǎn)調(diào)試相關(guān)
    if (data.debugMode != ApplicationThreadConstants.DEBUG_OFF) {
        // XXX should have option to change the port.
        ...
    }
    ...
    //渲染調(diào)試相關(guān)
    boolean isAppDebuggable = (data.appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
    HardwareRenderer.setDebuggingEnabled(isAppDebuggable || Build.IS_DEBUGGABLE);
    HardwareRenderer.setPackageName(data.appInfo.packageName);
    
    //初始化HTTP代理
    final IBinder b = ServiceManager.getService(Context.CONNECTIVITY_SERVICE);
    if (b != null) {
        final IConnectivityManager service = IConnectivityManager.Stub.asInterface(b);
        try {
            Proxy.setHttpProxySystemProperty(service.getProxyForNetwork(null));
        } catch (RemoteException e) {
            throw e.rethrowFromSystemServer();
        }
    }
    //創(chuàng)建Instrumentation并初始化
    // Continue loading instrumentation.
    if (ii != null) {
        ApplicationInfo instrApp;
        try {
            instrApp = getPackageManager().getApplicationInfo(ii.packageName, 0,
                    UserHandle.myUserId());
        } catch (RemoteException e) {
            instrApp = null;
        }
        if (instrApp == null) {
            instrApp = new ApplicationInfo();
        }
        ii.copyTo(instrApp);
        instrApp.initForUser(UserHandle.myUserId());
        final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
                appContext.getClassLoader(), false, true, false);

        final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
                appContext.getOpPackageName());
        try {
            //通過ClassLoader創(chuàng)建Instrumentation
            final ClassLoader cl = instrContext.getClassLoader();
            mInstrumentation = (Instrumentation)
                cl.loadClass(data.instrumentationName.getClassName()).newInstance();
        } catch (Exception e) {
           ...
        }
        //初始化Instrumentation
        final ComponentName component = new ComponentName(ii.packageName, ii.name);
        mInstrumentation.init(this, instrContext, appContext, component,
                data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
    } else {
        mInstrumentation = new Instrumentation();
        mInstrumentation.basicInit(this);
    }
    
    ...
    
    

    Application app;
    try {
        //創(chuàng)建application，這里面會調(diào)用application的attachBaseContext，這里的info對應(yīng)的class是LoadedApk.java，最終也是通過classLoader創(chuàng)建Application
        app = data.info.makeApplication(data.restrictedBackupMode, null);
        ...
        if (!data.restrictedBackupMode) {
            if (!ArrayUtils.isEmpty(data.providers)) {
                //這里調(diào)用installProvider()->AppComponentFactory.instantiateProvider->
                //localProvider.attachInfo()->ContentProvider.onCreate();
                //看到這里就明白了為什么LeakCanary2.0不需要在Application中手動初始化
                installContentProviders(app, data.providers);
            }
        }
        
        //調(diào)用application的onCreate
        mInstrumentation.callApplicationOnCreate(app);
    }
    //預(yù)加載字體資源
    FontsContract.setApplicationContextForResources(appContext);
    ...
}

frameworks/base/core/java/android/app/LoadedApk.java
在mInstrumentation.newApplication之前，創(chuàng)建了App的Context，具體實現(xiàn)類是ContextImpl

然后創(chuàng)建App時傳入了該Context，即App持有該Context

創(chuàng)建App之后ContextImpl調(diào)用了setOuterContext(app)，使得該Context持有了App的引用。這也是為什么我們可以context.getApplicationContext()

public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {
    
    ...
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
    // The network security config needs to be aware of multiple
    // applications in the same process to handle discrepancies
    NetworkSecurityConfigProvider.handleNewApplication(appContext);
    //chuangji
    app = mActivityThread.mInstrumentation.newApplication(
            cl, appClass, appContext);
    appContext.setOuterContext(app);
    ...
        
}

frameworks/base/core/java/android/app/Instrumentation.java

public Application newApplication(ClassLoader cl, String className, Context context)
        throws InstantiationException, IllegalAccessException, 
        ClassNotFoundException {
    Application app = getFactory(context.getPackageName())
            .instantiateApplication(cl, className);
    //調(diào)用Application的attach    
    app.attach(context);
    return app;
}

public void callApplicationOnCreate(Application app) {
    //調(diào)用Application的onCreate   
    app.onCreate();
}

/**
 * 用于控制manifest元素實例化的接口。
 * 可以看出四大組件 application classLoader都是在這個類實例化的
 *
 * @see #instantiateApplication
 * @see #instantiateActivity
 * @see #instantiateClassLoader
 * @see #instantiateService
 * @see #instantiateReceiver
 * @see #instantiateProvider
 */
public class AppComponentFactory {
    //注意這里的Application是通過classLoader加載class創(chuàng)建的
    public @NonNull Application instantiateApplication(ClassLoader cl,String className){
        return (Application) cl.loadClass(className).newInstance();
    }
}

至此，Application創(chuàng)建完畢。

啟動APP的入口Activity

frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

 public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
        synchronized (mGlobalLockWithoutBoost) {
            try {
                return mRootWindowContainer.attachApplication(wpc);
            } finally {
                Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
            }
        }
    }

frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java

boolean attachApplication(WindowProcessController app) throws RemoteException {
    final String processName = app.mName;
    boolean didSomething = false;
    for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
        final DisplayContent display = getChildAt(displayNdx);
        final ActivityStack stack = display.getFocusedStack();
        if (stack == null) {
            continue;
        }

        mTmpRemoteException = null;
        mTmpBoolean = false; // Set to true if an activity was started.
        //RootWindowContainer::startActivityForAttachedApplicationIfNeeded
        final PooledFunction c = PooledLambda.obtainFunction(
                RootWindowContainer::startActivityForAttachedApplicationIfNeeded, this,
                PooledLambda.__(ActivityRecord.class), app, stack.topRunningActivity());
        stack.forAllActivities(c);
        c.recycle();
        if (mTmpRemoteException != null) {
            throw mTmpRemoteException;
        }
        didSomething |= mTmpBoolean;
    }
    if (!didSomething) {
        ensureActivitiesVisible(null, 0, false /* preserve_windows */);
    }
    return didSomething;
}

private boolean startActivityForAttachedApplicationIfNeeded(ActivityRecord r,
        WindowProcessController app, ActivityRecord top) {
    ...
    try {
        if (mStackSupervisor.realStartActivityLocked(r, app, top == r /*andResume*/,
                true /*checkConfig*/)) {
            mTmpBoolean = true;
        }
    } catch (RemoteException e) {
        return true;
    }
    return false;
}

frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java

boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
    boolean andResume, boolean checkConfig){
    ...
    // Create activity launch transaction.
    final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.appToken);
    // 通過ClientLifecycleManager執(zhí)行啟動activity的任務(wù)
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
    
    ...
            
}

frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
執(zhí)行啟動activity的事務(wù)，IApplicationThread.scheduleTransaction(this)-> ActivityThread.this.scheduleTransaction(transaction);

void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    //開始執(zhí)行
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();
    if (!(client instanceof Binder)) {
        transaction.recycle();
    }
}

frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java

private IApplicationThread mClient;
public void schedule() throws RemoteException {
    //調(diào)用ApplicationThread的scheduleTransaction
    mClient.scheduleTransaction(this);
}

frameworks/base/core/java/android/app/ActivityThread.java#ApplicationThread

public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

frameworks/base/core/java/android/app/ActivityThread.java

void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
     //給ActivityThread發(fā)送EXECUTE_TRANSACTION消息
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}


    
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case EXECUTE_TRANSACTION:
                final ClientTransaction transaction = (ClientTransaction) msg.obj;
                //TransactionExecutor執(zhí)行transaction
                mTransactionExecutor.execute(transaction);
                if (isSystem()) {
                    transaction.recycle();
                }
                break;
        }
    }

case EXECUTE_TRANSACTION:
    final ClientTransaction transaction = (ClientTransaction) msg.obj;
    mTransactionExecutor.execute(transaction);
    if (isSystem()) {
        transaction.recycle();
    }
    break;

frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java

public void execute(ClientTransaction transaction) {

    final IBinder token = transaction.getActivityToken();
    ...
    executeCallbacks(transaction);
    executeLifecycleState(transaction);
    mPendingActions.clear();
}

//循環(huán)遍歷執(zhí)行
public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    if (callbacks == null || callbacks.isEmpty()) {
        return;
    }
    final IBinder token = transaction.getActivityToken();
    ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
    final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
    final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState(): UNDEFINED;
    final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);

    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        final ClientTransactionItem item = callbacks.get(i);
        final int postExecutionState = item.getPostExecutionState();
        final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
                item.getPostExecutionState());
        if (closestPreExecutionState != UNDEFINED) {
            cycleToPath(r, closestPreExecutionState, transaction);
        }
        //ClientTransactionItem 執(zhí)行啟動activity的任務(wù)，具體實現(xiàn)在LaunchActivityItem中
        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
    }
}

frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java

這里的client就是ActivityThread（class ActivityThread extends ClientTransactionHandler）

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

frameworks/base/core/java/android/app/ActivityThread.java

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


/** 啟動activity的核心實現(xiàn) */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }
        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }
        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }
        //創(chuàng)建Activity的Context
        ContextImpl appContext = createBaseContextForActivity(r);
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
            
            //通過ClassLoader創(chuàng)建Activity實例
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
        }

        try {
            //獲取application，之前在bindApplication的時候已經(jīng)創(chuàng)建過了
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);

            if (activity != null) {
                //這里進(jìn)行了一些屬性的賦值，創(chuàng)建phoneWindow等操作
                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,
                        r.assistToken);
                ...
                //設(shè)置主題
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }
               
                //調(diào)用activity的onCreate
                if (r.isPersistable()) {
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                r.activity = activity;
            }
        } catch (Exception e) {
        }

        return activity;
    } 
}

至此，Activity創(chuàng)建完畢。