Activity启动过程分析

69 阅读 0 评论 46 点赞

我是靠谱客的博主怡然电话，最近开发中收集的这篇文章主要介绍Activity启动过程分析，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一.概述

对着老罗的博客和源码自己梳理了一遍Activity的启动过程,为了方便记忆就将这个过程整理写了下来,整个启动过程涉及到的类主要有Activity,ActivityManagerService,ActivityStack, PackageManagerService,ActivityThread和ApplicationThread.涉及到的进程一般是有2个,如果是启动另外一个应用的acitiviy就有3个进程,第一个就是我们当前应用所在的进程,第二个就是ActivityManagerService所在的进程,如果有第3个就是要启动的activity所在的进程.所以整个启动过程就涉及到了Binder的通信,其中上面说的ActivityManagerService,PackageManagerService和ApplicationThread都是Binder的子类这3个就是负责整个启动过程中的进程通信的.

二.启动过程分析

整个过程其实可以理解成2个过程,第一过程就是在他们的应用进程中封装intent将要启动的activity的信息传入到ActivityManagerService中,第二个过程就是在ActivityManagerService通过PackageManagerService来验证intent信息,通过ActivityStack来管理任务栈和存储activity,通过ActivityThread的消息队列来实际操作activity的创建和生命周期的创建.
下面就先从要启动activity所在的进程开始分析
1.Activity.startActivity->startActivityForResult->mInstrumentation.execStartActivity->ActivityManagerNative.getDefault().startActivity

2.ActivitymanagerService.startActivity
从这一步开始就进入到了ActivitymanagerService所在的进程了,这ActivitymanagerService的startActivity方法中其实是通过调用ActivityStack.startActivityMayWait方法来处理逻辑.

3.ActivityStack.startActivityMayWait
这个方法首先调用PackageManagerService的resolveIntent方法来解析intent找到这个intent代表的activity信息,
然后在调用startActivityLocked方法.

4.ActivityStack.startActivityLocked(IApplicationThread caller,
Intent intent, String resolvedType,
Uri[] grantedUriPermissions,
int grantedMode, ActivityInfo aInfo, IBinder resultTo,
String resultWho, int requestCode,
int callingPid, int callingUid, boolean onlyIfNeeded,
boolean componentSpecified)

首先调用ActivityStack.isInAnyStackLocked方法其实就在ActivityStack的mActivityDisplays容器中查找要启动的activity是否存在于任意一个任务栈中.
在判断从PackageManagerService中获取到的acitiviyinfo是否为null,如果为null就表示要启动的acitiviy是没有在任何的清单文件中声明过的,就会抛出异常,否则就会通过new activityrecord 创建即将要启动的Activity的相关信息，并保存在r变量中,然后在调用startActivityUncheckedLocked

5.ActivityStack .startActivityUncheckedLocked

在这个里面会获取要启动的activity的启动模式,然后根据启动模式和要启动的activity的任务栈是否存在等信息来判断要不要启动新的任务栈,然后在进入到 startActivityLocked(ActivityRecord r, boolean newTask,
boolean doResume, boolean keepCurTransition, Bundle options)中

6.ActivityStack .startActivityLocked(ActivityRecord r, boolean newTask,
boolean doResume, boolean keepCurTransition, Bundle options)
这个方法就判断是否要切换新的界面,要切换就调用到resumeTopActivitiesLocked方法.

7.ActivityStack .resumeTopActivitiesLocked

它首先看要启动的Activity是否就是当前处于Resumed状态的Activity，如果是的话，那就什么都不用做，直接返回就可以了；否则再看一下系统当前是否休眠状态，如果是的话，再看看要启动的Activity是否就是当前处于堆栈顶端的Activity，如果是的话，也是什么都不用做。
上面两个条件都不满足，因此，在继续往下执行之前，首先要把当处于Resumed状态的Activity推入Paused状态，然后才可以启动新的Activity。但是在将当前这个Resumed状态的Activity推入Paused状态之前，首先要看一下当前是否有Activity正在进入Pausing状态，如果有的话，当前这个Resumed状态的Activity就要稍后才能进入Paused状态了，这样就保证了所有需要进入Paused状态的Activity串行处理。调用startPausingLocked将activity进入到Paused状态

8.ActivityStack .startPausingLocked

函数首先把mResumedActivity保存在本地变量prev中。mResumedActivity就是当前处于resume状态的activity，因此，这里把当前resueme状态进程中的ApplicationThread对象取出来，通过它来通知这个Activity它要进入Paused状态了。通过调用这个ApplicationThread对象的schedulePauseActivity来通知这个activity进入Paused状态.因为startPausingLocked是在acitiviymanagerservice进程的,而当前resume状态的activity是在我们的应用进程的,所以想要从acitiviymanagerservice进程让我们应用进程的activity进入pause状态就需要用到Binder通信,而这里完成这个通信的Binder就ApplicationThread.这个ApplicationThread就是一个Binder子类定义在ActivityThread类中.就了为了帮助ActivityThread完成进程间通信的.

ActivityThread . ApplicationThread . schedulePauseActivity


1. public final class ActivityThread {
2.
3.
......
4.
5.
private final class ApplicationThread extends ApplicationThreadNative {
6.
7.
......
8.
9.
public final void schedulePauseActivity(IBinder token, boolean finished,
10.
boolean userLeaving, int configChanges) {
11.
queueOrSendMessage(
12.
finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
13.
token,
14.
(userLeaving ? 1 : 0),
15.
configChanges);
16.
}
17.
18.
}
19.
20. }

其实到这一步就是到了当前处于resume状态的activity的ActivityThread也就是主线程中来了,然后schedulePauseActivity中就是通过handler将消息发送到主线程的消息队列中去了,在看下主线程的handlerH 的handmessage方法:


1.
public void handleMessage(Message msg) {
2.
switch (msg.what) {
3.
case PAUSE_ACTIVITY:
//
4.
handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
5.
maybeSnapshot();
6.
break;
7.
......
8.
9.
}

如果是pause_activity就调用handlePauseActivity方法.

10.ActivityThread.handlePauseActivity

最终还是调用mInstrumentation.callActivityOnPause(r.activity)来让当前activity进入到pause状态.
然后在调用ActivityManagerNative.getDefault().activityPaused(token);告诉activitymanager这个Activity已经进入Paused状态了，ActivityManagerService现在可以完成未竟的事情，即启动新的Activity了

11.activityStack.activityPausedLocked

这个方法会继续调用completePauseLocked方法来保存pauseactivity的信息,然后调用resumeTopActivitiesLocked()

12.activityStack.resumeTopActivitiesLocked

在这个方法中会拿到我们将要启动的activityrecord,然调用startSpecificActivityLocked(r),这里就将要启动的activirecord当参数传入

13.activityStack.startSpecificActivityLocked


1. public class ActivityStack {
2.
3.
......
4.
5.
private final void startSpecificActivityLocked(ActivityRecord r,
6.
boolean andResume, boolean checkConfig) {
7.
通过activityrecord的进程名和uid来获取进程 ,如果用户没有在xml指定默认就是包名
8.
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
9.
r.info.applicationInfo.uid);
10.
11.
......
12.
如果拿到了进程,就直接调用realStartActivityLocked
13.
if (app != null && app.thread != null) {
14.
try {
15.
realStartActivityLocked(r, app, andResume, checkConfig);
16.
return;
17.
} catch (RemoteException e) {
18.
......
19.
}
20.
}
21.
如果没有拿到进程,就先通过进程名创建进程
22.
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
23.
"activity", r.intent.getComponent(), false);
24.
}
25.
26.
27.
......
28.
29. }

这里就有2种情况了,如果是一个进程的第一个acitiviy也就进程还没有创建的情况就会调用ams的startProcessLocked方法先去创建进程,如果是进程已经存在的就会调用activityStack.realStartActivityLocked直接去创建acitiviy.因为创建进程完也是要创建activity的所以我们这里先去看一下ams.startProcessLocked方法.

ActivityManagerService .startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName, boolean allowWhileBooting))

在这个方法中会再次再次检查是否已经有以process + uid命名的进程存在,如果不存在就会创建一个ProcessRecord,在调用startProcessLocked(ProcessRecord app,
1. String hostingType, String hostingNameStr)方法.

14.ActivityManagerService .startProcessLocked(ProcessRecord app,
1. String hostingType, String hostingNameStr),在这个方法中会调用Process.start来创建一个新的进程,实际上进程的创建还要交给Zygote进程来创建的,新的进程会导入android.app.ActivityThread类，并且执行它的main函数.

15.ActivityThread .main


1. public static final void main(String[] args) {
2.
3.
.......
4.
5.
ActivityThread thread = new ActivityThread();
6.
thread.attach(false);
7.
8.
......
9.
10.
Looper.loop();
11.
12.
.......
13.
14.
thread.detach();
15.
16.
......
17.
}

这个函数在进程中创建一个ActivityThread实例，然后调用它的attach函数，接着就进入消息循环了，直到最后进程退出,所以一个进程都会有一个ActivityThread实例表示主线程.函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的attachApplication函数，传入的参数是mAppThread，这是一个ApplicationThread类型的Binder对象

16.ActivityManagerService.attachApplication

这里最终是调用attachApplicationLocked(IApplicationThread thread,int pid)函数来处理,thread和pid都是新进程传过来的

17.ActivityManagerService.attachApplicationLocked

这个方法会通过pid拿到我们之前创建的activirecord,并且将thread等信息设置给activityrecord,然后在调用activityStack.realStartActivityLocked.

18.activityStack.realStartActivityLocked

这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中，注意，这里的第二个参数r，是一个ActivityRecord类型的Binder对象，用来作来这个Activity的token值,这里就进入新的acitiviy所在的进程然后创建对应的acitiviy了,通信就是通过这个thread来通信的

19.ActivityThread .ApplicationThread .scheduleLaunchActivity

到了这里其实还是要通过handler将要创建activity的消息发送到消息队列中,所以下面就是进入到H的handmessage中.最终调用ActivityThread .handleLaunchActivity

20.ActivityThread .handleLaunchActivity


1. private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
2.
......
3.
创建acitiviy,并且回调onCreate方法
4.
Activity a = performLaunchActivity(r, customIntent);
5.
6.
if (a != null) {
7.
r.createdConfig = new Configuration(mConfiguration);
8.
Bundle oldState = r.state;
i.
在回调onResume方法,让acitiviy进入到onResume状态
9.
handleResumeActivity(r.token, false, r.isForward);
10.
11.
......
12.
} else {
13.
......
14.
}
15.
}

21.最终是调用performLaunchActivity来创建activity

 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//得到目标activity的ComponentName对象
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
Activity activity = null;
try {
//从package中拿到目标类的类加载器
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
//通过 mInstrumentation.newActivity创建acitiviy,实际就是通过类加载器反射创建
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
} catch (Exception e) {
...
}
try {
//如果该activity的进程application不存在就通过mInstrumentation的newApplication创建一个新的application,并且调用onCreate方法,如果已经存在了就直接返回,在应用中进程是用application来表示的
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
//创建一个新的Context
Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
调用activity的attach方法,赋值context,Instrumentation对象
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);
//调用activity的oncreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
}
return activity;
}

三.总结

1 就是将intent信息送入到activitymanagerservie中,这里涉及到了跨进程通信
3-6 就是负责校验要启动的acitiviy是否有在清单文件中注册过,没有就抛出异常,有就根据启动模式和flag等信息创建出对应的ActivityRecord准备启动
7-11 这个几个步骤就在准备启动新的activity之前先将当前处于resume状态的activity进入到pause状态,这里首先要从activitymanagerservice进程将要进入pause状态的信息发送到应用进程,等acitiviy进入到pause状态以后又要从应用进程将进入pause状态完成的信息发送到activitymanagerservice进程中

12-13 这2步就拿到要启动的activityrecord,并且通过activityrecord的进程名和uid来获取进程,如果进程不存在就创建进程,要存在就直接创建acitiviy

14-17 这几步就创建一个新的进程的过程,进程的创建都是通过Zygote进程来创建的,然后每一个进程都会创建一activitythread实例

18-21 这几部就是启动新的activity的过程,它是从acitiviymanagerservie进程及nag要启动的信息发送到新的acitiviy所在的进程的,然后通过消息队列来完成acitiviy的创建.

activityt的创建和生命周期的调用都是通过mInstrumentation来统一管理的.