Android源码解析:Application的onCreate()方法是如何被调用的

1.一个程序的入口是main方法,而当我们接触安卓的时候都是Activity的各种生命周期方法,那main在哪里调用呢?就是ActivityThread中,该类也代表应用程序的主进程.

ActivityThread 
    -> main()
    public static void main(String[] args) {
        //... 1.开启Looper
        Looper.prepareMainLooper();

        //2.实例化ActivityThread,并调用attach()方法
        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }
        //...
        Looper.loop();
    }

    ->attach(false)方法
    private void attach(boolean system) {
        if (!system) {
            //...
            //1.内部调用者的是AMS,将ApplicationThread对象与AMS联系起来,ApplicationThread作为AMS的代理类
            //调用AMS的attachApplication()方法,最后还是调用到ApplicationThread的bindApplication()方法
            final IActivityManager mgr = ActivityManager.getService();
            try {
                mgr.attachApplication(mAppThread); //
            } catch (RemoteException ex) {
                throw ex.rethrowFromSystemServer();
            }
            // ...
        }else{
             // ...
        }

    ApplicationThread.bindApplication()方法
        public final void bindApplication(String processName, ApplicationInfo appInfo,
                List 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) {
            //...
            AppBindData data = new AppBindData();
            //...1.数据封装为AppBindData,然后发送通知
            sendMessage(H.BIND_APPLICATION, data);
        }

    H接收到消息,然后进行处理,最后会调用ActivityThread的handleBindApplication()
    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;

解析:
a.找到应用程序的入口类ActivityThread和他的入口方法mian()
b.main()方法主要核心做两件事:开启Looper轮训和实例化ActivityThread对象,并调用attach()方法
c.我们主要研究的就是attach方法,该方法主要做一件事就是Binder通信,最终调用AMS的attachApplication()并将ApplicationThread作为参数传入.
d.最后通过代理模式调用ApplicationThread.bindApplication()方法

2.ActivityManager.getService()

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

    private static final Singleton IActivityManagerSingleton =
            new Singleton() {
                @Override
                protected IActivityManager create() {
                    //1.Binder通信
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE); 
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };    public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

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

3.handleBindApplication()

    private void handleBindApplication(AppBindData data) {
        // 将UI线程注册为运行时的敏感线程。
        VMRuntime.registerSensitiveThread();
         //...

        //1.创建上下文
        final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
        updateLocaleListFromAppContext(appContext,
                mResourcesManager.getConfiguration().getLocales());
        //...
        // Continue loading instrumentation.
        if (ii != null) {
            final ApplicationInfo 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);

            try {
                //2.反射创建Instrumentation实例
                final ClassLoader cl = instrContext.getClassLoader();
                mInstrumentation = (Instrumentation)
                    cl.loadClass(data.instrumentationName.getClassName()).newInstance();
            } catch (Exception e) {
            }

            //3.new出组件名称
            final ComponentName component = new ComponentName(ii.packageName, ii.name);
            mInstrumentation.init(this, instrContext, appContext, component,
                    data.instrumentationWatcher, data.instrumentationUiAutomationConnection);

            if (mProfiler.profileFile != null && !ii.handleProfiling
                    && mProfiler.profileFd == null) {
                mProfiler.handlingProfiling = true;
                final File file = new File(mProfiler.profileFile);
                file.getParentFile().mkdirs();
                Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);
            }
        } else {
            mInstrumentation = new Instrumentation();
        }
        //...
        final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
        try {
            //4.最后也是通过Instrumentation类,发射出ApplicationThread实例
            Application app = data.info.makeApplication(data.restrictedBackupMode, null);
            mInitialApplication = app;
            // ...
            try {
                mInstrumentation.onCreate(data.instrumentationArgs);
            }
            try {
                //5.调用Application的onCreate()方法
                mInstrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
                if (!mInstrumentation.onException(app, e)) {
                    throw new RuntimeException(
                        "Unable to create application " + app.getClass().getName()
                        + ": " + e.toString(), e);
                }
            }
        } finally {
            StrictMode.setThreadPolicy(savedPolicy);
        }
        //...
    }

解析:
a.通过Handle机制发送消息BIND_APPLICATION,最后调用handleBindApplication(),该方法主要就是创建Application实例并调用其onCreate()方法
b.创建Application的上下文ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
c.反射创建Instrumentation实例 (Instrumentation)cl.loadClass(data.instrumentationName.getClassName()).newInstance();
d.调用LoadApk最后也是Instrumentation反射创建Application实例对象
e.最后调用Application的onCreate()方法:mInstrumentation.callApplicationOnCreate(app);

4.调用时序图