分析Android中应用的启动流程

public class Launcher extends Activity  implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks,     View.OnTouchListener, PageSwitchListener, LauncherProviderChangeListener { ... /**  * Launches the intent referred by the clicked shortcut.  *  * @param v The view representing the clicked shortcut.  */ public void onClick(View v) {  // Make sure that rogue clicks don't get through while allapps is launching, or after the  // view has detached (it's possible for this to happen if the view is removed mid touch).  if (v.getWindowToken() == null) {   return;  }  ...  Object tag = v.getTag();  if (tag instanceof ShortcutInfo) {   onClickAppShortcut(v);  } else if (tag instanceof FolderInfo) {   ...  } else if (v == mAllAppsButton) {   onClickAllAppsButton(v);  } else if (tag instanceof AppInfo) {   startAppShortcutOrInfoActivity(v);  } else if (tag instanceof LauncherAppWidgetInfo) {   ...  } }  private void startAppShortcutOrInfoActivity(View v) {  ...  boolean success = startActivitySafely(v, intent, tag);  ... }  boolean startActivitySafely(View v, Intent intent, Object tag) {  ...  try {   success = startActivity(v, intent, tag);  } catch (ActivityNotFoundException e) {   ...  }  return success; }  boolean startActivity(View v, Intent intent, Object tag) {  intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  try {   ...   if (user == null || user.equals(UserHandleCompat.myUserHandle())) {    // Could be launching some bookkeeping activity    startActivity(intent, optsBundle);   } else {    ...   }   return true;  } catch (SecurityException e) {   ...  }  return false; }}

public class Instrumentation { ... public ActivityResult execStartActivity(   Context who, IBinder contextThread, IBinder token, Activity target,   Intent intent, int requestCode, Bundle options) {  IApplicationThread whoThread = (IApplicationThread) contextThread;  ...  try {   ...   int result = ActivityManagerNative.getDefault()    .startActivity(whoThread, who.getBasePackageName(), intent,      intent.resolveTypeIfNeeded(who.getContentResolver()),      token, target != null ? target.mEmbeddedID : null,      requestCode, 0, null, options);   ...  } catch (RemoteException e) {  }  return null; } ...}

public final class ActivityStackSupervisor implements DisplayListener { ... final int startActivityUncheckedLocked(ActivityRecord r, ActivityRecord sourceRecord,   IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,  int startFlags, boolean doResume, Bundle options, TaskRecord inTask) { final Intent intent = r.intent; final int callingUid = r.launchedFromUid; ... final boolean launchSingleTop = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP; final boolean launchSingleInstance = r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE; final boolean launchSingleTask = r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK;  int launchFlags = intent.getFlags(); ... // We'll invoke onUserLeaving before onPause only if the launching // activity did not explicitly state that this is an automated launch. mUserLeaving = (launchFlags & Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0; ...      ActivityRecord notTop =    (launchFlags & Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) != 0 ? r : null; // If the onlyIfNeeded flag is set, then we can do this if the activity // being launched is the same as the one making the call... or, as // a special case, if we do not know the caller then we count the // current top activity as the caller. if ((startFlags&ActivityManager.START_FLAG_ONLY_IF_NEEDED) != 0) { ... }   ...   // If the caller is not coming from another activity, but has given us an // explicit task into which they would like us to launch the new activity, // then let's see about doing that. if (sourceRecord == null && inTask != null && inTask.stack != null) { final Intent baseIntent = inTask.getBaseIntent(); final ActivityRecord root = inTask.getRootActivity(); ... // If this task is empty, then we are adding the first activity -- it // determines the root, and must be launching as a NEW_TASK. if (launchSingleInstance || launchSingleTask) { ... } ... }   ...   if (inTask == null) { if (sourceRecord == null) { // This activity is not being started from another... in this // case we -always- start a new task. if ((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) == 0 && inTask == null) {  Slog.w(TAG, "startActivity called from non-Activity context; forcing " +       "Intent.FLAG_ACTIVITY_NEW_TASK for: " + intent);  launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; } } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { // The original activity who is starting us is running as a single // instance... this new activity it is starting must go on its // own task. launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; } else if (launchSingleInstance || launchSingleTask) { // The activity being started is a single instance... it always // gets launched into its own task. launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; } }    ...      // We may want to try to place the new activity in to an existing task. We always // do this if the target activity is singleTask or singleInstance; we will also do // this if NEW_TASK has been requested, and there is not an additional qualifier telling // us to still place it in a new task: multi task, always doc mode, or being asked to // launch this as a new task behind the current one. if (((launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&    (launchFlags & Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)    || launchSingleInstance || launchSingleTask) { // If bring to front is requested, and no result is requested and we have not // been given an explicit task to launch in to, and // we can find a task that was started with this same // component, then instead of launching bring that one to the front. if (inTask == null && r.resultTo == null) { // See if there is a task to bring to the front. If this is // a SINGLE_INSTANCE activity, there can be one and only one // instance of it in the history, and it is always in its own // unique task, so we do a special search. ActivityRecord intentActivity = !launchSingleInstance ?  findTaskLocked(r) : findActivityLocked(intent, r.info); if (intentActivity != null) {  ... } } }   ...      if (r.packageName != null) {   // If the activity being launched is the same as the one currently   // at the top, then we need to check if it should only be launched   // once.   ActivityStack topStack = getFocusedStack();   ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(notTop);   if (top != null && r.resultTo == null) {    if (top.realActivity.equals(r.realActivity) && top.userId == r.userId) {     ...    }   }   } else{   ...   }   boolean newTask = false; boolean keepCurTransition = false; TaskRecord taskToAffiliate = launchTaskBehind && sourceRecord != null ?    sourceRecord.task : null; // Should this be considered a new task? if (r.resultTo == null && inTask == null && !addingToTask    && (launchFlags & Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { ... if (reuseTask == null) {    r.setTask(targetStack.createTaskRecord(getNextTaskId(),      newTaskInfo != null ? newTaskInfo : r.info,      newTaskIntent != null ? newTaskIntent : intent,      voiceSession, voiceInteractor, !launchTaskBehind /* toTop */),      taskToAffiliate);    ...   } else {    r.setTask(reuseTask, taskToAffiliate);   }    ... } else if (sourceRecord != null) {    } else if (!addingToTask &&     (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) {       } else if (inTask != null){    } else {    }   ...   targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options);    ...   return ActivityManager.START_SUCCESS; } ...}

final class ActivityStack { ... final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,   boolean dontWait) { if (mPausingActivity != null) {  ... }  ActivityRecord prev = mResumedActivity; if (prev == null) {  ... } ... mResumedActivity = null; mPausingActivity = prev; mLastPausedActivity = prev; mLastNoHistoryActivity = (prev.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_HISTORY) != 0    || (prev.info.flags & ActivityInfo.FLAG_NO_HISTORY) != 0 ? prev : null; prev.state = ActivityState.PAUSING; ...  if (prev.app != null && prev.app.thread != null) {  try { ... prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,      userLeaving, prev.configChangeFlags, dontWait);  } catch (Exception e) { ...  } } else {  ... } ... } ...}

public final class ActivityThread { ... private void handlePauseActivity(IBinder token, boolean finished,   boolean userLeaving, int configChanges, boolean dontReport) {  ActivityClientRecord r = mActivities.get(token);  if (r != null) {   ...   performPauseActivity(token, finished, r.isPreHoneycomb());   // Make sure any pending writes are now committed.   if (r.isPreHoneycomb()) {    QueuedWork.waitToFinish();   }   // Tell the activity manager we have paused.   if (!dontReport) {    try {     ActivityManagerNative.getDefault().activityPaused(token);    } catch (RemoteException ex) {    }   }   ...  } } ...}

public final class ActivityManagerService extends ActivityManagerNative  implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { ... private final void startProcessLocked(ProcessRecord app, String hostingType, String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) { ... try {  ...  // Start the process. It will either succeed and return a result containing  // the PID of the new process, or else throw a RuntimeException.  boolean isActivityProcess = (entryPoint == null);  if (entryPoint == null) entryPoint = "android.app.ActivityThread";  Process.ProcessStartResult startResult = Process.start(entryPoint,     app.processName, uid, uid, gids, debugFlags, mountExternal,     app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet,     app.info.dataDir, entryPointArgs);  ... } catch () {  ... } } ...}

public final class ActivityThread { ... public static void main(String[] args) {  ...  Looper.prepareMainLooper();  ActivityThread thread = new ActivityThread();  thread.attach(false);  ...  Looper.loop();    ... }  private void attach(boolean system) {  ...  if (!system) {   ...   final IActivityManager mgr = ActivityManagerNative.getDefault();   try {    mgr.attachApplication(mAppThread);   } catch (RemoteException ex) {    // Ignore   }  } else {   ...  }  ... } ...}

public final class ActivityStackSupervisor implements DisplayListener { ... final boolean realStartActivityLocked(ActivityRecord r,   ProcessRecord app, boolean andResume, boolean checkConfig)   throws RemoteException {  ...  r.app = app;  ...     try {  ...  app.thread.scheduleLaunchActivity(new Intent(r.intent), r.appToken,     System.identityHashCode(r), r.info, new Configuration(mService.mConfiguration),     r.compat, r.launchedFromPackage, r.task.voiceInteractor, app.repProcState,     r.icicle, r.persistentState, results, newIntents, !andResume,     mService.isNextTransitionForward(), profilerInfo);  ...  } catch (RemoteException e) {  ...  }  ... } ...}