ActivityThread笔记1-优快云博客

本文链接：https://blog.youkuaiyun.com/LYRIC_315/article/details/52798236

APP入口

以前一直都说Activity的人口是onCreate方法。其实Android上一个应用的入口，应该是ActivityThread。和普通的Java类一样，入口是一个main方法。

public static final void main(String[] args) {
        SamplingProfilerIntegration.start();
       ……
        Looper.prepareMainLooper();
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
       ……
        Looper.loop();
       ……
        thread.detach();
        ……
        Slog.i(TAG, "Main thread of " + name + " is now exiting");
    }

ActivityThread（所在的线程）其实就是经常说的UI thread，也就是主线程。

ActivityThread 有几个比较重要的成员变量，会在创建ActivityThread对象时初始化。

（1）final ApplicationThread mAppThread = new ApplicationThread()

ApplicationThread继承自ApplicationThreadNative，而ApplicationThreadNative又继承自Binder并实现了IApplicationThread接口。IApplicationThread继承自IInterface。这是一个很明显的binder结构，用于于Ams通信。IApplicationThread接口定义了操作接口。ApplicationThread通过binder与Ams通信，并将Ams的调用，通过下面的H类（也就是Hnalder）将消息发送到消息队列，然后进行相应的操作，入activity的start， stop。
这里写图片描述
（2）final H mH = new H()

H继承了Handler类，mH负责处理ApplicationThread发送到消息队列的消息

例如：

ApplicationThread发送到消息

public final void schedulePauseActivity(IBinder token, boolean finished,
                boolean userLeaving, int configChanges, boolean dontReport) {
            sendMessage(
                    finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
                    token,
                    (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
                    configChanges);
}
public final void scheduleLaunchActivity(...){
    ...
}

mH处理消息

public void handleMessage(Message msg) {
            if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + msg.what);
            switch (msg.what) {
                case LAUNCH_ACTIVITY: 
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
                    final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
                    r.packageInfo = getPackageInfoNoCheck(
                            r.activityInfo.applicationInfo, r.compatInfo);
                    handleLaunchActivity(r, null);//这里就将进行启动activity的工作了
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
                case PAUSE_ACTIVITY:
                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
                    handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,(msg.arg1&2) != 0);
                    maybeSnapshot();
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    break;
             ｝
｝

创建activity，在handleLaunchActivity(r, null)将会调用

WindowManagerGlobal.initialize();//创建activity前初始化
Activity a = performLaunchActivity(r, customIntent);//创建activity

在performLaunchActivity()调用onCreate()方法，此外还会调用activity中的onStart()、onRestoreInstanceState()、onPostCreate()三个生命周期函数。

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        //ActivityClientRecord是activity的包装类，记录了activity所需要的各种信息
        //ActivityInfo获得应用程序中<activity/>或者 <receiver />节点的信息 
        ActivityInfo aInfo = r.activityInfo;
        if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                    Context.CONTEXT_INCLUDE_CODE);
        }
        //ComponentName组件信息：包名和类名
        ComponentName component = r.intent.getComponent();
        if (component == null) {
            component = r.intent.resolveActivity(
                mInitialApplication.getPackageManager());
            r.intent.setComponent(component);
        }

        if (r.activityInfo.targetActivity != null) {
            component = new ComponentName(r.activityInfo.packageName,
                    r.activityInfo.targetActivity);
        }

        Activity activity = null;
        try {
            //类加载器
            java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
            //创建新的Activity
            activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            StrictMode.incrementExpectedActivityCount(activity.getClass());
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
            }
        } catch (Exception e) {
            ...
        }

        try {
            Application app = r.packageInfo.makeApplication(false, mInstrumentation);
            ...
            if (activity != null) {
                Context appContext = createBaseContextForActivity(r, activity);
                CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
                Configuration config = new Configuration(mCompatConfiguration);
                ...
                if (customIntent != null) {
                    activity.mIntent = customIntent;
                }
                r.lastNonConfigurationInstances = null;
                activity.mStartedActivity = false;
                int theme = r.activityInfo.getThemeResource();
                if (theme != 0) {
                    activity.setTheme(theme);
                }
                //1、这里将会调用activity的oncreate()方法
                activity.mCalled = false;
                if (r.isPersistable()) {
                    //persistent模式，activity在oncreate中将会恢复被shut down之前的状态
                    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
                } else {
                    //正常调用oncreate
                    mInstrumentation.callActivityOnCreate(activity, r.state);
                }
                ...
                r.activity = activity;
                r.stopped = true;//初始化
                //2、oncreate()之后调用activity的onStart()方法
                if (!r.activity.mFinished) {
                    activity.performStart();
                    r.stopped = false;
                }
                if (!r.activity.mFinished) {
                    //调用activity的OnRestoreInstanceState
                    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);
                    }
                }
                if (!r.activity.mFinished) {
                    activity.mCalled = false;//初始化
                    //调用activity的生命周期onPostCreate
                    if (r.isPersistable()) {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state,
                                r.persistentState);
                    } else {
                        mInstrumentation.callActivityOnPostCreate(activity, r.state);
                    }
                    ...
                }
            }
            r.paused = true;

            mActivities.put(r.token, r);

        } catch ((Exception e) {
            ...
        }

        return activity;
    }

ApplicationThread与Ams之间的通信

在main方法中有这样一句代码thread.attach(false)，它将获得远程Ams（ActivityManagerService）的代理，再通过Binder机制将mAppThread传递给远程的Ams,从而实现了ApplicationThread与Ams之间的通信。

private void attach(boolean system) {
     ...
     //获得远程Ams（ActivityManagerService）的代理ActivityManagerProxy
     final IActivityManager mgr = ActivityManagerNative.getDefault();
     try {
       //注册mAppThread
       mgr.attachApplication(mAppThread);
     } catch (RemoteException ex) {
       // Ignore
     }
     ...         
}

attachApplication(mAppThread)调用了ActivityManagerProxy类中的attachApplication方法

public void attachApplication(IApplicationThread app) throws RemoteException{
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IActivityManager.descriptor);
        data.writeStrongBinder(app.asBinder());//通过Binder传递ApplicationThread实例
        mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
        reply.readException();
        data.recycle();
        reply.recycle();
}

这里写图片描述

问题来了，我们是怎么获得Ams的代理？这就的说说ServiceManager的作用了。

ServiceManager是用户空间的一个守护进程，它一直运行在后台。它的职责是管理Binder机制中的各个Service。当Service启动时，Service会将”Service对象的名字”连同”Service对象的信息”一起注册到ServiceManager中；而当Client需要获取Service接入点时，则通过”Service的名字”来从ServiceManager中找到对应的Service。

getIServiceManager()获取ServiceManager，这里的sServiceManager实际上是远程代理。

private static IServiceManager getIServiceManager() {
        if (sServiceManager != null) {
            return sServiceManager;
        }

        // 初始化ServiceManager，并返回代理ServiceManagerProxy对象
        sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
        return sServiceManager;
    }

//native代码，不难猜测，这里的IBinder，应该是远程继承了IServiceManager的类
public static final native IBinder getContextObject();

当有了ServiceManager后，我们就可以通过它获得各种Service的代理类了，如上提到的Ams。

public static IBinder getService(String name) {
        try {
            IBinder service = sCache.get(name);
            if (service != null) {
                return service;
            } else {
                return getIServiceManager().getService(name);
            }
        } catch (RemoteException e) {
            Log.e(TAG, "error in getService", e);
        }
        return null;
    }

这里写图片描述