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) {
	      ...
	    }
	    ...
    }
    ...
}