ActivityThread相关源码分析

前言

先看ActivityThread相关类图

 

分析核心的类：ActivityThread

各个关键类简介：

      1、ActivityThread（进程内唯一）：负责进程下Application、所有Activity

      2、Instrumentation（进程内唯一）：作为ActivityThread组合部分，负责统一创建Application，创建Activity，管理某一个Activity生命周期。

      3、ApplicationThread（进程内唯一）：作为ActivityThread组合部分，管理整个App的生命周期，例如：通知App进入sleep状态，广播接收，应用退出等一堆App事件的分发。

      4、H（进程内唯一）：作为ActivityThread组合部分，继承于Handler，分发App内部Framework层的所有事件，将异步事件转入主线程。

      5、LoadedApk（进程内唯一）：常用变量名称：packageInfo。所以顾名思义，该类表示包相关的信息，例如：APK数据文件地址、ApplicationInfo（由此可知，LoadedApk含有Application的所有信息）

      6、ActivityClientRecord：新建Activity时会创建，用来持有Activity、ActivityInfo、LoadedApk等和具体Activity有关的信息

      7、ActivityManagerService：管理Activity、Service等活动栈、记录及与C++层交互

      8、ActivityStarter：主要负责Activity的启动，及联系Activity的Stack和Task相关

启动ActivityThread

1）启动入口

      看源码，我们可以发现，ActivityThread的构造器被两个静态方法使用，一个是ActivityThread的main方法，一个是ActivityThread的systemMain方法。

      先看systemMain方法，其由SystemServer的createSystemContext方法调用，同时该方法又被SystemServer的run方法调用。从Android启动源码那篇博客可以知道，run方法为System进程Java端的初始化过程。所以可以看出该方法是专门为SystemServer创建ActivityThread使用的。

      相对的，那么ActivityThread的main方法为普通App进程的启动方式。

2）下面进入main@ActivityThread

public static void main(String[] args) {
    // 初始化Environment
    Environment.initForCurrentUser();
    // 初始化Event日志
    EventLogger.setReporter(new EventLoggingReporter());
    // 根据用户Id创建指定目录
    final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
    // 将当前线程作为主线程，初始化Looper
    Looper.prepareMainLooper();
    // 创建ActivityThread
    ActivityThread thread = new ActivityThread();
    // 如果是System则直接创建Application，如果非System则将ApplicationThread注册到AM中
    thread.attach(false);
    // 初始化Handler
    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }
    // 无限循环中
    Looper.loop();
    // 异常终止，注意这里的异常通常是执行不到的，上方loop有异常也不会执行到这里。
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

      ActivityThread 构造器仅仅new ResourcesManager()；ResourceManager，顾名思义，是我们获取资源的管理类，DisplayMetrics和AssetManager也都是其负责的。

      main方法进入循环前只执行了一个方法：thread.attach(false);而后进入循环，说明了在该方法里面，集合了整个应用进程的生命周期。

3）开启应用App创建，查看thread.attach(false);

private void attach(boolean system) {
    sCurrentActivityThread = this;
    mSystemThread = system;
    if (!system) { // 进入应用创建
        ViewRootImpl.addFirstDrawHandler(new Runnable() {
            @Override
            public void run() {
                ensureJitEnabled();
            }
        });
        android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
        UserHandle.myUserId());
        RuntimeInit.setApplicationObject(mAppThread.asBinder());
        // 创建应用Application
        final IActivityManager mgr = ActivityManagerNative.getDefault();
        try {   
            mgr.attachApplication(mAppThread);
        } catch (RemoteException ex) {
            throw ex.rethrowFromSystemServer();
        }
        ...
    } else { // 进入SystemServer创建
        ...
        try {
            // 创建Activity生命周期管理类
            mInstrumentation = new Instrumentation();
            // 创建系统级别的上下文
            ContextImpl context = ContextImpl.createAppContext(
                this, getSystemContext().mPackageInfo);
            // 创建Application，并启动onCreate方法
            mInitialApplication = context.mPackageInfo.makeApplication(true, null);
            mInitialApplication.onCreate();
        } catch (Exception e) {
            throw new RuntimeException("Unable to instantiate Application():" + e.toString(), e);
        }
    }
    // 记录着系统关键log信息，主要功能用于Debug调试
    DropBox.setReporter(new DropBoxReporter());
    // 注册到ViewRootImpl中，监听组件配置信息变化监听
    ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
        ...
    });
}

创建System的Application代码比较明显，但是创建应用Application链路比较长，我们将这里分析下：

attach()中进入应用Application的入口：

final IActivityManager mgr = ActivityManagerNative.getDefault();
try {
    mgr.attachApplication(mAppThread);
} catch (RemoteException ex) {
    throw ex.rethrowFromSystemServer();
}

mgr在这里就是ActivityManagerProxy（可以看gDefault这个单例，里面先找到AMS，再利用AMS创建了ActivityManagerProxy），看ActivityManagerProxy里面的attachApplication，这里面执行了：

mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);

mRemote为创建ActivityManagerProxy时传入的IBinder，也就是AMS。这里执行的就是跨进程了。

通过ATTACH_APPLICATION_TRANSACTION可以确定，处理的代码在AMS的父类ActivityManagerNative中onTransact，

case ATTACH_APPLICATION_TRANSACTION: {
    data.enforceInterface(IActivityManager.descriptor);
    IApplicationThread app = ApplicationThreadNative.asInterface(
        data.readStrongBinder());
    if (app != null) {
        attachApplication(app);
    }
    reply.writeNoException();
    return true;
}

4）下一步执行attachApplication(app);这里执行的代码不再是ActivityManagerProxy，而是在AMS中：

@Override
public final void attachApplication(IApplicationThread thread) {
    synchronized (this) {
        int callingPid = Binder.getCallingPid();
        final long origId = Binder.clearCallingIdentity();
        attachApplicationLocked(thread, callingPid);
        Binder.restoreCallingIdentity(origId);
    }
}

private final boolean attachApplicationLocked(IApplicationThread thread,int pid) {
    ...
    try {
        ...
        // 绑定Application
        thread.bindApplication(processName, appInfo, providers, app.instrumentationClass,profilerInfo, app.instrumentationArguments, app.instrumentationWatcher,app.instrumentationUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(mConfiguration), app.compat,
getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked());
        ...

    } catch (Exception e) {
        ...
    }
    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;
        }
    }
    ...
    return true;
}

看源码，可以发现，创建Application，下一步应该是在这个传入的IApplicationThread的bindApplication方法中执行，从之前的代码中我们可以看到，ActivityThread传入了

mgr.attachApplication(mAppThread);

mAppThread为ApplicationThread，所以，AMS中执行的thread为ApplicationThread的Binder，最终代码我们看ApplicationThread的bindApplication方法。

创建Application

1）查看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<String, IBinder> services, Bundle coreSettings) {
    ...
    sendMessage(H.BIND_APPLICATION, data);
}

ApplicationThread为ActivityThread的内部类，这里刚好有这么一个方法，同时参数都对应的上，说明我们之前确实没有找错对象。可以看到该方法最终又找到了H这个Handler，进而在主线程中执行了ActivityThread的handleBindApplication();

2）看handleBindApplication：

private void handleBindApplication(AppBindData data) {
    ...
    try {
        ...
        Application app = data.info.makeApplication(data.restrictedBackupMode, null);
        mInitialApplication = app;
        ...
        try {
            // 该方法为空，应该是预留方法
            mInstrumentation.onCreate(data.instrumentationArgs);
        } catch (Exception e) {
            ...
        }
        try {
            // 开启Application的onCreate方法
            mInstrumentation.callApplicationOnCreate(app);
        } catch (Exception e) {
            ...
        }
        ...
    } finally {
        StrictMode.setThreadPolicy(savedPolicy);
    }
}

到了这里我们的Application已经启动了。

启动Launch Activity

下面分析Activity启动，这里要回到ActivityThread启动的第4步，执行：

1）第一步：m.attachApplicationLocked(app)；

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    ...
    for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
        ...
        try {
            if (realStartActivityLocked(hr, app, true, true)) {
                didSomething = true;
            }
        } catch (RemoteException e) {
            ...
            throw e;
        }
        ...
    }
    ...
    return didSomething;
}

2）第二步：StackSupervisor的realStartActivityLocked方法

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
    ...
    app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,
        System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),
    new Configuration(task.mOverrideConfig), r.compat, r.launchedFromPackage,
    task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results,
    newIntents, !andResume, mService.isNextTransitionForward(), profilerInfo);
    ...
}

通之前的Application一样，这里的thread为ApplicationThread

3）第三步：ApplicationThread的scheduleLaunchActivity

@Override
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
    ...
    sendMessage(H.LAUNCH_ACTIVITY, r);
}

4）第四步：ActivityThread的handleLaunchActivity

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
    ...
    // 初始化窗体
    WindowManagerGlobal.initialize();
    // 启动Launch Acitivity
    Activity a = performLaunchActivity(r, customIntent);
    if(a != null){
        ...
        // 将Activity状态置为Resume状态
        handleResumeActivity(r.token, false, r.isForward,
        !r.activity.mFinished && !r.startsNotResumed, r.lastProcessedSeq, reason);
        ...
    }
    ...
}

5）第五步：ActivityThread的performLaunchActivity

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ...
    Activity activity = null;
    try {
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        // 创建Actiivty实体类
        activity = mInstrumentation.newActivity(
        cl, component.getClassName(), r.intent);
        ...
    } catch (Exception e) {
        ...
    }
    try {
        // 如果packageinfo中没有Application，则创建新的Application，并onCreate()，否则直接返回
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        if (activity != null) {
            // 绑定上下文，Window设置
            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);
            // Activity onCreate方法
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            // 执行 onStart()方法
            if (!r.activity.mFinished) {
                activity.performStart();
                r.stopped = false;
            }
            // 执行状态恢复生命周期
            if (!r.activity.mFinished) {
                if (r.isPersistable()) {
                    if (r.state != null || r.persistentState != null) {
                        mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
r.persistentState);
                    }
                } else if (r.state != null) {
                    mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
            }
        }
        ...
    }
    r.paused = true;
    mActivities.put(r.token, r);
    } catch (SuperNotCalledException e) {
        ...
    }
    return activity;
}

代码执行完performLaunchActivity，Launch Activity已经进入了onStart。而后回到第四步，进入handleResumeActivity，使Activity进入Resume状态。

至此，我们的Launch Activity已经完成启动，ActivityThread在这之中扮演的角色也比较清晰了。