第一步Launcher.startActivitySafely()
說明：在Android系統中，應用程序是由Launcher啟動起來的，其實，Launcher本身也是一個應用程序，其它的應用程序安裝后，就會Launcher的界面上出現一個相應的圖標，點擊這個圖標時，Launcher就會對應的應用程序啟動起來。
/**
* Default launcher application.
*/
public final class Launcher extends Activity
implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
......
/**
* Launches the intent referred by the clicked shortcut.
*
* @param v The view representing the clicked shortcut.
*/
public void onClick(View v) {
Object tag = v.getTag();
if (tag instanceof ShortcutInfo) {
// Open shortcut
final Intent intent = ((ShortcutInfo) tag).intent;
int[] pos = new int[2];
v.getLocationOnScreen(pos);
intent.setSourceBounds(new Rect(pos[0], pos[1],
pos[0] + v.getWidth(), pos[1] + v.getHeight()));
startActivitySafely(intent, tag);
} else if (tag instanceof FolderInfo) {
......
} else if (v == mHandleView) {
......
}
}
void startActivitySafely(Intent intent, Object tag) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivity(intent);
} catch (ActivityNotFoundException e) {
......
} catch (SecurityException e) {
......
}
}
......
}
第二步：Activity.startActivity()
public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks {
......
@Override
public void startActivity(Intent intent) {
startActivityForResult(intent, -1);
}
......
}
第三步：Activtiy.startActivityForResult()
說明：
(1)mMainThread也是Activity類的成員變量，它的類型是ActivityThread，它代表的是應用程序的主線程。
(2)通過mMainThread.getApplicationThread獲得它里面的ApplicationThread成員變量，它是一個Binder對象，后面我們會看到，ActivityManagerService會使用它來和ActivityThread來進行進程間通信。
(3)這里的mMainThread代表的是Launcher應用程序運行的進程。
(4)mToken也是Activity類的成員變量，它是一個Binder對象的遠程接口。
public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks {
......
public void startActivityForResult(Intent intent, int requestCode) {
if (mParent == null) {
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode);
......
} else {
......
}
......
}
第四步：Instrumentation.execStartActivity()
(1)Intent.resolveTypeIfNeeded返回這個intent的MIME類型
(2)Instrumentation.checkStartActivityResult()：檢查啟動Activity的結果，會拋出各種異常，如Activity沒有注冊。
(3)ActivityManagetNative：繼承IActivityManager接口；相當于Stub(運行在SystemServer進程)
ActivityManagerService：實現了ActivityManagetNative抽象類
ActivityManagerNative.getDefault()：返回ActivityMangerProxy；相當于Proxy(運行在應用程序進程)
public class Instrumentation {
......
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
......
}
try {
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
null, 0, token, target != null ? target.mEmbeddedID : null,
requestCode, false, false);
......
} catch (RemoteException e) {
}
return null;
}
......
}
第五步：ActivityManagerNative.getDefalut.startActivity()
參數grantedUriPermissions和resultWho均為null；
參數caller為ApplicationThread類型的Binder實體；
參數resultTo為一個Binder實體的遠程接口，我們先不關注它；
參數grantedMode為0，我們也先不關注它；
參數requestCode為-1；
參數onlyIfNeeded和debug均空false。
class ActivityManagerProxy implements IActivityManager
{
......
public int startActivity(IApplicationThread caller, Intent intent,
String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
IBinder resultTo, String resultWho,
int requestCode, boolean onlyIfNeeded,
boolean debug) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
intent.writeToParcel(data, 0);
data.writeString(resolvedType);
data.writeTypedArray(grantedUriPermissions, 0);
data.writeInt(grantedMode);
data.writeStrongBinder(resultTo);
data.writeString(resultWho);
data.writeInt(requestCode);
data.writeInt(onlyIfNeeded ? 1 : 0);
data.writeInt(debug ? 1 : 0);
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
......
}
ActivityManagerProxy和ActivityManagerNative
public abstract class ActivityManagerNative extends Binder implements IActivityManager
{
//從類聲明上，我們可以看到ActivityManagerNative是Binder的一個子類，而且實現了IActivityManager接口
static public IActivityManager getDefault() {
return gDefault.get();
}
//通過單例模式獲取一個IActivityManager對象，這個對象通過asInterface(b)獲得
private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
IBinder b = ServiceManager.getService("activity");
if (false) {
Log.v("ActivityManager", "default service binder = " + b);
}
IActivityManager am = asInterface(b);
if (false) {
Log.v("ActivityManager", "default service = " + am);
}
return am;
}
};
}
//最終返回的還是一個ActivityManagerProxy對象
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}
//這里面的Binder類型的obj參數會作為ActivityManagerProxy的成員變量保存為mRemote成員變量，負責進行IPC通信
return new ActivityManagerProxy(obj);
}
第六步：ActivityManagerService.startActivity()
(1)將操作轉發給成員變量mMainStack的startActivityMayWait函數，這里的mMainStack的類型為ActivityStack。
public final class ActivityManagerService extends ActivityManagerNative
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
......
public final int startActivity(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded,
boolean debug) {
return mMainStack.startActivityMayWait(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, resultTo, resultWho,
requestCode, onlyIfNeeded, debug, null, null);
}
......
}
第七步： ActivityStack.startActivityMayWait()
public class ActivityStack {
......
final int startActivityMayWait(IApplicationThread caller,
Intent intent, String resolvedType, Uri[] grantedUriPermissions,
int grantedMode, IBinder resultTo,
String resultWho, int requestCode, boolean onlyIfNeeded,
boolean debug, WaitResult outResult, Configuration config) {
......
boolean componentSpecified = intent.getComponent() != null;
// Don't modify the client's object!
intent = new Intent(intent);
// Collect information about the target of the Intent.
ActivityInfo aInfo;
try {
ResolveInfo rInfo =
AppGlobals.getPackageManager().resolveIntent(
intent, resolvedType,
PackageManager.MATCH_DEFAULT_ONLY
| ActivityManagerService.STOCK_PM_FLAGS);
aInfo = rInfo != null ? rInfo.activityInfo : null;
} catch (RemoteException e) {
......
}
if (aInfo != null) {
// Store the found target back into the intent, because now that
// we have it we never want to do this again. For example, if the
// user navigates back to this point in the history, we should
// always restart the exact same activity.
intent.setComponent(new ComponentName(
aInfo.applicationInfo.packageName, aInfo.name));
......
}
synchronized (mService) {
int callingPid;
int callingUid;
if (caller == null) {
......
} else {
callingPid = callingUid = -1;
}
mConfigWillChange = config != null
&& mService.mConfiguration.diff(config) != 0;
......
if (mMainStack && aInfo != null &&
(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
......
}
int res = startActivityLocked(caller, intent, resolvedType,
grantedUriPermissions, grantedMode, aInfo,
resultTo, resultWho, requestCode, callingPid, callingUid,
onlyIfNeeded, componentSpecified);
if (mConfigWillChange && mMainStack) {
......
}
......
if (outResult != null) {
......
}
return res;
}
}
......
}
第六步：在ActivityStack和ActivitySupervisior之間來回調用方法
第七步：ActivityStackSupervisor.realStartActivityLocked()
第八步：AppliactionThreadProxy.scheduleLauchActivity()(SystemServer進程+Binder通信過程)
過程：通過Handler H發送一條消息給 H處理。
說明：
AppliactionThread：繼承AppliactionThreadNative；ActivityThread的內部類，負責ActivityThread和AMS之間的通信;相當于Stub實現類
ApplicationThreadProxy：實現IApplicationThread；相當于Proxy;
AAppliactionThreadNative：相當于Stub；實現IApplicationThread。
第九步：ActivityThread.handleLaunchActivity()
過程：調用ActivityThread.performLauchActivity()
第十步：ActivityThread.performLauchActivity()
(1)從ActivityClientRecord中獲取待啟動的Activity的組件信息
(2)通過Instrumentation的newActivity方法使用類加載器創建Activity對象
(3)通過LoadedApk的makeApplication方法來嘗試創建Application對象。
(4)創建ContextImpl對象，并通過Activity的attach方法來完成一些重要數據的初始化。
(5)調用Activity的onCreate方法
總結
一. Launcher通過Binder進程間通信機制通知ActivityManagerService，它要啟動一個Activity；
二. ActivityManagerService通過Binder進程間通信機制通知Launcher進入Paused狀態；
三. Launcher通過Binder進程間通信機制通知ActivityManagerService，它已經準備就緒進入Paused狀態，于是ActivityManagerService就創建一個新的進程，用來啟動一個ActivityThread實例，即將要啟動的Activity就是在這個ActivityThread實例中運行；
四. ActivityThread通過Binder進程間通信機制將一個ApplicationThread類型的Binder對象傳遞給ActivityManagerService，以便以后ActivityManagerService能夠通過這個Binder對象和它進行通信；
五. ActivityManagerService通過Binder進程間通信機制通知ActivityThread，現在一切準備就緒，它可以真正執行Activity的啟動操作了。
