提示
文中代码较多,点击文章末尾处阅读原文获取更好略读体验。
由此我们可以得到ActivityThread框架图:
通常ApplicationThread中的接口方法都是以“schedule”开头,而ActivityThread中对应的处理方法则以“handle”开头。
ActivityThread中的成员变量mActivities中保存了所有ActivityClientRecord对象,该类中重要的成员变量如下:
static final class ActivityClientRecord {
IBinder token; // Activity对象的全局唯一标示
Intent intent; // 启动Activity的Intent
Activity activity; // Activity对象
Window window; // Activity的窗口对象
boolean paused; // 是否在暂停状态的标志
boolean stopped; // 是否在停止状态的标志
ActivityInfo activityInfo; // Activity的信息
LoadedApk packageInfo; // 包的信息
}
token的类型是IBinder,在ActivityManagerService中会为每个应用程序中的Activity对象建立了一个对应的ActivityRecord对象,ActivityRecord会创建一个token对象来作为Activity的标识。这个token是个Binder对象,但是它不是为提供Binder服务而创建的,这里只是利用Binder对象的 系统全局唯一性 来作为标识符。 每一个Activity都包含了一个Window对象,Window对象关联着应用框架的一大块内容。
从上面的框架图我们可以得知:启动一个Activity,首先会经过AMS和ActivityThread之间又长又臭的调用和回调,最终才会调到ActivityThread的handleLaunchActivity()方法。下面我们看一下接下来的流程。
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
......
// 执行Activity创建和onCreate流程
Activity a = performLaunchActivity(r, customIntent); if (a != null) {
r.createdConfig = new Configuration(mConfiguration);
Bundle oldState = r.state;
// 执行Activity的onResume流程
handleResumeActivity(r.token, false, r.isForward,
!r.activity.mFinished && !r.startsNotResumed);
......
} else {
// If there was an error, for any reason, tell the activity
// manager to stop us.
try {
ActivityManagerNative.getDefault()
.finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
} catch (RemoteException ex) {
// Ignore
}
}
}
handleLaunchActivity()再调用performLaunchActivity()方法来创建Activity并执行onCreate流程,返回后再执行Activity的onResume流程。继续深入,不要怂。
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
// 首先,从ActivityClientRecord中获取待启动的Activity的组件信息
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
// 获取Activity的packageInfo
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
} ComponentName component = r.intent.getComponent();
if (component == null) {
// 获取Activity的ComponentName
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 {
// 拿到加载Activity的ClassLoader, 创建Activity对象
java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
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) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
} try {
// 拿到当前进程中的Application对象
Application app = r.packageInfo.makeApplication(false, mInstrumentation); if (activity != null) {
// 创建Activity的ApplicationContext
Context appContext = createBaseContextForActivity(r, activity);
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
// 调用Activity的attach方法在其内部保存一些ActivityClientRecord内的属性
// 来完成一些重要的数据初始化
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);
......
// 通过mInstrumentation调用Activity的onCreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
...
// 将ActivityClientRecord中的activity属性设置为当前activity
r.activity = activity;
......
}
r.paused = true; // 以ActivityClientRecord中的token为key,mActivities中添加待启动的activity
mActivities.put(r.token, r); } catch (SuperNotCalledException e) {
throw e; } catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
} return activity;
}
从上面代码我们发现,ActivityThread最后调用了mInstrumentation变量的newActivity()方法来创建Activity对象,并回调了callActivityOnCreate()方法,走完Activity的onCreate流程。
public class Instrumentation {
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle); // 回调Activity.onCreate()
postPerformCreate(activity);
} public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
activity.performCreate(icicle, persistentState); // 回调Activity.onCreate()
postPerformCreate(activity);
}
}public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback { final void performCreate(Bundle icicle) {
onCreate(icicle);
mActivityTransitionState.readState(icicle);
performCreateCommon();
} final void performCreate(Bundle icicle, PersistableBundle persistentState) {
onCreate(icicle, persistentState);
mActivityTransitionState.readState(icicle);
performCreateCommon();
}
}
这样Activity在应用端进程ActivityThread的启动流程和生命周期回调流程都简单分析完了。
Instrumentation可以理解为应用进程的管家,ActivityThread要执行创建或暂停某个Activity等操作时,都需要通过Instrumentation来进行具体的实现(回调Activity的生命周期)。每一个应用程序只有一个Instrumentation对象,每个Activity内都有一个对该对象的引用。 另外,当我们在Activity中调用startActivity()的 时候,实际上调用的还是Instrumentation的相关的方法mInstrumentation.execStartActivity()。
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess();
// 通知AMS执行startActivity的流程
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
ActivityManagerNative.getDefault返回的就是ActivityManagerService的远程接口,即ActivityManagerProxy。 除了启动Activity之外,还有很多方法,有兴趣的可以深入了解一下:
通俗的理解,ActivityThread负责创建这个“家庭”,并负责对外打交道,比如接收AMS的通知等。Instrumentation负责管理这个家庭,安排每个Activity的日常流程等工作。
AMS通过Binder进行IPC通讯,通知应用进程ActivityThread启动指定Activity
ActivitymanagerService是Android Framework的一个核心系统服务,它管理着Android系统中的4大组件:Activity、Service、ContentProvider和BroadcastReceiver。前面已经介绍了,Android希望模糊进程的作用,取而代之以组件的概念,AMS正是这一理念的实现。AMS除了管理这4大组件之外,同时也管理和调度所有用户进程。
AMS是一个Binder服务,但是AMS的Binder框架代码不是通过AIDL自动生成的。AMS从ActivityManagerNative类派生,这个类加上IActivityManager、ActivityManagerProxy和ActivityManager共同实现了AMS Binder框架。它们的关系如下图:
理解了AMS的Binder框架类的作用,后面分析AMS服务的时候,可以不用关系这些类,只需要集中精力在AMS类的本身上。
AMS运行在SystemServer进程中,对象的创建是在SystemServer类初始化时完成的。
public final class SystemServer {
......
private ActivityManagerService mActivityManagerService;
private void startBootstrapServices() {
...
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService(); // 创建AMS服务
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
...
}
......
}
从代码中可以看到,这里调用了mSystemServiceManager.startService()方法,这个方法将根据传入的参数(类的class)来创建类的实例对象,并注册到ServiceManager中。 接下来我们看一下AMS的构造方法做了些什么:
public ActivityManagerService(Context systemContext) {
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
// 获取运行在SystemServer中的ActivityThread对象
mSystemThread = ActivityThread.currentActivityThread();
// 创建用于处理消息的线程和Handler对象
mHandlerThread = new ServiceThread(TAG,
android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
// 创建用于UI操作相关的Handler对象
mUiHandler = new UiHandler(); // 创建管理广播的数据结构
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", BROADCAST_FG_TIMEOUT, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", BROADCAST_BG_TIMEOUT, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue; mServices = new ActiveServices(this); // 创建管理组件Service的对象
mProviderMap = new ProviderMap(this); // 创建管理组件Provider的对象 // 获取系统的data和system目录
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system");
systemDir.mkdirs(); // 创建BatteryStatsService服务
mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk();
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();
mBatteryStatsService.getActiveStatistics().setCallback(this);
// 创建ProcessStatsService服务
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
// 创建AppOpsService应用权限管理服务
mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler);
// 打开文件urigrants.xml
mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml")); // 设置0号用户作为第一个用户
mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true));
mUserLru.add(UserHandle.USER_OWNER);
updateStartedUserArrayLocked();
// 获取OpenglES的版本
GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
ConfigurationInfo.GL_ES_VERSION_UNDEFINED); mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
// 设置mConfiguration配置项为系统缺省值
mConfiguration.setToDefaults();
mConfiguration.setLocale(Locale.getDefault()); mConfigurationSeq = mConfiguration.seq = 1;
mProcessCpuTracker.init(); mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
// 创建Intent “防火墙”
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
// 创建最近任务栏的栈管理对象
mRecentTasks = new RecentTasks(this);
// 创建Activity栈的管理对象mStackSupervisor
mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks);
mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks);
// 创建统计CPU使用情况的线程
mProcessCpuThread = new Thread("CpuTracker") {
......
} // 把服务加到watchdog的监控中
Watchdog.getInstance().addMonitor(this);
Watchdog.getInstance().addThread(mHandler);
}
AMS构造方法的主要作用是创建了4大组件Activity、Service、BroadcastReceiver和ContentProvider的管理对象以及一些内部对象,逻辑比较简单。
AMS中启动一个进程调用的是addAppLocked()方法。
final ProcessRecord addAppLocked(ApplicationInfo info, boolean isolated,
String abiOverride) {
ProcessRecord app;
// isolated为true表示要启动一个新进程
if (!isolated) { // 在已经启动的进程列表中查找
app = getProcessRecordLocked(info.processName, info.uid, true);
} else {
app = null;
} if (app == null) {
// 创建一个ProcessRecord对象
app = newProcessRecordLocked(info, null, isolated, 0);
updateLruProcessLocked(app, false, null);
updateOomAdjLocked();
}
......
if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) {
mPersistentStartingProcesses.add(app);
// 启动进程
startProcessLocked(app, "added application", app.processName, abiOverride,
null /* entryPoint */, null /* entryPointArgs */);
} return app;
}
addAppLocked()方法会根据参数isolated来决定是否启动一个新进程,如果为true,即使系统中可能已经有一个同名的进程存在,也会再创建一个新进程。getProcessRecordLocked()方法用来在当前运行的进程列表中查找进程。newProcessRecordLocked()方法用来创建一个ProcessRecord的数据结构。updateLruProcessLocked方法用来更新运行中的进程的状态,updateOomAdjLocked用来更新进程的优先级,这两个方法是Process管理的核心。篇幅有限,这里不再展开分析咯。
final class ActivityRecord {
// AMS的引用
final ActivityManagerService service; // owner
// token用来和WMS交互
final IApplicationToken.Stub appToken; // window manager token
final ActivityInfo info; // all about me
final ApplicationInfo appInfo; // information about activity's app
final ComponentName realActivity; // the intent component, or target of an alias.
... //Activity资源信息
CharSequence nonLocalizedLabel; // the label information from the package mgr.
int labelRes; // the label information from the package mgr.
int icon; // resource identifier of activity's icon.
int logo; // resource identifier of activity's logo.
int theme; // resource identifier of activity's theme.
int realTheme; // actual theme resource we will use, never 0.
int windowFlags; // custom window flags for preview window. // ActivityRecord所在的TaskRecord
TaskRecord task; // the task this is in.
...
// ActivityRecord所在进程
ProcessRecord app; // if non-null, hosting application
ActivityState state; // current state we are in
...
}
ActivityRecord就是Activity在AMS中的代表,ActivityRecord和应用中的Activity一一对应,并且包含了Activity的所有信息。(就好比Activity在ActivityThread中对应ActivityClientRecord一样) 每一个ActivityRecord都会有一个Activity与之对应,一个Activity可能会有多个ActivityRecord,因为Activity可以被多次实例化,取决于其Launchmode。 其中task对象标识了其所归属的TaskRecord,这样ActivityRecord和TaskRecord就联系起来了。
final class TaskRecord {
// TaskRecord的唯一标识
final int taskId; // Unique identifier for this task.
.....
// This represents the last resolved activity values for this task
// NOTE: This value needs to be persisted with each task
TaskDescription lastTaskDescription = new TaskDescription(); // TaskRecord里所有的ActivityRecord信息
/** List of all activities in the task arranged in history order */
final ArrayList<ActivityRecord> mActivities; // TaskRecord所在的stack
ActivityStack stack;
......
}
TaskRecord中我列出来三个成员变量:
从TaskRecord 的数据结构我们可以看到,mActivities保存了一组ActivityRecord信息,同时每一个ActivityRecord都有其所在TaskRecord的引用。TaskRecord都有一个唯一标示taskId,还包含了ActivityStack的引用对象。 因此,TaskRecord可以理解为一个mActivities组成的栈,也可以理解为一个由一系列Activity组成的活动。
final class ActivityStack {
/**
* The back history of all previous (and possibly still
* running) activities. It contains #TaskRecord objects.
*/
private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>(); ... final int mStackId;
...
/** Run all ActivityStacks through this */
final ActivityStackSupervisor mStackSupervisor;
}
从名字上看,ActivityStack更像是一个栈,实际上它就是一个Manager的角色。 ActivityStack负责管理协调ActivityRecord和TaskRecord,通过mStackId来唯一标识,持有ActivityStackSupervisor的引用。
每一个ActivityRecord都会有一个Activity与之对应。一系列相关的ActivityRecord组成了一个TaskRecord,TaskRecord是存在于ActivityStack中,ActivityStackSupervisor是用来管理这些ActivityStack的。 下面是一个简单的关系图
Task 是Activity的集合。Android把用户一次相关操作用使用的Activity按照先后顺序保存在Task中,这样当用户按back键的时候就能按照相反的顺序依次返回退出。Task像一个栈,以先进后出的方式管理着Activity。系统运行时内存中会存在多个Task,当我们查看最近任务栏时,会弹出一个列表让你选择,这个列表就是系统中存在的Task集合,选择一个Task会将它所包含的Activity作为一个整体带到前台。Task中的Activity的顺序通常是不能改变的,只能压栈和出栈。
AMS中使用ActivityStack 类来管理Task,它管理的Task都存放在成员变量mTaskHistory中。mTaskHistory也是一个列表,存储的是TaskRecord对象。TaskRecord对象代表一个Task,他的成员变量mActivities也是一个列表,存储了属于该Task中的所有ActivityRecord对象。
本文由原作者彭小川独家授权Open软件开发小组发布,著作权归原作者所有。如需转载请申请授权。