Activity启动流程

只影1

已于 2022-06-26 00:16:16 修改

阅读量350

点赞数

分类专栏： Android 源码动脑笔记文章标签： Activity启动流程 Activity 启动流程

于 2020-05-24 22:43:32 首次发布

本文链接：https://blog.csdn.net/qq_19269585/article/details/106322880

版权

Android 同时被 3 个专栏收录

35 篇文章 0 订阅

订阅专栏

源码

9 篇文章 0 订阅

订阅专栏

动脑笔记

7 篇文章 0 订阅

订阅专栏

一、创建Application

首先 ActivityThread main()方法

public static void main(String[] args){
    ...
    //初始化Looper
    Looper.prepareMainLooper(); 
    ...
    //实例化一个ActivityThread
    ActivityThread thread = new ActivityThread();
    //这个方法最后就是为了发送出创建Application的消息
    thread.attach(false);
    ... 
    Looper.loop();
    //主线程进入无限循环状态，等待接收消息
}

ActivityThread 对象thread.attach(false)

public void attach(boolean system){
    ...
    //获得IActivityManager实例，他是一个ActivityManagerProxy的示例
    final IActivityManager mgr = ActivityManagerNative.getDefault();  
    try {
        //这里是关键。mAppThread是一个ApplicationThread实例，具体的在下面说
        mgr.attachApplication(mAppThread);
    } catch (RemoteException ex) {
        throw ex.rethrowFromSystemServer();
    }
    ...
}

mgr.attachApplication(mAppThread)

public void attachApplication(IApplicationThread app) throws RemoteException{
    Parcel data = Parcel.obtain();
    Parcel reply = Parcel.obtain();
    data.writeInterfaceToken(IActivityManager.descriptor);
    //把IApplicationThread 的对象app写到了data里，
    //app就是mAppThread，mAppThread是什么看后面分析
    data.writeStrongBinder(app.asBinder());
    //重点在这里，用mRemote把dare传输出去
    mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
    reply.readException();
    data.recycle();
    reply.recycle();
}

mRemote是什么？

看ActivityManagerProxy的构造方法，注意上面的mgr是一个ActivityManagerProxy的对象

public ActivityManagerProxy(IBinder remote){
	mRemote = remote;
}

而ActivityManagerProxy对象的创建是在ActivityManagerNative的静态方法asInterface里调用的

static public IActivityManager asInterface(IBinder obj) {
    if (obj == null) {
        return null;
    }
    ...
    //这里
    return new ActivityManagerProxy(obj);
}

obj即ActivityManagerProxy的mRemote对象又是方法外传入的，我们继续看调用

private static final Singleton<IActivityManager> gDefault = 
  new Singleton<IActivityManager>() {
    protected IActivityManager create() {
       //mRemote对象就是下面的IBinder b，它是一个ActivityManagerService的实例
       IBinder b = ServiceManager.getService("activity");
        ...
        IActivityManager am = asInterface(b);
        //调用了上面的方法。
        ...
        return am;
    }
};

也就是说mRemote 是一个ActivityManagerService的实例对象，

ActivityManagerService 的对transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0)的处理

我们在 3 [回到“3”] 调用了mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0)方法，而mRemote 是一个ActivityManagerService的实例对象

ActivityManagerService继承ActivityManagerNative对象，而ActivityManagerNative对象继承Binder，而Binder的transact方法的处理就是调用它的onTransact方法

 public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        ...
        boolean r = onTransact(code, data, reply, flags);
        ...
        return r;
    }

也就是说它会调用mRemote的onTransact方法，

而在ActivityManagerService的onTransact方法里

public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
            throws RemoteException {
    if (code == SYSPROPS_TRANSACTION){...}
    try {
        return super.onTransact(code, data, reply, flags);
        } catch (RuntimeException e) {
           ...
        }   
}

没有对ATTACH_APPLICATION_TRANSACTION进行处理，而是交给了他的父类ActivityManagerNative进行处理

ActivityManagerNative的onTransact方法

 @Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
    throws RemoteException {
    switch (code){
        case ATTACH_APPLICATION_TRANSACTION: {
            data.enforceInterface(IActivityManager.descriptor);
            //从data里取出app，也就是2 里的mAppThread
            IApplicationThread app = ApplicationThreadNative.asInterface(
                data.readStrongBinder());
            if (app != null) {
                //看这里，转到attachApplication去处理了
                attachApplication(app);
            }
            reply.writeNoException();
            return true;
        }
    }

attachApplication(app)方法

public final void attachApplication(IApplicationThread thread) {
    int callingPid = Binder.getCallingPid();
    ...
    attachApplicationLocked(thread, callingPid);
    ...  
}

继续跳转到attachApplicationLocked方法

private final boolean attachApplicationLocked(IApplicationThread thread
, int pid) {
    ...
    thread.bindApplication();
    ...
}

经过一系列的操作后调用了thread.bindApplication()发出初始化Applicationd的消息

mAppThread是什么

视野回到2：mgr.attachApplication(mAppThread)这里的mAppThread到底是个啥？

mAppThread是ActivityThread 的变量

final ApplicationThread mAppThread = new ApplicationThread();

而ApplicationThread类
```
private class ApplicationThread extends ApplicationThreadNative{
    ...
}
```
是一个ActivityThread中的一个内部类，它继承自ApplicationThreadNative
```
public abstract class ApplicationThreadNative extends Binder 
    implements IApplicationThread{
    ...
    //无参构造函数
    public ApplicationThreadNative() {
        //这是Binder的
        attachInterface(this, descriptor);
    }
    ...
}
```
那么很明显，ApplicationThread最终也是一个Binder！由于实现了IApplicationThread接口，所以它也是一个IApplicationThread，这就跟 5 [回到“5”]里面的最终调用对应起来了

下面是Binder的attachInterface()方法，单纯的进行了赋值
```
public void attachInterface(IInterface owner, String descriptor) {
    mOwner = owner;
    mDescriptor = descriptor;
}
```

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

他最终发送了一个H.BIND_APPLICATION消息，而这个消息被handler分发，最终由handleBindApplication方法处理

private void handleBindApplication(AppBindData data) {
    ...
    mInstrumentation = (Instrumentation)
        cl.loadClass(data.instrumentationName.getClassName())
        .newInstance();
    //通过反射初始化一个Instrumentation仪表。
    ...
    Application app = data.info.makeApplication(data.restrictedBackupMode, null);
    //通过LoadedApp命令创建Application实例
    mInitialApplication = app;
    ...
    mInstrumentation.callApplicationOnCreate(app);
    //让仪器调用Application的onCreate()方法
    ...
}

可以看到他在里面创建了Application对象。

然后是mInstrumentation.callApplicationOnCreate 方法

public void callApplicationOnCreate(Application app) {
    app.();
}

此时Application进入了我们熟悉的onCreate生命周期

makeApplication怎么创建了对象

首先要知道data.info为LoadedApk类型的对象，我们去这个类看makeApplication 方法

public Application makeApplication(boolean forceDefaultAppClass,
    Instrumentation instrumentation) {
    ...
    String appClass = mApplicationInfo.className;
    //获取Application的类名。明显是要用反射了。
    ...
    ContextImpl appContext = ContextImpl.createAppContext(mActivityThread
        , this);
    //留意下Context
    app = mActivityThread.mInstrumentation
        .newApplication( cl, appClass, appContext);
    //通过仪表创建Application
    ...
}

方法里获取了 Application 的类名，然后交给了 Instrumentation 去创建对象

Instrumentation 的 newApplication 方法

static public Application newApplication(Class<?> clazz
    , Context context) throws InstantiationException
    , IllegalAccessException
    , ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
        //反射创建，简单粗暴
        app.attach(context);
        //关注下这里，Application被创建后第一个调用的方法。
        //目的是为了绑定Context。
        return app;
    }

Instrumentation 直接用反射创建了Application 对象，然后调用了app.attach(context)方法绑定Context。

Application 的attach

final void attach(Context context) {
   //注意这个方法是一个可以比onCreate更早被调用的方法
   attachBaseContext(context);
   mLoadedApk = ContextImpl.getImpl(context).mPackageInf;
}

二、创建Activity

再次回到ActivityManagerService的attachApplication方法（在“5”处），这次我们多看一点代码

private final boolean attachApplicationLocked(IApplicationThread thread,
            int pid) {

        ......

        try {
        ......
            //1.发送启动Application
            thread.bindApplication(...);
        ......
        } catch (Exception e) {
        ......
            return false;
        }
        ......
        if (normalMode) {
            try {
                //2.启动activity
                if (mStackSupervisor.attachApplicationLocked(app)) {
                    didSomething = true;
                }
            } catch (Exception e) {
                ...
            }
        }

        ......

        return true;
    }

上面代码可以看到thread.bindApplication创建Application对象后，在正常模式下调用mStackSupervisor.attachApplicationLocked(app)方法去创建一个Activity

mStackSupervisor是一个ActivityStackSupervisor类型的示例

下面是attachApplicationLocked方法

boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
    ... 
    try {
        //调用realStartActivityLocked方法真正启动activity
        if (realStartActivityLocked(hr, app, true, true)) {
            didSomething = true;
        }
    } catch (RemoteException e) {
	...
    }
    ...
	return didSomething;
}

然后是realStartActivityLocked方法

final boolean realStartActivityLocked(ActivityRecord r,
            ProcessRecord app, boolean andResume, boolean checkConfig)
            throws RemoteException {
    ......
    try {
        ......
        app.thread.scheduleLaunchActivity(...);
        ......
    } catch (RemoteException e) {
        ......
    }
    ......
    return true;
}

app.thread就是我们熟悉的ApplicationThread（见 “6”）

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) {
     ...
     //将消息交给H类型的mH处理
     sendMessage(H.LAUNCH_ACTIVITY, r);
}

跟bindApplication类似发送一个H.LAUNCH_ACTIVITY消息

最终这个消息被被handler分发给了ApplicationThread的handleLaunchActivity方法

private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ......
    //1.执行Activity的初始化及oncreate方法
    Activity a = performLaunchActivity(r, customIntent);

    if (a != null) {
        ......
        //2.执行Activity的onResume方法
        handleResumeActivity(r.token, false, r.isForward,!r.activity.mFinished && !r.startsNotResumed);
        ......
    } else {
        ......
    }
   
}

ApplicationThread 的 performLaunchActivity 方法

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    ......
    Activity activity = null;
    try {
        ...
        //1.创建activity
        activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
        ...
        } catch (Exception e) {
            ...
        }

    try {
        //2.创建Application，实质上Application已经创建，只是获得已有的Application 实例
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
        ......
        if (activity != null) {
            //3.创建context
            Context appContext = createBaseContextForActivity(r, activity);
            ......
            //4.将Context和Application 与activity关联起来，完成activity的初始化
             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);
            //5.调用activity的oncreate方法
            if (r.isPersistable()) {
                mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
            } else {
                mInstrumentation.callActivityOnCreate(activity, r.state);
            }
            ......
        } catch (SuperNotCalledException e) {
            ...
        }
        return activity;
    }

实际创建 Activity 这里还是使用 Instrumentation 的对象，而mInstrumentation.newActivity方法跟

newApplication 方法一样。

用反射创建出Activity创建出Activity 后performLaunchActivity 方法开始执行使用mInstrumentation 调用 Activity的声明周期

三、简述，

ActivityThread main方法，创建一个ActivityThread 对象
ActivityThread 对象调用attach 方法创建并绑定Application
attach方法里获取到ActivityManagerProxy 对象 mgr，调用其 attachApplication 方法，其中传入ApplicationThread类型的参数mAppThread，ApplicationThread实现了Binder
attachApplication 方法使用ActivityManagerProxy 对象的属性mRemote 通过Binder机制远程调用ApplicationThread 的bindApplication方法，mRemote 是 ActivityManagerService 类型的远程 IBinder 对象

attachApplication 方法使用ActivityManagerService通过Binder机制远程调用其attachApplication方法，attachApplication方法通过传递过来的对象mAppThread通过Binder机制远程调用ApplicationThread的bindApplication方法

bindApplication方法使用Handler机制发送H.BIND_APPLICATION消息，消息被mH分发处理后使用Instrumentation 通过反射出Application对象，并调用其生命
attachApplication 在创建完Application对象后，使用上述类似的机制远程调用ApplicationThread 的scheduleLaunchActivity方法
scheduleLaunchActivity方法同样使用Handler发送H.LAUNCH_ACTIVITY消息，后面同Application的创建一样，使用Instrumentation 通过反射创建Activity对象，然后调用其生命周期

只影1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Activity启动流程

一、创建Application首先 ActivityThread main()方法public static void main(String[] args){ ... //初始化Looper Looper.prepareMainLooper(); ... //实例化一个ActivityThread ActivityThread thread = new ActivityThread(); //这个方法最后就是为了发送出创建Applicati
复制链接

扫一扫

专栏目录