Android 启动源码分析-Application的创建

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第11天，点击查看活动详情

ActivityThread类

ActivityThread的作用：

管理应用程序进程中主线程的执行，调度和执行活动，广播以及活动管理请求的其他操作

ActivityThread是应用的主线程，从main函数开始执行

public static void main(String[] args) {
    //将主线程设置为Looper线程，开始loop，用与处理H消息
    Looper.prepareMainLooper();
    //创建ActivityThread实例对象
    ActivityThread thread = new ActivityThread();
    //绑定
    thread.attach(false, startSeq);
    //开始无限循环，处理handler消息
    Looper.loop();
}

进入ActivityThread的绑定方法 attach

private void attach(boolean system, long startSeq) {
    sCurrentActivityThread = this;
    mSystemThread = system;
    if (!system) {
        ViewRootImpl.addFirstDrawHandler(new Runnable() {
            @Override
            public void run() {
                ensureJitEnabled();
            }
        });
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        //通过binder 机制获取AMS
        final IActivityManager mgr = ActivityManager.getService();
        try {
           //为ActivityThread绑定ApplicationThread
            mgr.attachApplication(mAppThread, startSeq);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
     
}

attach方法主要是通过binder机制获取AMS，并调用attachApplication方法，为ActivityThread绑定ApplicationThread

AMS（ActivityManagerService）中attachApplication方法

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

进入ActivityManagerService类中的attachApplicationLocked方法

// 为 ApplicationThread 绑定 Application 主方法
private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid) {
    try {
        checkTime(startTime, "attachApplicationLocked: immediately before bindApplication");
        mStackSupervisor.mActivityMetricsLogger.notifyBindApplication(app);
		// 在此处为 ActivityThread 绑定 Application , 此时又回到 ActivityThread
        if (app.instr != null) {
            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);
        } else {
            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);
        }
    } catch (Exception e) {
    }

    return true;
}

attachApplicationLocked方法中有调用ActivityThread的bindApplication方法，为ActivityThread绑定ApplicationThread

进入ActivityThread中的内部类ApplicationThread

    private class ApplicationThread extends IApplicationThread.Stub {
		// 为 ActivityThread 绑定 Application 
        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) {

            // 此处在所有数据就位后 , 发送了一个 H.BIND_APPLICATION 消息
            sendMessage(H.BIND_APPLICATION, data);
        }
	}

调用 ApplicationThread 类的 bindApplication方法 , 即可为 ActivityThread 绑定 ApplicationThread , 在所有数据就位后 , 发送了一个 H.BIND_APPLICATION 消息 ;

ActivityThread.H 处理BIND_APPLICATION消息

case BIND_APPLICATION:
 
    AppBindData data = (AppBindData)msg.obj;
    //处理绑定Application相关逻辑
    handleBindApplication(data);
    break;

//跳出之后还需要执行的方法
Object obj = msg.obj;
if (obj instanceof SomeArgs) {
    ((SomeArgs) obj).recycle();
}

进入ActivityThread的handleBindApplication方法

private void handleBindApplication(AppBindData data) {
    // 将UI线程注册为运行时的敏感线程
    VMRuntime.registerSensitiveThread();
    if (data.trackAllocation) {
        DdmVmInternal.enableRecentAllocations(true);
    }

    // 记录进程开始时间
    Process.setStartTimes(SystemClock.elapsedRealtime(), SystemClock.uptimeMillis());

    Application app;
    final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
    final StrictMode.ThreadPolicy writesAllowedPolicy = StrictMode.getThreadPolicy();
    try {
     //如果要启动应用程序进行完全备份或恢复，请使用基本应用程序类在受限环境中启动
     app = data.info.makeApplication(data.restrictedBackupMode, null);
  app.setAutofillCompatibilityEnabled(data.autofillCompatibilityEnabled);
        mInitialApplication = app;
    } ...
}

调用 data.info.makeApplication(data.restrictedBackupMode, null) 方法 , 创建 Application 实例对象 ;

data.info 是 LoadedApk 类型

进入LoadedApk类中的makeApplication方法中

public Application makeApplication(boolean forceDefaultAppClass,
        Instrumentation instrumentation) {
        //如果存在application,直接返回
    if (mApplication != null) {
        return mApplication;
    }
    Application app = null;

    String appClass = mApplicationInfo.className;
    if (forceDefaultAppClass || (appClass == null)) {
        appClass = "android.app.Application";
    }

    try {
        java.lang.ClassLoader cl = getClassLoader();
        if (!mPackageName.equals("android")) {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
                    "initializeJavaContextClassLoader");
            initializeJavaContextClassLoader();
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        }
        ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
        //通过调用 Instrumentation 的 newApplication 方法 , 创建 Application 实例对象
        app = mActivityThread.mInstrumentation.newApplication(
                cl, appClass, appContext);
        appContext.setOuterContext(app);
    } catch (Exception e) {
        if (!mActivityThread.mInstrumentation.onException(app, e)) {
            throw new RuntimeException(
                "Unable to instantiate application " + appClass
                + ": " + e.toString(), e);
        }
    }
    mActivityThread.mAllApplications.add(app);
    mApplication = app;
    
    return app;
}

调用 LoadedApk 的 makeApplication 方法 , 创建 Application 实例 , 在该方法中通过调用 Instrumentation 的 newApplication 方法 , 创建 Application实例对象

进入Instrumentation类中的newApplication方法

//执行进程对象的实例化。默认实现提供正常的系统行为。
public Application newApplication(ClassLoader cl, String className, Context context)
        throws InstantiationException, IllegalAccessException, 
        ClassNotFoundException {
    Application app = getFactory(context.getPackageName())
            .instantiateApplication(cl, className);
    app.attach(context);
    return app;
}

进入AppComponentFactory类中instantiateApplication方法

 /**
    * 允许应用程序重写应用程序对象的创建。这可以用于对这些类执行依赖项注入或类装入器更改等操作。
    * <p>
    * 此方法仅用于提供用于实例化的挂钩。它不提供对应用程序对象的早期访问。
    * 返回的对象尚未初始化为上下文，不应用于与其他android API交互。
    *
    * @param cl        用于实例化的默认类加载器。
    * @param className 要实例化的类。
    */
public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,
        @NonNull String className)
        throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        //通过反射创建 Application 实例对象 
    return (Application) cl.loadClass(className).newInstance();
}