AMS分析--基于深入理解android（3）

//将待启动的Activity放入栈顶  final void startActivityLocked(ActivityRecord r, boolean newTask,            boolean doResume, boolean keepCurTransition, Bundle options) {        TaskRecord rTask = r.task;        final int taskId = rTask.taskId;        if (taskForIdLocked(taskId) == null || newTask) {// 如果是新任务，则将任务插入到任务列表顶端            insertTaskAtTop(rTask);//将当前task置于顶部            mWindowManager.moveTaskToTop(taskId);        }        TaskRecord task = null;        if (!newTask) {            // If starting in an existing task, find where that is...            boolean startIt = true;            for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {                task = mTaskHistory.get(taskNdx);                /// M: ALPS01315669, fix google KK bug, skip activity if it is finishing like JB @{                boolean findTask = false;                for (int index = task.mActivities.size() - 1; index >=0; --index) {                    ActivityRecord p = task.mActivities.get(index);                    if (p.finishing) {                        continue;                    }                    if (p.task == r.task) {                     //如果不是在新的ActivityTask(也就是TaskRecord)中的话，就找出要运行在的TaskRecord对象                        // Here it is!  Now, if this is not yet visible to the                        // user, then just add it without starting; it will                        // get started when the user navigates back to it.                        if (!startIt) {//默认情况下此处不执行                            if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "                                    + task, new RuntimeException("here").fillInStackTrace());                            task.addActivityToTop(r);                            r.putInHistory();                            /// M: Add for Activity Stack Parser @{                            if (null != mStackListener){                                mStackListener.dumpStack(mTaskHistory);                            }                            /// @}                            mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,                                    r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,                                    (r.info.flags & ActivityInfo.FLAG_SHOW_ON_LOCK_SCREEN) != 0,                                    r.userId, r.info.configChanges);                            if (VALIDATE_TOKENS) {                                validateAppTokensLocked();                            }                            ActivityOptions.abort(options);                            return;                        }                        findTask = true;                        break;                    } else if (p.fullscreen) {                        startIt = false;                    }                }                if (findTask) {                    break;                }                /// @}            }

if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {            mStackSupervisor.mUserLeaving = false;//当用户按Home键等操作使程序进入后台时 就会根据mUserLeaving=true，             //调用onUserLeaveHint(),            //onUserLeaveHint            //这个回调函数主要用来监听按Home键退出到桌面的动作，发生在onPause之前。在启动一个新的Activity时，             //ActivityStackSupervisor里会调用startActivityUncheckedLocked，在它里面会给mUserLeaving赋值。              //mUserLeaving用于指示当前activity退到后台时函数onUserLeaving是否被调用。            //可见，只有当设置了FLAG_ACTIVITY_NO_USER_ACTION标志时mUserLeaving才会为false，            //其他情况下mUserLeaving均为true，也就是onUserLeaveHint会被调用，注释里也说了onUserLeaveHint会在onPause之前被调用。            if (DEBUG_USER_LEAVING) Slog.v(TAG,                    "startActivity() behind front, mUserLeaving=false");        }//http://www.2cto.com/kf/201503/380568.html        task = r.task;

 final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {        if (ActivityManagerService.DEBUG_LOCKSCREEN) mService.logLockScreen("");        // Find the first activity that is not finishing.        ActivityRecord next = topRunningActivityLocked(null);        // Remember how we'll process this pause/resume situation, and ensure        // that the state is reset however we wind up proceeding.        final boolean userLeaving = mStackSupervisor.mUserLeaving;//如果被置位说明这是被闹钟启动的话为true，        //处理FLAG_ACTIVITY_NO_USER_ACTION情况，如果该标志位为1，则表示并非是用户主观意愿启动的Activity        // 具体情况如来电、闹钟事件等，此时mUserLeaving为false        mStackSupervisor.mUserLeaving = false;        if (next == null) {//启动桌面            // There are no more activities!  Let's just start up the            // Launcher...            ActivityOptions.abort(options);            /// M: Power off alarm feature:            /// If mAlarmBoot is TRUE, that means this is alarm boot-up            /// We will skip to resume home activity until the Alarm activity is destroyed. @{            if (PowerOffAlarmUtility.isAlarmBoot()) {                Slog.v(TAG, "Skip to resume home activity!!");                return false;            }            /// @}            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: No more activities go home");            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();            return mStackSupervisor.resumeHomeActivity(prev);        }        next.delayedResume = false;        // If the top activity is the resumed one, nothing to do.        //如果next即是当前需要启动的Activity组件，并且其状态为resumed，则不需要进行任何操作        //,表示当前Activity组件已经处于启动和激活了        //mResumedActivity当前正在显示的Activity        if (mResumedActivity == next && next.state == ActivityState.RESUMED &&                    mStackSupervisor.allResumedActivitiesComplete()) {            // Make sure we have executed any pending transitions, since there            // should be nothing left to do at this point.            mWindowManager.executeAppTransition();            mNoAnimActivities.clear();            ActivityOptions.abort(options);            if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Top activity resumed " + next);            if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();            return false;        }        final TaskRecord nextTask = next.task;        final TaskRecord prevTask = prev != null ? prev.task : null;        if (prevTask != null && prevTask.mOnTopOfHome && prev.finishing && prev.frontOfTask) {            //上一个prev Task 不为null 并且上一个 pre  task 退出时候要启动home，并且 pre Activity已经结束且pre Activity是起始Activity            if (DEBUG_STACK)  mStackSupervisor.validateTopActivitiesLocked();            if (prevTask == nextTask) {//但是这 要启动的Task和pre  task是同一个。                ArrayList<ActivityRecord> activities = prevTask.mActivities;                final int numActivities = activities.size();                for (int activityNdx = 0; activityNdx < numActivities; ++activityNdx) {                    final ActivityRecord r = activities.get(activityNdx);                    // r is usually the same as next, but what if two activities were launched                    // before prev finished?                    if (!r.finishing) {//此时应该这样理解  if (!r.finishing) 要找到要启动activity，因为只有要启动activity没有finishing，                    //一个task 可以有几个起始activity，由于当前要启动的activity 与prev.frontOfTask 不同。所以我们要重新设置frontOfTask                        r.frontOfTask = true;//栈底作为入口 activity                         break;                    }                }             } else if (prevTask != topTask()) {                // This task is going away but it was supposed to return to the home task.                // Now the task above it has to return to the home task instead.                final int taskNdx = mTaskHistory.indexOf(prevTask) + 1;                mTaskHistory.get(taskNdx).mOnTopOfHome = true;//新任务代替返回home task            } else {                if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Launching home next");                return mStackSupervisor.resumeHomeActivity(prev);//启动home            }        } else {            /// M: Fix ALPS01260522            /// If there are some task (must contain pending finishing activity) with mOnTopOfHome above next activity,            /// we should resume home activity @{            boolean needResumeHome = false;            for (int taskIndex = mTaskHistory.size() - 1; taskIndex >= 0; taskIndex--) {                TaskRecord task = mTaskHistory.get(taskIndex);                if (next.task == task || task.mMovingToFront) {//在这种情况下。正在启动的task就是当前task，此时不需要启动home                    break;                } else if (task.mOnTopOfHome) {//若当前mOnTopOfHome = true 表示返回的时候启动home                    Slog.d(TAG, "Find previous pending finishing task with mOnTopOfHome: " + task);                    needResumeHome = true;                    break;                }            }            if (needResumeHome) {                Slog.d(TAG, "resumeTopActivityLocked: Launching home due to previous pending finishing task");                return mStackSupervisor.resumeHomeActivity(prev);            }

if (mService.isSleepingOrShuttingDown()
&& mLastPausedActivity == next
&& mStackSupervisor.allPausedActivitiesComplete()) {
// 如果当前的next是要显示的Activity，而且上次刚暂停的Activity正好也是next，并且系统正要进入关机或者睡眠状态
//说明系统要睡眠。
// Make sure we have executed any pending transitions, since there
// should be nothing left to do at this point.
mWindowManager.executeAppTransition();
mNoAnimActivities.clear();
ActivityOptions.abort(options);
if (DEBUG_STATES) Slog.d(TAG, “resumeTopActivityLocked: Going to sleep and all paused”);
if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
return false;
}

    // Make sure that the user who owns this activity is started.  If not,    // we will just leave it as is because someone should be bringing    // another user's activities to the top of the stack.    if (mService.mStartedUsers.get(next.userId) == null) {//判断当前要resume的Activity所属的userID是否已经起来        Slog.w(TAG, "Skipping resume of top activity " + next                + ": user " + next.userId + " is stopped");        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();        return false;    }    // The activity may be waiting for stop, but that is no longer    // appropriate for it.    mStackSupervisor.mStoppingActivities.remove(next);//next是要马上启动的。所以从mStoppingActivities 移除    mStackSupervisor.mGoingToSleepActivities.remove(next);//同理以上    next.sleeping = false;    mStackSupervisor.mWaitingVisibleActivities.remove(next);

//如果要resume一个Activity，那么必然要清掉mStoppingActivities、mGoingToSleepActivities、mWaitingVisibleActivities列表中该Activity
next.updateOptionsLocked(options);

    if (DEBUG_SWITCH) Slog.v(TAG, "Resuming " + next);    // If we are currently pausing an activity, then don't do anything    // until that is done.    if (!mStackSupervisor.allPausedActivitiesComplete()) {//再暂停完pre Activity之前，我们什么都不做        if (DEBUG_SWITCH || DEBUG_PAUSE || DEBUG_STATES) Slog.v(TAG,                "resumeTopActivityLocked: Skip resume: some activity pausing.");        if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();        return false;    }

boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving);
//前面说了，在调用resumeTopActivityLocked()已经做好了Stack、Task等准备，但是还没pause 前一个Stack中的resumed Activity
//，或者没有pause掉本Stack中resumed activity。此时便进行触发pause操作
//，然后返回，等待pause完成后调用completePauseLocked()–>resumeTopActivityLocked()再次尝试resume，此时便可继续往下执行。
//mStackSupervisor.mUserLeaving的值在过程5中被设置为true，此处取出来赋值给userLeaving
//，表明是用户操作行为(按下返回键，HOME按键等)；无论是true还是false，此处还是再复位一下
//，重新设置为false
if (mResumedActivity != null) {
pausing = true;
startPausingLocked(userLeaving, false);
if (DEBUG_STATES) Slog.d(TAG, “resumeTopActivityLocked: Pausing ” + mResumedActivity);
}
if (pausing) {
if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG,
“resumeTopActivityLocked: Skip resume: need to start pausing”);
// At this point we want to put the upcoming activity’s process
// at the top of the LRU list, since we know we will be needing it
// very soon and it would be a waste to let it get killed if it
// happens to be sitting towards the end.
if (next.app != null && next.app.thread != null) {
// No reason to do full oom adj update here; we’ll let that
// happen whenever it needs to later.
mService.updateLruProcessLocked(next.app, true, null);
//调整进程调度优先级和OOM_Adj
//参考http://blog.csdn.net/yujun411522/article/details/46682687
}
if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
return true;
}

    if (mService.mSleeping && mLastNoHistoryActivity != null &&            !mLastNoHistoryActivity.finishing) {        if (DEBUG_STATES) Slog.d(TAG, "no-history finish of " + mLastNoHistoryActivity +                " on new resume");        requestFinishActivityLocked(mLastNoHistoryActivity.appToken, Activity.RESULT_CANCELED,                null, "no-history", false);//确认 在mLastNoHistoryActivity 列表的Activity都已经被结束        mLastNoHistoryActivity = null;        //例如现在栈情况为：A B C。C通过intent跳转到D，这个intent添加FLAG_ACTIVITY_NO_HISTORY标志        //，则此时界面显示D的内容，但是它并不会压入栈中。如果按返回键，返回到C，栈的情况还是：A B C        //。如果此时D中又跳转到E，栈的情况变为：A B C E，此时按返回键会回到C，因为D根本就没有被压入栈中。    }    if (prev != null && prev != next) {        if (!prev.waitingVisible && next != null && !next.nowVisible) {            prev.waitingVisible = true;            //prev 置位true表示等待 next显示。nowVisible 表示 next要显示            mStackSupervisor.mWaitingVisibleActivities.add(prev);            if (DEBUG_SWITCH) Slog.v(                    TAG, "Resuming top, waiting visible to hide: " + prev);        } else {            // 如果当前Activity已经是可见，所以我们需要立即hide之间的Activity界面以便能够尽快地显示新Activity界面            if (prev.finishing) {                mWindowManager.setAppVisibility(prev.appToken, false);                if (DEBUG_SWITCH) Slog.v(TAG, "Not waiting for visible to hide: "                        + prev + ", waitingVisible="                        + (prev != null ? prev.waitingVisible : null)                        + ", nowVisible=" + next.nowVisible);            } else {                if (DEBUG_SWITCH) Slog.v(TAG, "Previous already visible but still waiting to hide: "                    + prev + ", waitingVisible="                    + (prev != null ? prev.waitingVisible : null)                    + ", nowVisible=" + next.nowVisible);            }        }    }    // Launching this app's activity, make sure the app is no longer    // considered stopped.    //启动新Activity    try {        AppGlobals.getPackageManager().setPackageStoppedState(                next.packageName, false, next.userId); /* TODO: Verify if correct userid */    } catch (RemoteException e1) {    } catch (IllegalArgumentException e) {        Slog.w(TAG, "Failed trying to unstop package "                + next.packageName + ": " + e);    }    //如果pre Activity已经被finish了，那么直接隐藏pre Activity的窗口好了。如果没有被finish呢    //？那就先不管，反正next Activity的窗口肯定会覆盖pre Activity的窗口之上    //。从这个逻辑可以看出一个Activity只有在finish掉时窗口才设为不可见，pause状态窗口是可见的    //，同时也可以知道Activity切换动画是在resume next Activity时启动的。    boolean anim = true;    if (prev != null) {        if (prev.finishing) {            if (DEBUG_TRANSITION) Slog.v(TAG,                    "Prepare close transition: prev=" + prev);            if (mNoAnimActivities.contains(prev)) {//不要钱过度动画                anim = false;                 mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);                //prepareAppTransition 详细看云笔记            } else {                mWindowManager.prepareAppTransition(prev.task == next.task                        ? AppTransition.TRANSIT_ACTIVITY_CLOSE                        : AppTransition.TRANSIT_TASK_CLOSE, false);                //TRANSIT_ACTIVITY_CLOSE：关闭当前活动窗口，恢复同一个task中的上一个窗口                //TRANSIT_TASK_CLOSE：关闭当前活动窗口，回到上一个任务            }            mWindowManager.setAppWillBeHidden(prev.appToken);//pre v的Activity隐藏            mWindowManager.setAppVisibility(prev.appToken, false);        } else {            if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: prev=" + prev);            if (mNoAnimActivities.contains(next)) {                anim = false;                mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);            } else {                mWindowManager.prepareAppTransition(prev.task == next.task                        ? AppTransition.TRANSIT_ACTIVITY_OPEN                        : AppTransition.TRANSIT_TASK_OPEN, false);            }        }        if (false) {            mWindowManager.setAppWillBeHidden(prev.appToken);            mWindowManager.setAppVisibility(prev.appToken, false);        }    } else {        if (DEBUG_TRANSITION) Slog.v(TAG, "Prepare open transition: no previous");        if (mNoAnimActivities.contains(next)) {            anim = false;            mWindowManager.prepareAppTransition(AppTransition.TRANSIT_NONE, false);        } else {            mWindowManager.prepareAppTransition(AppTransition.TRANSIT_ACTIVITY_OPEN, false);            //TRANSIT_ACTIVITY_OPEN：在同一task中在最顶端打开一个窗口        }    }    if (anim) {        next.applyOptionsLocked();//启动动画    } else {        next.clearOptionsLocked();    }

void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// Is this activity’s application already running?
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
//查询是否已经存在满足要求的进程
r.task.stack.setLaunchTime(r);//设置启动时间
//如果该进程存在并且已经向ams注册
if (app != null && app.thread != null) {
try {
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0//FLAG_MULTIPROCESS 可以在多进程运行的话。就不需要
//重新启动进程
|| !”android”.equals(r.info.packageName)) {
// Don’t add this if it is a platform component that is marked
// to run in multiple processes, because this is actually
// part of the framework so doesn’t make sense to track as a
// separate apk in the process.
app.addPackage(r.info.packageName, mService.mProcessStats);
}
realStartActivityLocked(r, app, andResume, checkConfig);//启动这个进程
return;
} catch (RemoteException e) {
Slog.w(TAG, “Exception when starting activity ”
+ r.intent.getComponent().flattenToShortString(), e);
}

        // If a dead object exception was thrown -- fall through to        // restart the application.    }    mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,            "activity", r.intent.getComponent(), false, false, true);}

final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
String hostingType, ComponentName hostingName, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
ProcessRecord app;
if (!isolated) {//是否单独进程
app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
…….
if (app == null) {
//在ActivityManagerService中为新进程创建一个ProcessRecord实例
app = newProcessRecordLocked(info, processName, isolated);
if (app == null) {
Slog.w(TAG, “Failed making new process record for ”
+ processName + “/” + info.uid + ” isolated=” + isolated);
return null;
}
mProcessNames.put(processName, app.uid, app);//添加到进程列表中
if (isolated) {
mIsolatedProcesses.put(app.uid, app);//添加到单独进程列表中
}
} else {
// If this is a new package in the process, add the package to the list
app.addPackage(info.packageName, mProcessStats);
}//添加包名到 当前进程包列表

private final void startProcessLocked(ProcessRecord app,
String hostingType, String hostingNameStr) {
//当app的pid大于0并且pid不是AMS的话，就要把当前pid的进程从mPidsSelfLocked列表中移除，防止重复，因为后面我们还要加入
if (app.pid > 0 && app.pid != MY_PID) {
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.remove(app.pid);
mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
//PROC_START_TIMEOUT_MSG消息，这个消息是AMS用来控制app启动时间的，如果启动超时了就发出效果消息，下面我们会设置这个消息，现在需要取消之前设置的消息，防止干扰。
//接下来的逻辑：
}
app.setPid(0);//pid 置位0
//系统中所有应用进程（同时包括SystemServer）的ProcessRecord信息都保存在mPidsSelfLocked成员中
}

    if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG,            "startProcessLocked removing on hold: " + app);    mProcessesOnHold.remove(app);    //mProcessesOnHold用于保存那些在系统还没有准备好就提前请求启动的ProcessRecord

public static ActivityThread systemMain() {
HardwareRenderer.disable(true);
ActivityThread thread = new ActivityThread();
thread.attach(true);
return thread;
}

public final void installSystemProviders(List<ProviderInfo> providers) {    if (providers != null) {        installContentProviders(mInitialApplication, providers);    }}public int getIntCoreSetting(String key, int defaultValue) {    synchronized (mResourcesManager) {        if (mCoreSettings != null) {            return mCoreSettings.getInt(key, defaultValue);        }        return defaultValue;    }}private static class EventLoggingReporter implements EventLogger.Reporter {    @Override    public void report (int code, Object... list) {        EventLog.writeEvent(code, list);    }}private class DropBoxReporter implements DropBox.Reporter {    private DropBoxManager dropBox;    public DropBoxReporter() {        dropBox = (DropBoxManager) getSystemContext().getSystemService(Context.DROPBOX_SERVICE);    }    @Override    public void addData(String tag, byte[] data, int flags) {        dropBox.addData(tag, data, flags);    }    @Override    public void addText(String tag, String data) {        dropBox.addText(tag, data);    }}public static void main(String[] args) {    /// M: Retrieve the information from AMS @{    if ( args != null && args.length == 4 ) {        if ( args[0].equals("enable") ) {            mEnableAppLaunchLog = true;        }        if ( args[1].equals("true") ) {            mIsUserBuild = true;        }        if ( args[2].equals("true") ) {            mBooted = true;        }        if (args.length >=4 && args[3].equals("true") ) {//Prevention args.length < 4, then exception.            mEnableLooperLog = true;        }        if (!mIsUserBuild) {            Slog.v(TAG, "MAIN-ARGS launch log: " + mEnableAppLaunchLog + ", user build: "                 + mIsUserBuild + ", booted: " + mBooted + ", looper log: " + mEnableLooperLog);        }    }    /// @}    logAppLaunchTime(TAG, "ActivityThread is created"); /// M: It's for debugging App Launch time    SamplingProfilerIntegration.start();    // CloseGuard defaults to true and can be quite spammy.  We    // disable it here, but selectively enable it later (via    // StrictMode) on debug builds, but using DropBox, not logs.    CloseGuard.setEnabled(false);    Environment.initForCurrentUser();    // Set the reporter for event logging in libcore    EventLogger.setReporter(new EventLoggingReporter());    Security.addProvider(new AndroidKeyStoreProvider());    Process.setArgV0("<pre-initialized>");//这只进程名字    Looper.prepareMainLooper();//准备主线程消息循环    ActivityThread thread = new ActivityThread();//创建一个ActivityThread对象    thread.attach(false);    if (sMainThreadHandler == null) {        sMainThreadHandler = thread.getHandler();    }    AsyncTask.init();    if (false) {        Looper.myLooper().setMessageLogging(new                LogPrinter(Log.DEBUG, "ActivityThread"));    }    /// M: ALPS00270724 message history mechanism @{    /// M: for build type revise @{    try {        /// M: Enable/disable ANR mechanism from adb command @{        if ( ENABLE_ALL_ANR_MECHANISM == Settings.System.getInt(mSystemContext.getContentResolver(), Settings.System.ANR_DEBUGGING_MECHANISM, 0)) {        //if(!IS_USER_BUILD){        /// M: for build type revise @}            ANRAppManager mANRAppManager = ANRAppManager.getDefault();            Looper.myLooper().setMessageLogging(mANRAppManager.newMessageLogger(mEnableLooperLog));        }    } catch (Exception e) {        Log.d(TAG, "set ANR debugging mechanism state fair " + e );    }    /// @}    /// M: Enable/disable ANR mechanism from adb command @}    Looper.loop();//主线程循环    throw new RuntimeException("Main thread loop unexpectedly exited");}

                                         UserHandle.myUserId());        //设置DDMS中临时现实的进程名.        RuntimeInit.setApplicationObject(mAppThread.asBinder());        IActivityManager mgr = ActivityManagerNative.getDefault();        try {            logAppLaunchTime(TAG, "attachApplication -> AMS"); /// M: It's for debugging App Launch time            mgr.attachApplication(mAppThread);             //调用AMS的attachApplication，mAppThread为ApplicationThread类型，        //它是应用进程和AMS交互的接口        } catch (RemoteException ex) {            // Ignore        }    } else {        // Don't set application object here -- if the system crashes,        // we can't display an alert, we just want to die die die.        android.ddm.DdmHandleAppName.setAppName("system_process",                                                UserHandle.myUserId());        try {            mInstrumentation = new Instrumentation();            ContextImpl context = new ContextImpl();            context.init(getSystemContext().mPackageInfo, null, this);            Application app = Instrumentation.newApplication(Application.class, context);            mAllApplications.add(app);            mInitialApplication = app;            app.onCreate();        } catch (Exception e) {            throw new RuntimeException(                    "Unable to instantiate Application():" + e.toString(), e);        }    }

private final boolean attachApplicationLocked(IApplicationThread thread,        int pid) {    // Find the application record that is being attached...  either via    // the pid if we are running in multiple processes, or just pull the    // next app record if we are emulating process with anonymous threads.    ProcessRecord app;    if (pid != MY_PID && pid >= 0) {        synchronized (mPidsSelfLocked) {            app = mPidsSelfLocked.get(pid);//根据pid查找对应 processrecord对象        }    } else {        app = null;    }

//如果该应用进程由AMS启动，则它一定在AMS中有对应的processrecord，先创建一个processrecord对象
//，才发命令给zygote.如果此处app==null，则表示AMS没有该进程的记录。需要杀死他
if (app == null) {
Slog.w(TAG, “No pending application record for pid ” + pid
+ ” (IApplicationThread ” + thread + “); dropping process”);
EventLog.writeEvent(EventLogTags.AM_DROP_PROCESS, pid);
if (pid > 0 && pid != MY_PID) {
Process.killProcessQuiet(pid);
} else {//说明是system_server进程。
try {
thread.scheduleExit();
} catch (Exception e) {
// Ignore exceptions.
}
}
return false;
}

    // If this application record is still attached to a previous    // process, clean it up now.   //对象不为空，表示该进程为旧的未被杀死的进程，系统不会重用   //，而是调用 handleAppDiedLocked() 处理.将app之前的各种connect 断开    if (app.thread != null) {        handleAppDiedLocked(app, true, true);    }

    } else {        app = null;    }

//如果该应用进程由AMS启动，则它一定在AMS中有对应的processrecord，先创建一个processrecord对象
//，才发命令给zygote.如果此处app==null，则表示AMS没有该进程的记录。需要杀死他
if (app == null) {
Slog.w(TAG, “No pending application record for pid ” + pid
+ ” (IApplicationThread ” + thread + “); dropping process”);
EventLog.writeEvent(EventLogTags.AM_DROP_PROCESS, pid);
if (pid > 0 && pid != MY_PID) {
Process.killProcessQuiet(pid);
} else {//说明是system_server进程。
try {
thread.scheduleExit();
} catch (Exception e) {
// Ignore exceptions.
}
}
return false;
}

    // If this application record is still attached to a previous    // process, clean it up now.   //对象不为空，表示该进程为旧的未被杀死的进程，系统不会重用   //，而是调用 handleAppDiedLocked() 处理.将app之前的各种connect 断开    if (app.thread != null) {        handleAppDiedLocked(app, true, true);    }    // Tell the process all about itself.    if (localLOGV) Slog.v(            TAG, "Binding process pid " + pid + " to record " + app);    final String processName = app.processName;    try {           /*      创建一个应用进程讣告接收对象。当应用进程退出时，该对象的binderDied将被调      用。这样，AMS就能做相应处理。binderDied函数将在另外一个线程中执行，其内部也会      调用handleAppDiedLocked。假如用户在binderDied被调用之前又启动一个进程，      那么就会出现以上代码中app.thread不为null的情况。这是多线程环境中常出现的      情况，不熟悉多线程编程的读者要仔细体会。      */        AppDeathRecipient adr = new AppDeathRecipient(                app, pid, thread);        thread.asBinder().linkToDeath(adr, 0);        app.deathRecipient = adr;    } catch (RemoteException e) {        app.resetPackageList(mProcessStats);        startProcessLocked(app, "link fail", processName);        return false;    }    EventLog.writeEvent(EventLogTags.AM_PROC_BOUND, app.userId, app.pid, app.processName);     //设置该进程的调度优先级和oom_adj等成员    app.makeActive(thread, mProcessStats);    app.curAdj = app.setAdj = -100;    app.curSchedGroup = app.setSchedGroup = Process.THREAD_GROUP_DEFAULT;    app.forcingToForeground = null;    app.foregroundServices = false;    app.hasShownUi = false;    app.debugging = false;    app.cached = false;       //启动成功，从消息队列中撤销PROC_START_TIMEOUT_MSG消息    mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);

//通过ApplicationThread和应用进程交互，调用其bindApplication函数
thread.bindApplication(processName, appInfo, providers,
app.instrumentationClass, profileFile, profileFd, profileAutoStop,
app.instrumentationArguments, app.instrumentationWatcher,
app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace,
isRestrictedBackupMode || !normalMode, app.persistent,
new Configuration(mConfiguration), app.compat, getCommonServicesLocked(),
mCoreSettingsObserver.getCoreSettingsLocked());
updateLruProcessLocked(app, false, null);
app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis();
} catch (Exception e) {
// Check if a next-broadcast receiver is in this process…
if (!badApp && isPendingBroadcastProcessLocked(pid)) {
try {
didSomething |= sendPendingBroadcastsLocked(app); //发送广播
} catch (Exception e) {
// If the app died trying to launch the receiver we declare it ‘bad’
badApp = true;
}
}

    // Check whether the next backup agent is in this process...    if (!badApp && mBackupTarget != null && mBackupTarget.appInfo.uid == app.uid) {        if (DEBUG_BACKUP) Slog.v(TAG, "New app is backup target, launching agent for " + app);        ensurePackageDexOpt(mBackupTarget.appInfo.packageName);        try {            thread.scheduleCreateBackupAgent(mBackupTarget.appInfo,                    compatibilityInfoForPackageLocked(mBackupTarget.appInfo),                    mBackupTarget.backupMode);            //http://blog.csdn.net/liyuanjinglyj/article/details/46916337 有关备份        } catch (Exception e) {            Slog.w(TAG, "Exception scheduling backup agent creation: ");            e.printStackTrace();        }    }    if (badApp) {        // todo: Also need to kill application to deal with all        // kinds of exceptions.        handleAppDiedLocked(app, false, true);        return false;    }    if (!didSomething) {        updateOomAdjLocked();        //调整进程优先级，didSomething代表以上流程是否启动了其他activity组件。 updateOomAdjLocked根据组件多少        //调整 oom_adj数值。    }    return true;

  设置代表该应用进程的ProcessRecrod对象的一些成员变量，例如用于和应用进程交互的thread对象、进程调度优先级及oom_adj的值等。·  从消息队列中撤销PROC_START_TIMEOUT_MSG。至此，该进程启动成功，但是这一阶段的工作仅针对进程本身（如设置调度优先级，oom_adj等），还没有涉及和Activity启动相关的内容，这部分工作将在第二阶段完成。

private void handleBindApplication(AppBindData data)
{
mBoundApplication = data;
mConfiguration = new Configuration(data.config);
mCompatConfiguration = new Configuration(data.config);

    mProfiler = new Profiler();    mProfiler.profileFile = data.initProfileFile;    mProfiler.profileFd = data.initProfileFd;    mProfiler.autoStopProfiler = data.initAutoStopProfiler;    logAppLaunchTime(TAG, "handleBindApplication is called"); /// M: It's for debugging App Launch time    // send up app name; do this *before* waiting for debugger    Process.setArgV0(data.processName);//设置进程名    android.ddm.DdmHandleAppName.setAppName(data.processName,                                            UserHandle.myUserId());    if (data.persistent) {        // Persistent processes on low-memory devices do not get to        // use hardware accelerated drawing, since this can add too much        // overhead to the process.        if (!ActivityManager.isHighEndGfx()) {            HardwareRenderer.disable(false);//低内存禁止使用硬件加速        }    }    //启动性能统计    if (mProfiler.profileFd != null) {        mProfiler.startProfiling();    }    // If the app is Honeycomb MR1 or earlier, switch its AsyncTask    // implementation to use the pool executor.  Normally, we use the    // serialized executor as the default. This has to happen in the    // main thread so the main looper is set right.    if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {        AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);    }    /*     * Before spawning a new process, reset the time zone to be the system time zone.     * This needs to be done because the system time zone could have changed after the     * the spawning of this process. Without doing this this process would have the incorrect     * system time zone.     */     //设置 TimeZone    TimeZone.setDefault(null);    /*     * Initialize the default locale in this process for the reasons we set the time zone.     */    Locale.setDefault(data.config.locale);    /*     * Update the system configuration since its preloaded and might not     * reflect configuration changes. The configuration object passed     * in AppBindData can be safely assumed to be up to date     */    mResourcesManager.applyConfigurationToResourcesLocked(data.config, data.compatInfo);    mCurDefaultDisplayDpi = data.config.densityDpi;    applyCompatConfiguration(mCurDefaultDisplayDpi);    data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);    /**     * Switch this process to density compatibility mode if needed.     */      //如果没有设置屏幕密度，则为DENSITY_DEFAULT设置默认的屏幕密度    if ((data.appInfo.flags&ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES)            == 0) {        mDensityCompatMode = true;        Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);    }    updateDefaultDensity();    final ContextImpl appContext = new ContextImpl();    appContext.init(data.info, null, this);    if (!Process.isIsolated()) {        final File cacheDir = appContext.getCacheDir();        if (cacheDir != null) {            // Provide a usable directory for temporary files            System.setProperty("java.io.tmpdir", cacheDir.getAbsolutePath());            setupGraphicsSupport(data.info, cacheDir);        } else {            Log.e(TAG, "Unable to setupGraphicsSupport due to missing cache directory");        }    }    /**     * For system applications on userdebug/eng builds, log stack     * traces of disk and network access to dropbox for analysis.     */    if ((data.appInfo.flags &         (ApplicationInfo.FLAG_SYSTEM |          ApplicationInfo.FLAG_UPDATED_SYSTEM_APP)) != 0) {        StrictMode.conditionallyEnableDebugLogging();    }    /**     * For apps targetting SDK Honeycomb or later, we don't allow     * network usage on the main event loop / UI thread.     *     * Note to those grepping:  this is what ultimately throws     * NetworkOnMainThreadException ...     */    if (data.appInfo.targetSdkVersion > 9) {        StrictMode.enableDeathOnNetwork();    }    if (data.debugMode != IApplicationThread.DEBUG_OFF) {        // XXX should have option to change the port.        Debug.changeDebugPort(8100);        if (data.debugMode == IApplicationThread.DEBUG_WAIT) {            Slog.w(TAG, "Application " + data.info.getPackageName()                  + " is waiting for the debugger on port 8100...");            IActivityManager mgr = ActivityManagerNative.getDefault();            try {                mgr.showWaitingForDebugger(mAppThread, true);            } catch (RemoteException ex) {            }            Debug.waitForDebugger();            try {                mgr.showWaitingForDebugger(mAppThread, false);            } catch (RemoteException ex) {            }        } else {            Slog.w(TAG, "Application " + data.info.getPackageName()                  + " can be debugged on port 8100...");        }    }    // Enable OpenGL tracing if required    if (data.enableOpenGlTrace) {        GLUtils.setTracingLevel(1);    }    // Allow application-generated systrace messages if we're debuggable.    boolean appTracingAllowed = (data.appInfo.flags&ApplicationInfo.FLAG_DEBUGGABLE) != 0;    Trace.setAppTracingAllowed(appTracingAllowed);    /**     * Initialize the default http proxy in this process for the reasons we set the time zone.     */    IBinder b = ServiceManager.getService(Context.CONNECTIVITY_SERVICE);    if (b != null) {        // In pre-boot mode (doing initial launch to collect password), not        // all system is up.  This includes the connectivity service, so don't        // crash if we can't get it.        IConnectivityManager service = IConnectivityManager.Stub.asInterface(b);        try {            ProxyProperties proxyProperties = service.getProxy();            Proxy.setHttpProxySystemProperty(proxyProperties);        } catch (RemoteException e) {}    }    if (data.instrumentationName != null) {        InstrumentationInfo ii = null;        try {            ii = appContext.getPackageManager().                getInstrumentationInfo(data.instrumentationName, 0);        } catch (PackageManager.NameNotFoundException e) {        }        if (ii == null) {            throw new RuntimeException(                "Unable to find instrumentation info for: "                + data.instrumentationName);        }        mInstrumentationAppDir = ii.sourceDir;        mInstrumentationAppLibraryDir = ii.nativeLibraryDir;        mInstrumentationAppPackage = ii.packageName;        mInstrumentedAppDir = data.info.getAppDir();        mInstrumentedAppLibraryDir = data.info.getLibDir();        ApplicationInfo instrApp = new ApplicationInfo();        instrApp.packageName = ii.packageName;        instrApp.sourceDir = ii.sourceDir;        instrApp.publicSourceDir = ii.publicSourceDir;        instrApp.dataDir = ii.dataDir;        instrApp.nativeLibraryDir = ii.nativeLibraryDir;        LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,                appContext.getClassLoader(), false, true);        ContextImpl instrContext = new ContextImpl();        instrContext.init(pi, null, this);        try {            java.lang.ClassLoader cl = instrContext.getClassLoader();            mInstrumentation = (Instrumentation)                cl.loadClass(data.instrumentationName.getClassName()).newInstance();        } catch (Exception e) {            throw new RuntimeException(                "Unable to instantiate instrumentation "                + data.instrumentationName + ": " + e.toString(), e);        }        mInstrumentation.init(this, instrContext, appContext,               new ComponentName(ii.packageName, ii.name), data.instrumentationWatcher,               data.instrumentationUiAutomationConnection);        if (mProfiler.profileFile != null && !ii.handleProfiling                && mProfiler.profileFd == null) {            mProfiler.handlingProfiling = true;            File file = new File(mProfiler.profileFile);            file.getParentFile().mkdirs();            Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);        }    } else {     //创建Instrumentation对象，在正常情况都再这个条件下执行        mInstrumentation = new Instrumentation();    }     //如果Package中声明了FLAG_LARGE_HEAP，则可跳过虚拟机的内存限制，放心使用内存    if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {        dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();    }    // Allow disk access during application and provider setup. This could    // block processing ordered broadcasts, but later processing would    // probably end up doing the same disk access.    final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();    try {        // If the app is being launched for full backup or restore, bring it up in        // a restricted environment with the base application class.         //创建一个Application，data.info为LoadedApk类型，在其内部会通过Java反射机制         //创建一个在该APK AndroidManifest.xml中声明的Application对象        Application app = data.info.makeApplication(data.restrictedBackupMode, null);        mInitialApplication = app;         //mInitialApplication保存该进程中第一个创建的Application        // don't bring up providers in restricted mode; they may depend on the        // app's custom Application class         //安装本Package中携带的ContentProvider        if (!data.restrictedBackupMode) {            List<ProviderInfo> providers = data.providers;            if (providers != null) {                installContentProviders(app, providers);                // For process that contains content providers, we want to                // ensure that the JIT is enabled "at some point".                mH.sendEmptyMessageDelayed(H.ENABLE_JIT, 10*1000);            }        }        // Do this after providers, since instrumentation tests generally start their        // test thread at this point, and we don't want that racing.        try {            mInstrumentation.onCreate(data.instrumentationArgs);        }        catch (Exception e) {            throw new RuntimeException(                "Exception thrown in onCreate() of "                + data.instrumentationName + ": " + e.toString(), e);        }        try {            //调用Application的onCreate函数，做一些初始工作            mInstrumentation.callApplicationOnCreate(app);        } catch (Exception e) {            if (!mInstrumentation.onException(app, e)) {                throw new RuntimeException(                    "Unable to create application " + app.getClass().getName()                    + ": " + e.toString(), e);            }        }    } finally {        StrictMode.setThreadPolicy(savedPolicy);    }}

由以上代码可知，bindApplication函数将设置一些初始化参数，其中最重要的有：·  创建一个Application对象，该对象是本进程中运行的第一个Application。·  如果该Application有ContentProvider，则应安装它们。提示从以上代码可知，ContentProvider的创建就在bindApplication函数中，其时机早于其他组件的创建。·  在应用进程启动后，需要尽快调用AMS的attachApplication函数，该函数是这个刚呱呱坠地的应用进程第一次和AMS交互。此时的它还默默“无名”，连一个确定的进程名都没有。不过没关系，attachApplication函数将根据创建该应用进程之前所保存的ProcessRecord为其准备一切“手续”。·  attachApplication准备好一切后，将调用应用进程的bindApplication函数，在该函数内部将发消息给主线程，最终该消息由handleBindApplication处理。handleBindApplication将为该进程设置进程名，初始化一些策略和参数信息等。另外，它还创建一个Application对象。同时，如果该Application声明了ContentProvider，还需要为该进程安装ContentProvider。提示这个流程有点类似生孩子，一般生之前需要到医院去登记，生完后又需去注册户口，如此这般，这个孩子才会在社会有合法的身份。

boolean attachApplicationLocked(ProcessRecord app, boolean headless) throws Exception {
boolean didSomething = false;
final String processName = app.processName;
for (int stackNdx = mStacks.size() - 1; stackNdx >= 0; –stackNdx) {
final ActivityStack stack = mStacks.get(stackNdx);
if (!isFrontStack(stack)) {//不是焦点stack
continue;
}//找到焦点stack
ActivityRecord hr = stack.topRunningActivityLocked(null);
if (hr != null) {
if (hr.app == null && app.uid == hr.info.applicationInfo.uid
&& processName.equals(hr.processName)) {
try {
if (headless) {
Slog.e(TAG, “Starting activities not supported on headless device: ”
+ hr);
} else if (realStartActivityLocked(hr, app, true, true)) {
//通知该进程中的启动目标Activity
didSomething = true;
}
} catch (Exception e) {
Slog.w(TAG, “Exception in new application when starting activity ”
+ hr.intent.getComponent().flattenToShortString(), e);
throw e;
}
}
}
}
if (!didSomething) {
ensureActivitiesVisibleLocked(null, 0);
}
return didSomething;
}

“`