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<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) {
            //...
            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<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @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<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @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.调用时序图