Android中启动一个Activity过程
来自个人维基
Android中启动一个Activity过程
启动activity：
- Aactivity启动Bactivity的过程描述
- 代码如下：
Intent intent =new Intent(Aactivity.this, Bactivity.class);
startActivity(intent);
接下来分析：
1.Acticity.startActivityForResult() @Aactivity
2.Instrumention.execStartActivity(); @ Insrumention
此类是一个监控类，主要用于监控Activity的生命周期 的执行，比如，什么时候调用了onCreate，什么时候调用了onPause()方法等。
3.ActivityManagerNative.getDefault() .startActivity()
- 3.1 ActivityManagerNative.getDefault()返回的是ActivityManagerProxy的实例，
- 它只是一个代理类，这个代理类实际上代理的是IBinder b = ServiceManager.getService("activity");
- 这个Service。
- 3.2 这个Service是什么时候添加进来的呢？
- 在SystemServer.java的run()中有调用
- ActivityManagerService.setSystemProcess();
- ServiceManager.addService("activity", m);
- 这里还会添加许多系统关键服务。
- （TODO：查看在SystemServer的Log输出）
- 3.3 由于ActivityManagerService是一个系统类，因此访问他要经过一个代理，不能直接访问，而且用代理类访问他，我们可以在访问他以前做一些其它操作，因此ActivityManagerNative.getDefault()，看代码是返回的一个ActivityManagerProxy类的实例，这个类就是ActivityManagerService的代理类，也就是通过这个类来访问AMS,代码如下
static public IActivityManager getDefault() {
if(gDefault!=null) {
return gDefault
}
IBinder b=ServiceManager.getService("activity"); // 从ServiceManager进程中获得AMS实例
gDefault=asInterface(b); // 把获得的AMS实例要通过adInterface接口赋给其代理类
return gDefault
}
- 再看asInterface() 方法，如下
static public IActivityManager asInterface(IBinder obj) {
if(obj==null) {
return null;
}
IActivityManager in=(IActivityManager)obj.queryLocalInterface(descriptor);
if(in!=null) {
return in;
}
return new ActivityManagerproxy(obj); // 这句就是把AMS的实例当作参数传给了ActivityManagerProxy类
// 因此我们想操作AMS就要通过此代理类来操作，不能直接调用
}
- 因此，ActivityManagerNative.getDefault() .startActivity() 这句代码，实际执行的是
- ActivityManagerProxy类中的startActivity() 方法
4：我们再分析ActivityManagerProxy类
ActivityManagerProxy是ActivityManagerNative类的一个内部类，其定义如下：
class ActivityManagerProxy implements IActivityManager { private IBinder mRemote; // 构造函数 public ActivityManagerProxy(IBinder remote) { mRemote=remote; // 此处就是asInterface方法中定义时把AMS实例传过来的，也就是说 // 此处的mRemote就是ActivityManagerService实例 } }
再分析ActivityManagerProxy中的startActivity方法，定义如下：
public int startActivity(IApplicationThread caller, Intent intent , String resolvedType, Uri[] grantedUriPermissions, int grantedMode, IBinder resultTo, String resultWho int requestCode, boolean onlyIfNeeded, boolean debug) { Parcel data=Parcel.obtain(); //把客户端传递的数据封装一下，然后跨进程传递 Parcel reply =Parcel.obtain(); data.writeInterfaceToken(IActivityManage.descriptor); // 保存数据 .... .... mRote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0); // 此句代码很重要，它会把以上所有数据，跨进程传递给ActivityManagerService类中onTrasact方法处理。 }
5: 分析ActivityManagerService类
- 第一个方法是onTrasact() ,来接受客户端传递数据，方法定义如下：
public boolean onTransact(int code , Parcel data , Parcel reply, int flags) { super.onTransact(code ,data , reply , flags); // 调用父类ActivityManagerNative中的onTrasact()方法 }
- onTrasact() 方法主要是接受trasact()方法封装的参数，也就是trasact()函数相当于封包，onTrasact()相当于拆包
- 把解析出来的参数，传给ActivityManagerService中的 startActivity()
------startActivity() @ActivityManagerService
------startActivityMayWait() @ActivityManagerService
------startActivityLocked() @ActivityManagerService
------startActivityUncheckedLocked() @ActivityManagerService 此方法检查权限，解析Intent中的flag语句
-------startActivityLocked() @ActivityManagerService// 与上个方法参数不一样，
--------resumeTopActivityLocked() @ActivityManagerService
--------startSpecificActivityLocked @ActivityManagerService // 此方法内容会分两部分执行，首先判断activity的进程是否启动，如果已经启动则执行第1种方案，
//如果没有启动，则启动第2种方案，
- 方案1：
--------startProcessLocked () @ActivityManagerService
- 方案2:
--------realStartActivityLocked() @ActivityManagerService // 此方法是进入真正启动一个Activity流程
--------scheduleLaunchActivity () @ActivityThread @ApplicationThread // 此方法进入到ApplicationThreadNative提供的服务，
// 也就是到ActivityThread的内部类ApplicationThread类中，
// 这里相当于进入客户端处理了，(到此服务端的Activity实例初始化完毕)。
- scheduleLaunchActivity方法定义如下:
scheduleLaunchActivity (Intent intent, IBinder token, int ident......) {
ActivityRecord r = new ActivityRecord() ; // 为此Activity定义一个客户端实例
....
queueOrSendMessage(H.LAUNCH_ACTIVITY, r); // 把启动Activity的消息传给一个内部类(H)来处理
// H类是一个Handler，
}
--------------handleLaunchActivity @ ActivityThread
--------------performLaunchActivity @ActivityThread // 此方法开始具体创建Activity，并调用其生命周期
- 此方法定义如下 :
private final Activity performLauchActivity(ActivityRecord r, Intent customIntent) {
.....
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
// 通过反射构造出Activity对象
activity.attach();// 调用Activity的attach() 方法, 此方法比较重要，主要创建Activity中的Window及
// WindowManager ， 等会儿具体分析
以下会逐渐调用Activity中生命周期的方法
mInstrumentation.callActivityOnCreate(activity, r.state); // 调用Activity中的onCreate方法
activity.performStart() ; // 调用
mInstrumentation.callActivityOnRestoreInstanceState(activity,r.state);
mInstrumentation.callActivityOnPostCreate(activity,r.state);
mActivitys.put(r.token,r); // 压入栈
}
--------------handleResumeActivity: 开始调用onResume() 方法，
--------------performResumeActivity(); // 调用onResume()方法
performResumeActivity () {
....
r.activity.performResume(); // 调用Activity中的onResume方法
.....
}
到此为止，整个Activity已经创建，启动了，但是他还什么都没有显示，因为没有显示在屏幕上，
handleResumeActivity() {
--r.window.getDecorView(); //开始把DecorView添加进Window
--wm.addView(decor, l);
}
屏幕上的内容，会显示出来， 至于窗口是怎么创建出来的，那要分析Activity中的Attach()方法了，以后再分析！
6:Activity与Window，View的关系分析，
- 在Android系统中，一个界面可以由两部分组成，
- 一：逻辑控制部分：Activity部分
- 二：界面显示部分：Window+View 部分，其中主要是View部分
- Activity主要是一个界面的逻辑控制部分，生命周期的管理等，具体的显示则交给View来显示，
- 在Activity类中有一个Window对象和一个WindowManager对象，用来管理View的显示，定义如下：
private Window window;
private WindowManager mWindowManager;
- 在1-5个分析中，我们把界面的逻辑部分(Activity部分)分析了一下，现在开始分析界面的显示部分(View部分)，
- 那么这两个对象在什么时候初始化呢？ 答案是在Activity刚被创建出来的时候，也就是在Activity中的attach()方法中初始化， 具体代码如下：
final void attach(Context context，ActivityThread aThread，.....) {
...
mWindow=PolicyManager.makeNewWindow(this); // 创建Window对象
...
mWindow.setWindowManager(null，mToken，mComponent.flattenToString()); // 创建WindowManager对象
....
mWindowManager=mWindow.getWindowManager();
}
- 让我们跟踪mWindow对象的创建过程，进入PolicyManager类中，我们发现makeNewWindow()方法返回一个PhoneWindow对象，此类实现了Window抽象类，
- 再看一下WindowManager对象的创建，mWindow.setWindowManager()方法，毫无疑问，mWindow就是PhoneWindow， setWindowManager() 实际是由Window这个类来实现的，进入Window类中的此方法，看到如下代码：
public void setWindowManager(wm，appToken，appName) {
if(wm==null) {
wm=WindowManagerImpl.getDefault();
}
mWindowManager=new LocalWindowManager(wm);
}
由此可以看出 LocalWindowManager是一个代理类，它代理的是WindowManagerImpl类，也就是说，真正实现功能的是
WindowManagerImpl类，
到此为止，界面的Window部分已初始化完毕，下面进入界面显示部分的主角-----View部分：
- system_process进程
4 ActivityManagerNative
|--ActivityManagerService
在ActivityManagerNative的onTransact方法中最终提供了服务：
case START_ACTIVITY_TRANSACTION：
ActivityManagerService.startActivity（）;
--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)
--startActivityUncheckedLocked(r, sourceRecord,grantedUriPermissions, grantedMode, onlyIfNeeded,true)
在这个方法里面检查权限，解析intent中的Flag。。。
--startActivityLocked(HistoryRecord r, boolean newTask)
--resumeTopActivityLocked(HistoryRecord prev)
--startSpecificActivityLocked(HistoryRecord r,boolean andResume, boolean checkConfig)
--startProcessLocked(String processName,ApplicationInfo info, boolean knownToBeDead, int intentFlags,String hostingType, ComponentName hostingName)
--startProcessLocked(ProcessRecord app,String hostingType, String hostingNameStr)
在这里启动一个进程用来host这个应用
int pid = Process.start("android.app.ActivityThread",
mSimpleProcessManagement ? app.processName : null, uid, uid,
gids, debugFlags, null);
ActivityManagerService.java
--startSpecificActivityLocked(HistoryRecord r,boolean andResume, boolean checkConfig)
--realStartActivityLocked(HistoryRecord r,ProcessRecord app, boolean andResume, boolean checkConfig)
--app.thread.scheduleLaunchActivity //scheduleLaunchActivity()@IApplicationThread.java
--scheduleLaunchActivity()@ActivityThread.java //这里实际是ApplicationThreadNative提供的服务
--handleMessage()@H$ActivityThread.java
--handleLaunchActivity()@ActivityThread.java
--Activity performLaunchActivity(ActivityRecord r, Intent customIntent)@ActivityThread.java
//这时真正的Activity对象被构造出来
--mInstrumentation.newActivity（） //通过反射构造出Activity对象
--activity.attach（） //初始化Activity，生成一个window对象，设置各种状态等等
--mInstrumentation.callActivityOnCreate(activity, r.state); //调用Activity的onCreate()方法
到这里，我们自己写的activity的onCreate()方法已经被系统调用了，接下来依次回调生命周期方法：
--activity.performStart();
--mInstrumentation.callActivityOnStart(this);
--mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
--mInstrumentation.callActivityOnPostCreate(activity, r.state);
--mActivities.put(r.token, r); //将这个activity入栈
然后就要调用onResume()方法了：
--handleResumeActivity(IBinder token, boolean clearHide, boolean isForward)
--performResumeActivity(token, clearHide);
--r.activity.performResume();
--performRestart()@Activity.java;
--mInstrumentation.callActivityOnRestart(this);
--mInstrumentation.callActivityOnStart(this);
--mInstrumentation.callActivityOnResume(this);
onResume()已经调用完毕，一个activity的逻辑处理结束了，
但是这时候屏幕上还不会显示任何东西，因为View还没有添加进去
--r.window.getDecorView(); //开始把DecorView添加进Window
--wm.addView(decor, l);
至此一个Activity启动结束。
原文
http://blog.csdn.net/jyfllzy/archive/2011/03/12/6245124.aspx
