Activity启动流程(下)

创建线程从ActivityThread.main开始

public static void main(String[] args){
    ...
    Looper.prepareMainLooper(); 
    //初始化Looper
    ...
    ActivityThread thread = new ActivityThread();
    //实例化一个ActivityThread
    thread.attach(false);
    //这个方法最后就是为了发送出创建Application的消息
    ... 
    Looper.loop();
    //主线程进入无限循环状态，等待接收消息
}

然后 attach Application

public void attach(boolean system){
    ...
    final IActivityManager mgr = ActivityManagerNative.getDefault();  
    //获得IActivityManager实例，ActivityManager
    try {
        mgr.attachApplication(mAppThread);
    } catch (RemoteException ex) {
        throw ex.rethrowFromSystemServer();
    }
    ...
}

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);
    }
}

public void attachApplicationLocked(IApplicationThread app){
  ...
// Find the application record that is being attached
 thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
                        null, null, null, testMode,
                        mBinderTransactionTrackingEnabled, enableTrackAllocation,
                        isRestrictedBackupMode || !normalMode, app.persistent,
                        new Configuration(getGlobalConfiguration()), app.compat,
                        getCommonServicesLocked(app.isolated),
                        mCoreSettingsObserver.getCoreSettingsLocked(),
                        buildSerial, isAutofillCompatEnabled);
  ...
 // See if the top visible activity is waiting to run in this process...
   if (normalMode) {
        try {
           // 这里会去 launch activity
            if (mStackSupervisor.attachApplicationLocked(app)) {
                didSomething = true;
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
           badApp = true;
        }
   }
}

 // ApplicationThread
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<String, IBinder> services, 
    Bundle coreSettings){

    ...
    sendMessage(H.BIND_APPLICATION, data);
}

private void handleBindApplication(AppBindData data) {
    ...
    mInstrumentation = (Instrumentation)
        cl.loadClass(data.instrumentationName.getClassName())
        .newInstance();
    //通过反射初始化一个Instrumentation
    ...
    Application app = data.info.makeApplication(data.restrictedBackupMode, null);
    //通过LoadedApp命令创建Application实例
    mInitialApplication = app;
    ...
    mInstrumentation.callApplicationOnCreate(app);
    //让仪器调用Application的onCreate()方法
    ...
}

public Application makeApplication(boolean forceDefaultAppClass,
    Instrumentation instrumentation) {
    ...
    String appClass = mApplicationInfo.className;
    //Application的类名。明显是要用反射了。
    ...
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread
        , this);
    //留意下Context
    app = mActivityThread.mInstrumentation
        .newApplication( cl, appClass, appContext);
    //通过Instrumentation创建Application
    ...
}

static public Application newApplication(Class<?> clazz
    , Context context) throws InstantiationException
    , IllegalAccessException
    , ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
        //反射创建，简单粗暴
        app.attach(context);
        //关注下这里，Application被创建后第一个调用的方法。
        //目的是为了绑定Context。
        return app;
    }

在 Activity启动流程(上) 中，这一段过程是在40-41之间执行的，创建完 ApplicationThread 后，经过层层调用，生成 LaunchActivityItem 来发送 LAUNCH_ACTIVITY 消息

private void handleLaunchActivity(ActivityClientRecord r
 , Intent customIntent
 , String reason) {
 ...
 Activity a = performLaunchActivity(r, customIntent);
 ...
 if (a != null) {
     ...
     handleResumeActivity(r.token
     , false
     , r.isForward
     ,!r.activity.mFinished && !r.startsNotResumed
     , r.lastProcessedSeq, reason);
     //Activity创建成功就往onResume()走了！
     ...
 }
}

private Activity performLaunchActivity(ActivityClientRecord r
 , Intent customIntent) {
 ...
ContextImpl appContext = createBaseContextForActivity(r);
java.lang.ClassLoader cl = appContext.getClassLoader();
 activity = mInstrumentation.newActivity(
      cl, component.getClassName(), r.intent);
 //通过仪表来创建Activity
 ...
  Application app = r.packageInfo.makeApplication(false
  , mInstrumentation);
  //前面说过，是在获取Application
 ...
 activity.attach(appContext
     , this
     , getInstrumentation()
     , r.token
     ,.ident
     , app
     , r.intent
     , r.activityInfo
     , title
     , r.parent
     , r.embeddedID
     , r.lastNonConfigurationInstances
     , config
     ,r.referrer
     , r.voiceInteractor
     , window);
 ...
 if (r.isPersistable()) {
     mInstrumentation.callActivityOnCreate(
       activity, r.state, r.persistentState);
 } else {
     mInstrumentation.callActivityOnCreate(activity, r.state);
 }
 //根据是否可持久化选择onCreate()方法。
 ...
}

public Activity newActivity(ClassLoader cl, String className,
         Intent intent)
         throws InstantiationException
         , IllegalAccessException,
         ClassNotFoundException {
     return (Activity)cl.loadClass(className).newInstance();
     //反射实例化Activity而已
 }