Android应用程序启动过程源代码分析

前文简要介绍了Android应用程序的Activity的启动过程。在Android系统中，应用程序是由Activity组成的，因此，应用程序的启动过程实际上就是应用程序中的默认Activity的启动过程，本文将详细分析应用程序框架层的源代码，了解Android应用程序的启动过程。

        在上一篇文章Android应用程序的Activity启动过程简要介绍和学习计划中，我们举例子说明了启动Android应用程序中的Activity的两种情景，其中，在手机屏幕中点击应用程序图标的情景就会引发Android应用程序中的默认Activity的启动，从而把应用程序启动起来。这种启动方式的特点是会启动一个新的进程来加载相应的Activity。这里，我们继续以这个例子为例来说明Android应用程序的启动过程，即MainActivity的启动过程。

        MainActivity的启动过程如下图所示：

Android应用程序启动过程源代码分析_第1张图片

点击查看大图

        下面详细分析每一步是如何实现的。

        Step 1. Launcher.startActivitySafely

        在Android系统中，应用程序是由Launcher启动起来的，其实，Launcher本身也是一个应用程序，其它的应用程序安装后，就会Launcher的界面上出现一个相应的图标，点击这个图标时，Launcher就会对应的应用程序启动起来。

        Launcher的源代码工程在packages/apps/Launcher2目录下，负责启动其它应用程序的源代码实现在src/com/android/launcher2/Launcher.java文件中：

[java]  view plain copy
  1. /** 
  2. * Default launcher application. 
  3. */  
  4. public final class Launcher extends Activity  
  5.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
  6.   
  7.     ......  
  8.   
  9.     /** 
  10.     * Launches the intent referred by the clicked shortcut. 
  11.     * 
  12.     * @param v The view representing the clicked shortcut. 
  13.     */  
  14.     public void onClick(View v) {  
  15.         Object tag = v.getTag();  
  16.         if (tag instanceof ShortcutInfo) {  
  17.             // Open shortcut  
  18.             final Intent intent = ((ShortcutInfo) tag).intent;  
  19.             int[] pos = new int[2];  
  20.             v.getLocationOnScreen(pos);  
  21.             intent.setSourceBounds(new Rect(pos[0], pos[1],  
  22.                 pos[0] + v.getWidth(), pos[1] + v.getHeight()));  
  23.             startActivitySafely(intent, tag);  
  24.         } else if (tag instanceof FolderInfo) {  
  25.             ......  
  26.         } else if (v == mHandleView) {  
  27.             ......  
  28.         }  
  29.     }  
  30.   
  31.     void startActivitySafely(Intent intent, Object tag) {  
  32.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
  33.         try {  
  34.             startActivity(intent);  
  35.         } catch (ActivityNotFoundException e) {  
  36.             ......  
  37.         } catch (SecurityException e) {  
  38.             ......  
  39.         }  
  40.     }  
  41.   
  42.     ......  
  43.   
  44. }  
        回忆一下前面一篇文章 Android应用程序的Activity启动过程简要介绍和学习计划 说到的应用程序Activity，它的默认Activity是MainActivity，这里是AndroidManifest.xml文件中配置的：

[html]  view plain copy
  1. <activity android:name=".MainActivity"    
  2.       android:label="@string/app_name">    
  3.        <intent-filter>    
  4.         <action android:name="android.intent.action.MAIN" />    
  5.         <category android:name="android.intent.category.LAUNCHER" />    
  6.     </intent-filter>    
  7. </activity>    
        因此，这里的intent包含的信息为：action = "android.intent.action.Main"，category="android.intent.category.LAUNCHER", cmp="shy.luo.activity/.MainActivity"，表示它要启动的Activity为shy.luo.activity.MainActivity。Intent.FLAG_ACTIVITY_NEW_TASK表示要在一个新的Task中启动这个Activity，注意，Task是Android系统中的概念，它不同于进程Process的概念。简单地说，一个Task是一系列Activity的集合，这个集合是以堆栈的形式来组织的，遵循后进先出的原则。事实上，Task是一个非常复杂的概念，有兴趣的读者可以到官网 http://developer.android.com/guide/topics/manifest/activity-element.html 查看相关的资料。这里，我们只要知道，这个MainActivity要在一个新的Task中启动就可以了。

        Step 2. Activity.startActivity

        在Step 1中，我们看到，Launcher继承于Activity类，而Activity类实现了startActivity函数，因此，这里就调用了Activity.startActivity函数，它实现在frameworks/base/core/java/android/app/Activity.java文件中：

[java]  view plain copy
  1. public class Activity extends ContextThemeWrapper  
  2.         implements LayoutInflater.Factory,  
  3.         Window.Callback, KeyEvent.Callback,  
  4.         OnCreateContextMenuListener, ComponentCallbacks {  
  5.   
  6.     ......  
  7.   
  8.     @Override  
  9.     public void startActivity(Intent intent) {  
  10.         startActivityForResult(intent, -1);  
  11.     }  
  12.   
  13.     ......  
  14.   
  15. }  
        这个函数实现很简单，它调用startActivityForResult来进一步处理，第二个参数传入-1表示不需要这个Actvity结束后的返回结果。

        Step 3. Activity.startActivityForResult

        这个函数也是实现在frameworks/base/core/java/android/app/Activity.java文件中：

[java]  view plain copy
  1. public class Activity extends ContextThemeWrapper  
  2.         implements LayoutInflater.Factory,  
  3.         Window.Callback, KeyEvent.Callback,  
  4.         OnCreateContextMenuListener, ComponentCallbacks {  
  5.   
  6.     ......  
  7.   
  8.     public void startActivityForResult(Intent intent, int requestCode) {  
  9.         if (mParent == null) {  
  10.             Instrumentation.ActivityResult ar =  
  11.                 mInstrumentation.execStartActivity(  
  12.                 this, mMainThread.getApplicationThread(), mToken, this,  
  13.                 intent, requestCode);  
  14.             ......  
  15.         } else {  
  16.             ......  
  17.         }  
  18.   
  19.   
  20.     ......  
  21.   
  22. }  
         这里的mInstrumentation是Activity类的成员变量，它的类型是Intrumentation，定义在frameworks/base/core/java/android/app/Instrumentation.java文件中，它用来监控应用程序和系统的交互。

         这里的mMainThread也是Activity类的成员变量，它的类型是ActivityThread，它代表的是应用程序的主线程，我们在Android系统在新进程中启动自定义服务过程（startService）的原理分析一文中已经介绍过了。这里通过mMainThread.getApplicationThread获得它里面的ApplicationThread成员变量，它是一个Binder对象，后面我们会看到，ActivityManagerService会使用它来和ActivityThread来进行进程间通信。这里我们需注意的是，这里的mMainThread代表的是Launcher应用程序运行的进程。

         这里的mToken也是Activity类的成员变量，它是一个Binder对象的远程接口。

         Step 4. Instrumentation.execStartActivity
         这个函数定义在frameworks/base/core/java/android/app/Instrumentation.java文件中：

[java]  view plain copy
  1. public class Instrumentation {  
  2.   
  3.     ......  
  4.   
  5.     public ActivityResult execStartActivity(  
  6.     Context who, IBinder contextThread, IBinder token, Activity target,  
  7.     Intent intent, int requestCode) {  
  8.         IApplicationThread whoThread = (IApplicationThread) contextThread;  
  9.         if (mActivityMonitors != null) {  
  10.             ......  
  11.         }  
  12.         try {  
  13.             int result = ActivityManagerNative.getDefault()  
  14.                 .startActivity(whoThread, intent,  
  15.                 intent.resolveTypeIfNeeded(who.getContentResolver()),  
  16.                 null, 0, token, target != null ? target.mEmbeddedID : null,  
  17.                 requestCode, false, false);  
  18.             ......  
  19.         } catch (RemoteException e) {  
  20.         }  
  21.         return null;  
  22.     }  
  23.   
  24.     ......  
  25.   
  26. }  
         这里的ActivityManagerNative.getDefault返回ActivityManagerService的远程接口，即ActivityManagerProxy接口，具体可以参考 Android系统在新进程中启动自定义服务过程（startService）的原理分析 一文。

         这里的intent.resolveTypeIfNeeded返回这个intent的MIME类型，在这个例子中，没有AndroidManifest.xml设置MainActivity的MIME类型，因此，这里返回null。

         这里的target不为null，但是target.mEmbddedID为null，我们不用关注。

         Step 5. ActivityManagerProxy.startActivity

         这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

[java]  view plain copy
  1. class ActivityManagerProxy implements IActivityManager  
  2. {  
  3.   
  4.     ......  
  5.   
  6.     public int startActivity(IApplicationThread caller, Intent intent,  
  7.             String resolvedType, Uri[] grantedUriPermissions, int grantedMode,  
  8.             IBinder resultTo, String resultWho,  
  9.             int requestCode, boolean onlyIfNeeded,  
  10.             boolean debug) throws RemoteException {  
  11.         Parcel data = Parcel.obtain();  
  12.         Parcel reply = Parcel.obtain();  
  13.         data.writeInterfaceToken(IActivityManager.descriptor);  
  14.         data.writeStrongBinder(caller != null ? caller.asBinder() : null);  
  15.         intent.writeToParcel(data, 0);  
  16.         data.writeString(resolvedType);  
  17.         data.writeTypedArray(grantedUriPermissions, 0);  
  18.         data.writeInt(grantedMode);  
  19.         data.writeStrongBinder(resultTo);  
  20.         data.writeString(resultWho);  
  21.         data.writeInt(requestCode);  
  22.         data.writeInt(onlyIfNeeded ? 1 : 0);  
  23.         data.writeInt(debug ? 1 : 0);  
  24.         mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);  
  25.         reply.readException();  
  26.         int result = reply.readInt();  
  27.         reply.recycle();  
  28.         data.recycle();  
  29.         return result;  
  30.     }  
  31.   
  32.     ......  
  33.   
  34. }  
        这里的参数比较多，我们先整理一下。从上面的调用可以知道，这里的参数resolvedType、grantedUriPermissions和resultWho均为null；参数caller为ApplicationThread类型的Binder实体；参数resultTo为一个Binder实体的远程接口，我们先不关注它；参数grantedMode为0，我们也先不关注它；参数requestCode为-1；参数onlyIfNeeded和debug均空false。

        Step 6. ActivityManagerService.startActivity

        上一步Step 5通过Binder驱动程序就进入到ActivityManagerService的startActivity函数来了，它定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

[java]  view plain copy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     public final int startActivity(IApplicationThread caller,  
  7.             Intent intent, String resolvedType, Uri[] grantedUriPermissions,  
  8.             int grantedMode, IBinder resultTo,  
  9.             String resultWho, int requestCode, boolean onlyIfNeeded,  
  10.             boolean debug) {  
  11.         return mMainStack.startActivityMayWait(caller, intent, resolvedType,  
  12.             grantedUriPermissions, grantedMode, resultTo, resultWho,  
  13.             requestCode, onlyIfNeeded, debug, null, null);  
  14.     }  
  15.   
  16.   
  17.     ......  
  18.   
  19. }  
        这里只是简单地将操作转发给成员变量mMainStack的startActivityMayWait函数，这里的mMainStack的类型为ActivityStack。

        Step 7. ActivityStack.startActivityMayWait

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final int startActivityMayWait(IApplicationThread caller,  
  6.             Intent intent, String resolvedType, Uri[] grantedUriPermissions,  
  7.             int grantedMode, IBinder resultTo,  
  8.             String resultWho, int requestCode, boolean onlyIfNeeded,  
  9.             boolean debug, WaitResult outResult, Configuration config) {  
  10.   
  11.         ......  
  12.   
  13.         boolean componentSpecified = intent.getComponent() != null;  
  14.   
  15.         // Don't modify the client's object!  
  16.         intent = new Intent(intent);  
  17.   
  18.         // Collect information about the target of the Intent.  
  19.         ActivityInfo aInfo;  
  20.         try {  
  21.             ResolveInfo rInfo =  
  22.                 AppGlobals.getPackageManager().resolveIntent(  
  23.                 intent, resolvedType,  
  24.                 PackageManager.MATCH_DEFAULT_ONLY  
  25.                 | ActivityManagerService.STOCK_PM_FLAGS);  
  26.             aInfo = rInfo != null ? rInfo.activityInfo : null;  
  27.         } catch (RemoteException e) {  
  28.             ......  
  29.         }  
  30.   
  31.         if (aInfo != null) {  
  32.             // Store the found target back into the intent, because now that  
  33.             // we have it we never want to do this again.  For example, if the  
  34.             // user navigates back to this point in the history, we should  
  35.             // always restart the exact same activity.  
  36.             intent.setComponent(new ComponentName(  
  37.                 aInfo.applicationInfo.packageName, aInfo.name));  
  38.             ......  
  39.         }  
  40.   
  41.         synchronized (mService) {  
  42.             int callingPid;  
  43.             int callingUid;  
  44.             if (caller == null) {  
  45.                 ......  
  46.             } else {  
  47.                 callingPid = callingUid = -1;  
  48.             }  
  49.   
  50.             mConfigWillChange = config != null  
  51.                 && mService.mConfiguration.diff(config) != 0;  
  52.   
  53.             ......  
  54.   
  55.             if (mMainStack && aInfo != null &&  
  56.                 (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {  
  57.                     
  58.                       ......  
  59.   
  60.             }  
  61.   
  62.             int res = startActivityLocked(caller, intent, resolvedType,  
  63.                 grantedUriPermissions, grantedMode, aInfo,  
  64.                 resultTo, resultWho, requestCode, callingPid, callingUid,  
  65.                 onlyIfNeeded, componentSpecified);  
  66.   
  67.             if (mConfigWillChange && mMainStack) {  
  68.                 ......  
  69.             }  
  70.   
  71.             ......  
  72.   
  73.             if (outResult != null) {  
  74.                 ......  
  75.             }  
  76.   
  77.             return res;  
  78.         }  
  79.   
  80.     }  
  81.   
  82.     ......  
  83.   
  84. }  
        注意，从Step 6传下来的参数outResult和config均为null，此外，表达式(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0为false，因此，这里忽略了无关代码。

        下面语句对参数intent的内容进行解析，得到MainActivity的相关信息，保存在aInfo变量中：

[java]  view plain copy
  1.    ActivityInfo aInfo;  
  2.    try {  
  3. ResolveInfo rInfo =  
  4. AppGlobals.getPackageManager().resolveIntent(  
  5.     intent, resolvedType,  
  6.     PackageManager.MATCH_DEFAULT_ONLY  
  7.     | ActivityManagerService.STOCK_PM_FLAGS);  
  8. aInfo = rInfo != null ? rInfo.activityInfo : null;  
  9.    } catch (RemoteException e) {  
  10.     ......  
  11.    }  
        解析之后，得到的aInfo.applicationInfo.packageName的值为"shy.luo.activity"，aInfo.name的值为"shy.luo.activity.MainActivity"，这是在这个实例的配置文件AndroidManifest.xml里面配置的。

        此外，函数开始的地方调用intent.getComponent()函数的返回值不为null，因此，这里的componentSpecified变量为true。

        接下去就调用startActivityLocked进一步处理了。

        Step 8. ActivityStack.startActivityLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final int startActivityLocked(IApplicationThread caller,  
  6.             Intent intent, String resolvedType,  
  7.             Uri[] grantedUriPermissions,  
  8.             int grantedMode, ActivityInfo aInfo, IBinder resultTo,  
  9.                 String resultWho, int requestCode,  
  10.             int callingPid, int callingUid, boolean onlyIfNeeded,  
  11.             boolean componentSpecified) {  
  12.             int err = START_SUCCESS;  
  13.   
  14.         ProcessRecord callerApp = null;  
  15.         if (caller != null) {  
  16.             callerApp = mService.getRecordForAppLocked(caller);  
  17.             if (callerApp != null) {  
  18.                 callingPid = callerApp.pid;  
  19.                 callingUid = callerApp.info.uid;  
  20.             } else {  
  21.                 ......  
  22.             }  
  23.         }  
  24.   
  25.         ......  
  26.   
  27.         ActivityRecord sourceRecord = null;  
  28.         ActivityRecord resultRecord = null;  
  29.         if (resultTo != null) {  
  30.             int index = indexOfTokenLocked(resultTo);  
  31.               
  32.             ......  
  33.                   
  34.             if (index >= 0) {  
  35.                 sourceRecord = (ActivityRecord)mHistory.get(index);  
  36.                 if (requestCode >= 0 && !sourceRecord.finishing) {  
  37.                     ......  
  38.                 }  
  39.             }  
  40.         }  
  41.   
  42.         int launchFlags = intent.getFlags();  
  43.   
  44.         if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0  
  45.             && sourceRecord != null) {  
  46.             ......  
  47.         }  
  48.   
  49.         if (err == START_SUCCESS && intent.getComponent() == null) {  
  50.             ......  
  51.         }  
  52.   
  53.         if (err == START_SUCCESS && aInfo == null) {  
  54.             ......  
  55.         }  
  56.   
  57.         if (err != START_SUCCESS) {  
  58.             ......  
  59.         }  
  60.   
  61.         ......  
  62.   
  63.         ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,  
  64.             intent, resolvedType, aInfo, mService.mConfiguration,  
  65.             resultRecord, resultWho, requestCode, componentSpecified);  
  66.   
  67.         ......  
  68.   
  69.         return startActivityUncheckedLocked(r, sourceRecord,  
  70.             grantedUriPermissions, grantedMode, onlyIfNeeded, true);  
  71.     }  
  72.   
  73.   
  74.     ......  
  75.   
  76. }  
        从传进来的参数caller得到调用者的进程信息，并保存在callerApp变量中，这里就是Launcher应用程序的进程信息了。

        前面说过，参数resultTo是Launcher这个Activity里面的一个Binder对象，通过它可以获得Launcher这个Activity的相关信息，保存在sourceRecord变量中。
        再接下来，创建即将要启动的Activity的相关信息，并保存在r变量中：

[java]  view plain copy
  1. ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,  
  2.     intent, resolvedType, aInfo, mService.mConfiguration,  
  3.     resultRecord, resultWho, requestCode, componentSpecified);  
        接着调用startActivityUncheckedLocked函数进行下一步操作。

        Step 9. ActivityStack.startActivityUncheckedLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final int startActivityUncheckedLocked(ActivityRecord r,  
  6.         ActivityRecord sourceRecord, Uri[] grantedUriPermissions,  
  7.         int grantedMode, boolean onlyIfNeeded, boolean doResume) {  
  8.         final Intent intent = r.intent;  
  9.         final int callingUid = r.launchedFromUid;  
  10.   
  11.         int launchFlags = intent.getFlags();  
  12.   
  13.         // We'll invoke onUserLeaving before onPause only if the launching  
  14.         // activity did not explicitly state that this is an automated launch.  
  15.         mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;  
  16.           
  17.         ......  
  18.   
  19.         ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)  
  20.             != 0 ? r : null;  
  21.   
  22.         // If the onlyIfNeeded flag is set, then we can do this if the activity  
  23.         // being launched is the same as the one making the call...  or, as  
  24.         // a special case, if we do not know the caller then we count the  
  25.         // current top activity as the caller.  
  26.         if (onlyIfNeeded) {  
  27.             ......  
  28.         }  
  29.   
  30.         if (sourceRecord == null) {  
  31.             ......  
  32.         } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {  
  33.             ......  
  34.         } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE  
  35.             || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {  
  36.             ......  
  37.         }  
  38.   
  39.         if (r.resultTo != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  40.             ......  
  41.         }  
  42.   
  43.         boolean addingToTask = false;  
  44.         if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&  
  45.             (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)  
  46.             || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK  
  47.             || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {  
  48.                 // If bring to front is requested, and no result is requested, and  
  49.                 // we can find a task that was started with this same  
  50.                 // component, then instead of launching bring that one to the front.  
  51.                 if (r.resultTo == null) {  
  52.                     // See if there is a task to bring to the front.  If this is  
  53.                     // a SINGLE_INSTANCE activity, there can be one and only one  
  54.                     // instance of it in the history, and it is always in its own  
  55.                     // unique task, so we do a special search.  
  56.                     ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE  
  57.                         ? findTaskLocked(intent, r.info)  
  58.                         : findActivityLocked(intent, r.info);  
  59.                     if (taskTop != null) {  
  60.                         ......  
  61.                     }  
  62.                 }  
  63.         }  
  64.   
  65.         ......  
  66.   
  67.         if (r.packageName != null) {  
  68.             // If the activity being launched is the same as the one currently  
  69.             // at the top, then we need to check if it should only be launched  
  70.             // once.  
  71.             ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);  
  72.             if (top != null && r.resultTo == null) {  
  73.                 if (top.realActivity.equals(r.realActivity)) {  
  74.                     ......  
  75.                 }  
  76.             }  
  77.   
  78.         } else {  
  79.             ......  
  80.         }  
  81.   
  82.         boolean newTask = false;  
  83.   
  84.         // Should this be considered a new task?  
  85.         if (r.resultTo == null && !addingToTask  
  86.             && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  87.                 // todo: should do better management of integers.  
  88.                 mService.mCurTask++;  
  89.                 if (mService.mCurTask <= 0) {  
  90.                     mService.mCurTask = 1;  
  91.                 }  
  92.                 r.task = new TaskRecord(mService.mCurTask, r.info, intent,  
  93.                     (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);  
  94.                 ......  
  95.                 newTask = true;  
  96.                 if (mMainStack) {  
  97.                     mService.addRecentTaskLocked(r.task);  
  98.                 }  
  99.   
  100.         } else if (sourceRecord != null) {  
  101.             ......  
  102.         } else {  
  103.             ......  
  104.         }  
  105.   
  106.         ......  
  107.   
  108.         startActivityLocked(r, newTask, doResume);  
  109.         return START_SUCCESS;  
  110.     }  
  111.   
  112.     ......  
  113.   
  114. }  
        函数首先获得intent的标志值，保存在launchFlags变量中。

        这个intent的标志值的位Intent.FLAG_ACTIVITY_NO_USER_ACTION没有置位，因此 ，成员变量mUserLeaving的值为true。

        这个intent的标志值的位Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP也没有置位，因此，变量notTop的值为null。

        由于在这个例子的AndroidManifest.xml文件中，MainActivity没有配置launchMode属值，因此，这里的r.launchMode为默认值0，表示以标准（Standard，或者称为ActivityInfo.LAUNCH_MULTIPLE）的方式来启动这个Activity。Activity的启动方式有四种，其余三种分别是ActivityInfo.LAUNCH_SINGLE_INSTANCE、ActivityInfo.LAUNCH_SINGLE_TASK和ActivityInfo.LAUNCH_SINGLE_TOP，具体可以参考官方网站http://developer.android.com/reference/android/content/pm/ActivityInfo.html。

        传进来的参数r.resultTo为null，表示Launcher不需要等这个即将要启动的MainActivity的执行结果。

        由于这个intent的标志值的位Intent.FLAG_ACTIVITY_NEW_TASK被置位，而且Intent.FLAG_ACTIVITY_MULTIPLE_TASK没有置位，因此，下面的if语句会被执行：

[java]  view plain copy
  1.    if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&  
  2. (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)  
  3. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK  
  4. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {  
  5.     // If bring to front is requested, and no result is requested, and  
  6.     // we can find a task that was started with this same  
  7.     // component, then instead of launching bring that one to the front.  
  8.     if (r.resultTo == null) {  
  9.         // See if there is a task to bring to the front.  If this is  
  10.         // a SINGLE_INSTANCE activity, there can be one and only one  
  11.         // instance of it in the history, and it is always in its own  
  12.         // unique task, so we do a special search.  
  13.         ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE  
  14.             ? findTaskLocked(intent, r.info)  
  15.             : findActivityLocked(intent, r.info);  
  16.         if (taskTop != null) {  
  17.             ......  
  18.         }  
  19.     }  
  20.    }  
        这段代码的逻辑是查看一下，当前有没有Task可以用来执行这个Activity。由于r.launchMode的值不为ActivityInfo.LAUNCH_SINGLE_INSTANCE，因此，它通过findTaskLocked函数来查找存不存这样的Task，这里返回的结果是null，即taskTop为null，因此，需要创建一个新的Task来启动这个Activity。

        接着往下看：

[java]  view plain copy
  1.    if (r.packageName != null) {  
  2. // If the activity being launched is the same as the one currently  
  3. // at the top, then we need to check if it should only be launched  
  4. // once.  
  5. ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);  
  6. if (top != null && r.resultTo == null) {  
  7.     if (top.realActivity.equals(r.realActivity)) {  
  8.         ......  
  9.     }  
  10. }  
  11.   
  12.    }   
        这段代码的逻辑是看一下，当前在堆栈顶端的Activity是否就是即将要启动的Activity，有些情况下，如果即将要启动的Activity就在堆栈的顶端，那么，就不会重新启动这个Activity的别一个实例了，具体可以参考官方网站 http://developer.android.com/reference/android/content/pm/ActivityInfo.html 。现在处理堆栈顶端的Activity是Launcher，与我们即将要启动的MainActivity不是同一个Activity，因此，这里不用进一步处理上述介绍的情况。

       执行到这里，我们知道，要在一个新的Task里面来启动这个Activity了，于是新创建一个Task：

[java]  view plain copy
  1.   if (r.resultTo == null && !addingToTask  
  2. && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  3. // todo: should do better management of integers.  
  4. mService.mCurTask++;  
  5. if (mService.mCurTask <= 0) {  
  6.     mService.mCurTask = 1;  
  7. }  
  8. r.task = new TaskRecord(mService.mCurTask, r.info, intent,  
  9.     (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);  
  10. ......  
  11. newTask = true;  
  12. if (mMainStack) {  
  13.     mService.addRecentTaskLocked(r.task);  
  14. }  
  15.   
  16.    }  
        新建的Task保存在r.task域中，同时，添加到mService中去，这里的mService就是ActivityManagerService了。

        最后就进入startActivityLocked(r, newTask, doResume)进一步处理了。这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void startActivityLocked(ActivityRecord r, boolean newTask,  
  6.             boolean doResume) {  
  7.         final int NH = mHistory.size();  
  8.   
  9.         int addPos = -1;  
  10.   
  11.         if (!newTask) {  
  12.             ......  
  13.         }  
  14.   
  15.         // Place a new activity at top of stack, so it is next to interact  
  16.         // with the user.  
  17.         if (addPos < 0) {  
  18.             addPos = NH;  
  19.         }  
  20.   
  21.         // If we are not placing the new activity frontmost, we do not want  
  22.         // to deliver the onUserLeaving callback to the actual frontmost  
  23.         // activity  
  24.         if (addPos < NH) {  
  25.             ......  
  26.         }  
  27.   
  28.         // Slot the activity into the history stack and proceed  
  29.         mHistory.add(addPos, r);  
  30.         r.inHistory = true;  
  31.         r.frontOfTask = newTask;  
  32.         r.task.numActivities++;  
  33.         if (NH > 0) {  
  34.             // We want to show the starting preview window if we are  
  35.             // switching to a new task, or the next activity's process is  
  36.             // not currently running.  
  37.             ......  
  38.         } else {  
  39.             // If this is the first activity, don't do any fancy animations,  
  40.             // because there is nothing for it to animate on top of.  
  41.             ......  
  42.         }  
  43.           
  44.         ......  
  45.   
  46.         if (doResume) {  
  47.             resumeTopActivityLocked(null);  
  48.         }  
  49.     }  
  50.   
  51.     ......  
  52.   
  53. }  
        这里的NH表示当前系统中历史任务的个数，这里肯定是大于0，因为Launcher已经跑起来了。当NH>0时，并且现在要切换新任务时，要做一些任务切的界面操作，这段代码我们就不看了，这里不会影响到下面启Activity的过程，有兴趣的读取可以自己研究一下。

        这里传进来的参数doResume为true，于是调用resumeTopActivityLocked进一步操作。

        Step 10. Activity.resumeTopActivityLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     /** 
  6.     * Ensure that the top activity in the stack is resumed. 
  7.     * 
  8.     * @param prev The previously resumed activity, for when in the process 
  9.     * of pausing; can be null to call from elsewhere. 
  10.     * 
  11.     * @return Returns true if something is being resumed, or false if 
  12.     * nothing happened. 
  13.     */  
  14.     final boolean resumeTopActivityLocked(ActivityRecord prev) {  
  15.         // Find the first activity that is not finishing.  
  16.         ActivityRecord next = topRunningActivityLocked(null);  
  17.   
  18.         // Remember how we'll process this pause/resume situation, and ensure  
  19.         // that the state is reset however we wind up proceeding.  
  20.         final boolean userLeaving = mUserLeaving;  
  21.         mUserLeaving = false;  
  22.   
  23.         if (next == null) {  
  24.             ......  
  25.         }  
  26.   
  27.         next.delayedResume = false;  
  28.   
  29.         // If the top activity is the resumed one, nothing to do.  
  30.         if (mResumedActivity == next && next.state == ActivityState.RESUMED) {  
  31.             ......  
  32.         }  
  33.   
  34.         // If we are sleeping, and there is no resumed activity, and the top  
  35.         // activity is paused, well that is the state we want.  
  36.         if ((mService.mSleeping || mService.mShuttingDown)  
  37.             && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {  
  38.             ......  
  39.         }  
  40.   
  41.         ......  
  42.   
  43.         // If we are currently pausing an activity, then don't do anything  
  44.         // until that is done.  
  45.         if (mPausingActivity != null) {  
  46.             ......  
  47.         }  
  48.   
  49.         ......  
  50.   
  51.         // We need to start pausing the current activity so the top one  
  52.         // can be resumed...  
  53.         if (mResumedActivity != null) {  
  54.             ......  
  55.             startPausingLocked(userLeaving, false);  
  56.             return true;  
  57.         }  
  58.   
  59.         ......  
  60.     }  
  61.   
  62.     ......  
  63.   
  64. }  
        函数先通过调用topRunningActivityLocked函数获得堆栈顶端的Activity，这里就是MainActivity了，这是在上面的Step 9设置好的，保存在next变量中。 

       接下来把mUserLeaving的保存在本地变量userLeaving中，然后重新设置为false，在上面的Step 9中，mUserLeaving的值为true，因此，这里的userLeaving为true。

       这里的mResumedActivity为Launcher，因为Launcher是当前正被执行的Activity。

       当我们处理休眠状态时，mLastPausedActivity保存堆栈顶端的Activity，因为当前不是休眠状态，所以mLastPausedActivity为null。

       有了这些信息之后，下面的语句就容易理解了：

[java]  view plain copy
  1.    // If the top activity is the resumed one, nothing to do.  
  2.    if (mResumedActivity == next && next.state == ActivityState.RESUMED) {  
  3. ......  
  4.    }  
  5.   
  6.    // If we are sleeping, and there is no resumed activity, and the top  
  7.    // activity is paused, well that is the state we want.  
  8.    if ((mService.mSleeping || mService.mShuttingDown)  
  9. && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {  
  10. ......  
  11.    }  
        它首先看要启动的Activity是否就是当前处理Resumed状态的Activity，如果是的话，那就什么都不用做，直接返回就可以了；否则再看一下系统当前是否休眠状态，如果是的话，再看看要启动的Activity是否就是当前处于堆栈顶端的Activity，如果是的话，也是什么都不用做。

        上面两个条件都不满足，因此，在继续往下执行之前，首先要把当处于Resumed状态的Activity推入Paused状态，然后才可以启动新的Activity。但是在将当前这个Resumed状态的Activity推入Paused状态之前，首先要看一下当前是否有Activity正在进入Pausing状态，如果有的话，当前这个Resumed状态的Activity就要稍后才能进入Paused状态了，这样就保证了所有需要进入Paused状态的Activity串行处理。

        这里没有处于Pausing状态的Activity，即mPausingActivity为null，而且mResumedActivity也不为null，于是就调用startPausingLocked函数把Launcher推入Paused状态去了。

        Step 11. ActivityStack.startPausingLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {  
  6.         if (mPausingActivity != null) {  
  7.             ......  
  8.         }  
  9.         ActivityRecord prev = mResumedActivity;  
  10.         if (prev == null) {  
  11.             ......  
  12.         }  
  13.         ......  
  14.         mResumedActivity = null;  
  15.         mPausingActivity = prev;  
  16.         mLastPausedActivity = prev;  
  17.         prev.state = ActivityState.PAUSING;  
  18.         ......  
  19.   
  20.         if (prev.app != null && prev.app.thread != null) {  
  21.             ......  
  22.             try {  
  23.                 ......  
  24.                 prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving,  
  25.                     prev.configChangeFlags);  
  26.                 ......  
  27.             } catch (Exception e) {  
  28.                 ......  
  29.             }  
  30.         } else {  
  31.             ......  
  32.         }  
  33.   
  34.         ......  
  35.       
  36.     }  
  37.   
  38.     ......  
  39.   
  40. }  

        函数首先把mResumedActivity保存在本地变量prev中。在上一步Step 10中，说到mResumedActivity就是Launcher，因此，这里把Launcher进程中的ApplicationThread对象取出来，通过它来通知Launcher这个Activity它要进入Paused状态了。当然，这里的prev.app.thread是一个ApplicationThread对象的远程接口，通过调用这个远程接口的schedulePauseActivity来通知Launcher进入Paused状态。

       参数prev.finishing表示prev所代表的Activity是否正在等待结束的Activity列表中，由于Laucher这个Activity还没结束，所以这里为false；参数prev.configChangeFlags表示哪些config发生了变化，这里我们不关心它的值。

       Step 12. ApplicationThreadProxy.schedulePauseActivity

       这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

[java]  view plain copy
  1. class ApplicationThreadProxy implements IApplicationThread {  
  2.       
  3.     ......  
  4.   
  5.     public final void schedulePauseActivity(IBinder token, boolean finished,  
  6.     boolean userLeaving, int configChanges) throws RemoteException {  
  7.         Parcel data = Parcel.obtain();  
  8.         data.writeInterfaceToken(IApplicationThread.descriptor);  
  9.         data.writeStrongBinder(token);  
  10.         data.writeInt(finished ? 1 : 0);  
  11.         data.writeInt(userLeaving ? 1 :0);  
  12.         data.writeInt(configChanges);  
  13.         mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null,  
  14.             IBinder.FLAG_ONEWAY);  
  15.         data.recycle();  
  16.     }  
  17.   
  18.     ......  
  19.   
  20. }  

        这个函数通过Binder进程间通信机制进入到ApplicationThread.schedulePauseActivity函数中。

        Step 13. ApplicationThread.schedulePauseActivity

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中，它是ActivityThread的内部类：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final class ApplicationThread extends ApplicationThreadNative {  
  6.           
  7.         ......  
  8.   
  9.         public final void schedulePauseActivity(IBinder token, boolean finished,  
  10.                 boolean userLeaving, int configChanges) {  
  11.             queueOrSendMessage(  
  12.                 finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,  
  13.                 token,  
  14.                 (userLeaving ? 1 : 0),  
  15.                 configChanges);  
  16.         }  
  17.   
  18.         ......  
  19.   
  20.     }  
  21.   
  22.     ......  
  23.   
  24. }  
        这里调用的函数queueOrSendMessage是ActivityThread类的成员函数。

       上面说到，这里的finished值为false，因此，queueOrSendMessage的第一个参数值为H.PAUSE_ACTIVITY，表示要暂停token所代表的Activity，即Launcher。

       Step 14. ActivityThread.queueOrSendMessage

       这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final void queueOrSendMessage(int what, Object obj, int arg1) {  
  6.         queueOrSendMessage(what, obj, arg1, 0);  
  7.     }  
  8.   
  9.     private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {  
  10.         synchronized (this) {  
  11.             ......  
  12.             Message msg = Message.obtain();  
  13.             msg.what = what;  
  14.             msg.obj = obj;  
  15.             msg.arg1 = arg1;  
  16.             msg.arg2 = arg2;  
  17.             mH.sendMessage(msg);  
  18.         }  
  19.     }  
  20.   
  21.     ......  
  22.   
  23. }  
        这里首先将相关信息组装成一个msg，然后通过mH成员变量发送出去，mH的类型是H，继承于Handler类，是ActivityThread的内部类，因此，这个消息最后由H.handleMessage来处理。

        Step 15. H.handleMessage

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final class H extends Handler {  
  6.   
  7.         ......  
  8.   
  9.         public void handleMessage(Message msg) {  
  10.             ......  
  11.             switch (msg.what) {  
  12.               
  13.             ......  
  14.               
  15.             case PAUSE_ACTIVITY:  
  16.                 handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);  
  17.                 maybeSnapshot();  
  18.                 break;  
  19.   
  20.             ......  
  21.   
  22.             }  
  23.         ......  
  24.   
  25.     }  
  26.   
  27.     ......  
  28.   
  29. }  

        这里调用ActivityThread.handlePauseActivity进一步操作，msg.obj是一个ActivityRecord对象的引用，它代表的是Launcher这个Activity。
        Step 16. ActivityThread.handlePauseActivity

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final void handlePauseActivity(IBinder token, boolean finished,  
  6.             boolean userLeaving, int configChanges) {  
  7.   
  8.         ActivityClientRecord r = mActivities.get(token);  
  9.         if (r != null) {  
  10.             //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);  
  11.             if (userLeaving) {  
  12.                 performUserLeavingActivity(r);  
  13.             }  
  14.   
  15.             r.activity.mConfigChangeFlags |= configChanges;  
  16.             Bundle state = performPauseActivity(token, finished, true);  
  17.   
  18.             // Make sure any pending writes are now committed.  
  19.             QueuedWork.waitToFinish();  
  20.   
  21.             // Tell the activity manager we have paused.  
  22.             try {  
  23.                 ActivityManagerNative.getDefault().activityPaused(token, state);  
  24.             } catch (RemoteException ex) {  
  25.             }  
  26.         }  
  27.     }  
  28.   
  29.     ......  
  30.   
  31. }  
         函数首先将Binder引用token转换成ActivityRecord的远程接口ActivityClientRecord，然后做了三个事情：1. 如果userLeaving为true，则通过调用performUserLeavingActivity函数来调用Activity.onUserLeaveHint通知Activity，用户要离开它了；2. 调用performPauseActivity函数来调用Activity.onPause函数，我们知道，在Activity的生命周期中，当它要让位于其它的Activity时，系统就会调用它的onPause函数；3. 它通知ActivityManagerService，这个Activity已经进入Paused状态了，ActivityManagerService现在可以完成未竟的事情，即启动MainActivity了。

        Step 17. ActivityManagerProxy.activityPaused

        这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

[java]  view plain copy
  1. class ActivityManagerProxy implements IActivityManager  
  2. {  
  3.     ......  
  4.   
  5.     public void activityPaused(IBinder token, Bundle state) throws RemoteException  
  6.     {  
  7.         Parcel data = Parcel.obtain();  
  8.         Parcel reply = Parcel.obtain();  
  9.         data.writeInterfaceToken(IActivityManager.descriptor);  
  10.         data.writeStrongBinder(token);  
  11.         data.writeBundle(state);  
  12.         mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);  
  13.         reply.readException();  
  14.         data.recycle();  
  15.         reply.recycle();  
  16.     }  
  17.   
  18.     ......  
  19.   
  20. }  
        这里通过Binder进程间通信机制就进入到ActivityManagerService.activityPaused函数中去了。

        Step 18. ActivityManagerService.activityPaused

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

[java]  view plain copy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.             implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.     ......  
  4.   
  5.     public final void activityPaused(IBinder token, Bundle icicle) {  
  6.           
  7.         ......  
  8.   
  9.         final long origId = Binder.clearCallingIdentity();  
  10.         mMainStack.activityPaused(token, icicle, false);  
  11.           
  12.         ......  
  13.     }  
  14.   
  15.     ......  
  16.   
  17. }  
       这里，又再次进入到ActivityStack类中，执行activityPaused函数。

       Step 19. ActivityStack.activityPaused

       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {  
  6.           
  7.         ......  
  8.   
  9.         ActivityRecord r = null;  
  10.   
  11.         synchronized (mService) {  
  12.             int index = indexOfTokenLocked(token);  
  13.             if (index >= 0) {  
  14.                 r = (ActivityRecord)mHistory.get(index);  
  15.                 if (!timeout) {  
  16.                     r.icicle = icicle;  
  17.                     r.haveState = true;  
  18.                 }  
  19.                 mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);  
  20.                 if (mPausingActivity == r) {  
  21.                     r.state = ActivityState.PAUSED;  
  22.                     completePauseLocked();  
  23.                 } else {  
  24.                     ......  
  25.                 }  
  26.             }  
  27.         }  
  28.     }  
  29.   
  30.     ......  
  31.   
  32. }  
       这里通过参数token在mHistory列表中得到ActivityRecord，从上面我们知道，这个ActivityRecord代表的是Launcher这个Activity，而我们在Step 11中，把Launcher这个Activity的信息保存在mPausingActivity中，因此，这里mPausingActivity等于r，于是，执行completePauseLocked操作。

       Step 20. ActivityStack.completePauseLocked

       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void completePauseLocked() {  
  6.         ActivityRecord prev = mPausingActivity;  
  7.           
  8.         ......  
  9.   
  10.         if (prev != null) {  
  11.   
  12.             ......  
  13.   
  14.             mPausingActivity = null;  
  15.         }  
  16.   
  17.         if (!mService.mSleeping && !mService.mShuttingDown) {  
  18.             resumeTopActivityLocked(prev);  
  19.         } else {  
  20.             ......  
  21.         }  
  22.   
  23.         ......  
  24.     }  
  25.   
  26.     ......  
  27.   
  28. }  
        函数首先把mPausingActivity变量清空，因为现在不需要它了，然后调用resumeTopActivityLokced进一步操作，它传入的参数即为代表Launcher这个Activity的ActivityRecord。

        Step 21. ActivityStack.resumeTopActivityLokced
        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final boolean resumeTopActivityLocked(ActivityRecord prev) {  
  6.         ......  
  7.   
  8.         // Find the first activity that is not finishing.  
  9.         ActivityRecord next = topRunningActivityLocked(null);  
  10.   
  11.         // Remember how we'll process this pause/resume situation, and ensure  
  12.         // that the state is reset however we wind up proceeding.  
  13.         final boolean userLeaving = mUserLeaving;  
  14.         mUserLeaving = false;  
  15.   
  16.         ......  
  17.   
  18.         next.delayedResume = false;  
  19.   
  20.         // If the top activity is the resumed one, nothing to do.  
  21.         if (mResumedActivity == next && next.state == ActivityState.RESUMED) {  
  22.             ......  
  23.             return false;  
  24.         }  
  25.   
  26.         // If we are sleeping, and there is no resumed activity, and the top  
  27.         // activity is paused, well that is the state we want.  
  28.         if ((mService.mSleeping || mService.mShuttingDown)  
  29.             && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {  
  30.             ......  
  31.             return false;  
  32.         }  
  33.   
  34.         .......  
  35.   
  36.   
  37.         // We need to start pausing the current activity so the top one  
  38.         // can be resumed...  
  39.         if (mResumedActivity != null) {  
  40.             ......  
  41.             return true;  
  42.         }  
  43.   
  44.         ......  
  45.   
  46.   
  47.         if (next.app != null && next.app.thread != null) {  
  48.             ......  
  49.   
  50.         } else {  
  51.             ......  
  52.             startSpecificActivityLocked(next, true, true);  
  53.         }  
  54.   
  55.         return true;  
  56.     }  
  57.   
  58.   
  59.     ......  
  60.   
  61. }  
        通过上面的Step 9，我们知道，当前在堆栈顶端的Activity为我们即将要启动的MainActivity，这里通过调用topRunningActivityLocked将它取回来，保存在next变量中。之前最后一个Resumed状态的Activity，即Launcher，到了这里已经处于Paused状态了，因此，mResumedActivity为null。最后一个处于Paused状态的Activity为Launcher，因此，这里的mLastPausedActivity就为Launcher。前面我们为MainActivity创建了ActivityRecord后，它的app域一直保持为null。有了这些信息后，上面这段代码就容易理解了，它最终调用startSpecificActivityLocked进行下一步操作。

       Step 22. ActivityStack.startSpecificActivityLocked
       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void startSpecificActivityLocked(ActivityRecord r,  
  6.             boolean andResume, boolean checkConfig) {  
  7.         // Is this activity's application already running?  
  8.         ProcessRecord app = mService.getProcessRecordLocked(r.processName,  
  9.             r.info.applicationInfo.uid);  
  10.   
  11.         ......  
  12.   
  13.         if (app != null && app.thread != null) {  
  14.             try {  
  15.                 realStartActivityLocked(r, app, andResume, checkConfig);  
  16.                 return;  
  17.             } catch (RemoteException e) {  
  18.                 ......  
  19.             }  
  20.         }  
  21.   
  22.         mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,  
  23.             "activity", r.intent.getComponent(), false);  
  24.     }  
  25.   
  26.   
  27.     ......  
  28.   
  29. }  
        注意，这里由于是第一次启动应用程序的Activity，所以下面语句：

[java]  view plain copy
  1. ProcessRecord app = mService.getProcessRecordLocked(r.processName,  
  2.     r.info.applicationInfo.uid);  
        取回来的app为null。在Activity应用程序中的AndroidManifest.xml配置文件中，我们没有指定Application标签的process属性，系统就会默认使用package的名称，这里就是"shy.luo.activity"了。每一个应用程序都有自己的uid，因此，这里uid + process的组合就可以为每一个应用程序创建一个ProcessRecord。当然，我们可以配置两个应用程序具有相同的uid和package，或者在AndroidManifest.xml配置文件的application标签或者activity标签中显式指定相同的process属性值，这样，不同的应用程序也可以在同一个进程中启动。

       函数最终执行ActivityManagerService.startProcessLocked函数进行下一步操作。

       Step 23. ActivityManagerService.startProcessLocked

       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

[java]  view plain copy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     final ProcessRecord startProcessLocked(String processName,  
  7.             ApplicationInfo info, boolean knownToBeDead, int intentFlags,  
  8.             String hostingType, ComponentName hostingName, boolean allowWhileBooting) {  
  9.   
  10.         ProcessRecord app = getProcessRecordLocked(processName, info.uid);  
  11.           
  12.         ......  
  13.   
  14.         String hostingNameStr = hostingName != null  
  15.             ? hostingName.flattenToShortString() : null;  
  16.   
  17.         ......  
  18.   
  19.         if (app == null) {  
  20.             app = new ProcessRecordLocked(null, info, processName);  
  21.             mProcessNames.put(processName, info.uid, app);  
  22.         } else {  
  23.             // If this is a new package in the process, add the package to the list  
  24.             app.addPackage(info.packageName);  
  25.         }  
  26.   
  27.         ......  
  28.   
  29.         startProcessLocked(app, hostingType, hostingNameStr);  
  30.         return (app.pid != 0) ? app : null;  
  31.     }  
  32.   
  33.     ......  
  34.   
  35. }  
        这里再次检查是否已经有以process + uid命名的进程存在，在我们这个情景中，返回值app为null，因此，后面会创建一个ProcessRecord，并存保存在成员变量mProcessNames中，最后，调用另一个startProcessLocked函数进一步操作：

[java]  view plain copy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     private final void startProcessLocked(ProcessRecord app,  
  7.                 String hostingType, String hostingNameStr) {  
  8.   
  9.         ......  
  10.   
  11.         try {  
  12.             int uid = app.info.uid;  
  13.             int[] gids = null;  
  14.             try {  
  15.                 gids = mContext.getPackageManager().getPackageGids(  
  16.                     app.info.packageName);  
  17.             } catch (PackageManager.NameNotFoundException e) {  
  18.                 ......  
  19.             }  
  20.               
  21.             ......  
  22.   
  23.             int debugFlags = 0;  
  24.               
  25.             ......  
  26.               
  27.             int pid = Process.start("android.app.ActivityThread",  
  28.                 mSimpleProcessManagement ? app.processName : null, uid, uid,  
  29.                 gids, debugFlags, null);  
  30.               
  31.             ......  
  32.   
  33.         } catch (RuntimeException e) {  
  34.               
  35.             ......  
  36.   
  37.         }  
  38.     }  
  39.   
  40.     ......  
  41.   
  42. }  
        这里主要是调用Process.start接口来创建一个新的进程，新的进程会导入android.app.ActivityThread类，并且执行它的main函数，这就是为什么我们前面说每一个应用程序都有一个ActivityThread实例来对应的原因。

        Step 24. ActivityThread.main

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final void attach(boolean system) {  
  6.         ......  
  7.   
  8.         mSystemThread = system;  
  9.         if (!system) {  
  10.   
  11.             ......  
  12.   
  13.             IActivityManager mgr = ActivityManagerNative.getDefault();  
  14.             try {  
  15.                 mgr.attachApplication(mAppThread);  
  16.             } catch (RemoteException ex) {  
  17.             }  
  18.         } else {  
  19.   
  20.             ......  
  21.   
  22.         }  
  23.     }  
  24.   
  25.     ......  
  26.   
  27.     public static final void main(String[] args) {  
  28.           
  29.         .......  
  30.   
  31.         ActivityThread thread = new ActivityThread();  
  32.         thread.attach(false);  
  33.   
  34.         ......  
  35.   
  36.         Looper.loop();  
  37.   
  38.         .......  
  39.   
  40.         thread.detach();  
  41.           
  42.         ......  
  43.     }  
  44. }  
       这个函数在进程中创建一个ActivityThread实例，然后调用它的attach函数，接着就进入消息循环了，直到最后进程退出。

       函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的attachApplication函数，传入的参数是mAppThread，这是一个ApplicationThread类型的Binder对象，它的作用是用来进行进程间通信的。

      Step 25. ActivityManagerProxy.attachApplication

      这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：

[java]  view plain copy
  1. class ActivityManagerProxy implements IActivityManager  
  2. {  
  3.     ......  
  4.   
  5.     public void attachApplication(IApplicationThread app) throws RemoteException  
  6.     {  
  7.         Parcel data = Parcel.obtain();  
  8.         Parcel reply = Parcel.obtain();  
  9.         data.writeInterfaceToken(IActivityManager.descriptor);  
  10.         data.writeStrongBinder(app.asBinder());  
  11.         mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);  
  12.         reply.readException();  
  13.         data.recycle();  
  14.         reply.recycle();  
  15.     }  
  16.   
  17.     ......  
  18.   
  19. }  
       这里通过Binder驱动程序，最后进入ActivityManagerService的attachApplication函数中。

       Step 26. ActivityManagerService.attachApplication

       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

[java]  view plain copy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     public final void attachApplication(IApplicationThread thread) {  
  7.         synchronized (this) {  
  8.             int callingPid = Binder.getCallingPid();  
  9.             final long origId = Binder.clearCallingIdentity();  
  10.             attachApplicationLocked(thread, callingPid);  
  11.             Binder.restoreCallingIdentity(origId);  
  12.         }  
  13.     }  
  14.   
  15.     ......  
  16.   
  17. }  
        这里将操作转发给attachApplicationLocked函数。

        Step 27. ActivityManagerService.attachApplicationLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：

[java]  view plain copy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     private final boolean attachApplicationLocked(IApplicationThread thread,  
  7.             int pid) {  
  8.         // Find the application record that is being attached...  either via  
  9.         // the pid if we are running in multiple processes, or just pull the  
  10.         // next app record if we are emulating process with anonymous threads.  
  11.         ProcessRecord app;  
  12.         if (pid != MY_PID && pid >= 0) {  
  13.             synchronized (mPidsSelfLocked) {  
  14.                 app = mPidsSelfLocked.get(pid);  
  15.             }  
  16.         } else if (mStartingProcesses.size() > 0) {  
  17.             ......  
  18.         } else {  
  19.             ......  
  20.         }  
  21.   
  22.         if (app == null) {  
  23.             ......  
  24.             return false;  
  25.         }  
  26.   
  27.         ......  
  28.   
  29.         String processName = app.processName;  
  30.         try {  
  31.             thread.asBinder().linkToDeath(new AppDeathRecipient(  
  32.                 app, pid, thread), 0);  
  33.         } catch (RemoteException e) {  
  34.             ......  
  35.             return false;  
  36.         }  
  37.   
  38.         ......  
  39.   
  40.         app.thread = thread;  
  41.         app.curAdj = app.setAdj = -100;  
  42.         app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;  
  43.         app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;  
  44.         app.forcingToForeground = null;  
  45.         app.foregroundServices = false;  
  46.         app.debugging = false;  
  47.   
  48.         ......  
  49.   
  50.         boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);  
  51.   
  52.         ......  
  53.   
  54.         boolean badApp = false;  
  55.         boolean didSomething = false;  
  56.   
  57.         // See if the top visible activity is waiting to run in this process...  
  58.         ActivityRecord hr = mMainStack.topRunningActivityLocked(null);  
  59.         if (hr != null && normalMode) {  
  60.             if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid  
  61.                 && processName.equals(hr.processName)) {  
  62.                     try {  
  63.                         if (mMainStack.realStartActivityLocked(hr, app, true, true)) {  
  64.                             didSomething = true;  
  65.                         }  
  66.                     } catch (Exception e) {  
  67.                         ......  
  68.                     }  
  69.             } else {  
  70.                 ......  
  71.             }  
  72.         }  
  73.   
  74.         ......  
  75.   
  76.         return true;  
  77.     }  
  78.   
  79.     ......  
  80.   
  81. }  

        在前面的Step 23中，已经创建了一个ProcessRecord，这里首先通过pid将它取回来，放在app变量中，然后对app的其它成员进行初始化，最后调用mMainStack.realStartActivityLocked执行真正的Activity启动操作。这里要启动的Activity通过调用mMainStack.topRunningActivityLocked(null)从堆栈顶端取回来，这时候在堆栈顶端的Activity就是MainActivity了。

        Step 28. ActivityStack.realStartActivityLocked

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

[java]  view plain copy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final boolean realStartActivityLocked(ActivityRecord r,  
  6.             ProcessRecord app, boolean andResume, boolean checkConfig)  
  7.             throws RemoteException {  
  8.           
  9.         ......  
  10.   
  11.         r.app = app;  
  12.   
  13.         ......  
  14.   
  15.         int idx = app.activities.indexOf(r);  
  16.         if (idx < 0) {  
  17.             app.activities.add(r);  
  18.         }  
  19.           
  20.         ......  
  21.   
  22.         try {  
  23.             ......  
  24.   
  25.             List<ResultInfo> results = null;  
  26.             List<Intent> newIntents = null;  
  27.             if (andResume) {  
  28.                 results = r.results;  
  29.                 newIntents = r.newIntents;  
  30.             }  
  31.       
  32.             ......  
  33.               
  34.             app.thread.scheduleLaunchActivity(new Intent(r.intent), r,  
  35.                 System.identityHashCode(r),  
  36.                 r.info, r.icicle, results, newIntents, !andResume,  
  37.                 mService.isNextTransitionForward());  
  38.   
  39.             ......  
  40.   
  41.         } catch (RemoteException e) {  
  42.             ......  
  43.         }  
  44.   
  45.         ......  
  46.   
  47.         return true;  
  48.     }  
  49.   
  50.     ......  
  51.   
  52. }  
        这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中，注意，这里的第二个参数r，是一个ActivityRecord类型的Binder对象，用来作来这个Activity的token值。

        Step 29. ApplicationThreadProxy.scheduleLaunchActivity
        这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：

[java]  view plain copy
  1. class ApplicationThreadProxy implements IApplicationThread {  
  2.   
  3.     ......  
  4.   
  5.     public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,  
  6.             ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,  
  7.             List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)  
  8.             throws RemoteException {  
  9.         Parcel data = Parcel.obtain();  
  10.         data.writeInterfaceToken(IApplicationThread.descriptor);  
  11.         intent.writeToParcel(data, 0);  
  12.         data.writeStrongBinder(token);  
  13.         data.writeInt(ident);  
  14.         info.writeToParcel(data, 0);  
  15.         data.writeBundle(state);  
  16.         data.writeTypedList(pendingResults);  
  17.         data.writeTypedList(pendingNewIntents);  
  18.         data.writeInt(notResumed ? 1 : 0);  
  19.         data.writeInt(isForward ? 1 : 0);  
  20.         mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,  
  21.             IBinder.FLAG_ONEWAY);  
  22.         data.recycle();  
  23.     }  
  24.   
  25.     ......  
  26.   
  27. }  
        这个函数最终通过Binder驱动程序进入到ApplicationThread的scheduleLaunchActivity函数中。

        Step 30. ApplicationThread.scheduleLaunchActivity
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final class ApplicationThread extends ApplicationThreadNative {  
  6.   
  7.         ......  
  8.   
  9.         // we use token to identify this activity without having to send the  
  10.         // activity itself back to the activity manager. (matters more with ipc)  
  11.         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,  
  12.                 ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,  
  13.                 List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {  
  14.             ActivityClientRecord r = new ActivityClientRecord();  
  15.   
  16.             r.token = token;  
  17.             r.ident = ident;  
  18.             r.intent = intent;  
  19.             r.activityInfo = info;  
  20.             r.state = state;  
  21.   
  22.             r.pendingResults = pendingResults;  
  23.             r.pendingIntents = pendingNewIntents;  
  24.   
  25.             r.startsNotResumed = notResumed;  
  26.             r.isForward = isForward;  
  27.   
  28.             queueOrSendMessage(H.LAUNCH_ACTIVITY, r);  
  29.         }  
  30.   
  31.         ......  
  32.   
  33.     }  
  34.   
  35.     ......  
  36. }  
         函数首先创建一个ActivityClientRecord实例，并且初始化它的成员变量，然后调用ActivityThread类的queueOrSendMessage函数进一步处理。

         Step 31. ActivityThread.queueOrSendMessage
         这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final class ApplicationThread extends ApplicationThreadNative {  
  6.   
  7.         ......  
  8.   
  9.         // if the thread hasn't started yet, we don't have the handler, so just  
  10.         // save the messages until we're ready.  
  11.         private final void queueOrSendMessage(int what, Object obj) {  
  12.             queueOrSendMessage(what, obj, 0, 0);  
  13.         }  
  14.   
  15.         ......  
  16.   
  17.         private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {  
  18.             synchronized (this) {  
  19.                 ......  
  20.                 Message msg = Message.obtain();  
  21.                 msg.what = what;  
  22.                 msg.obj = obj;  
  23.                 msg.arg1 = arg1;  
  24.                 msg.arg2 = arg2;  
  25.                 mH.sendMessage(msg);  
  26.             }  
  27.         }  
  28.   
  29.         ......  
  30.   
  31.     }  
  32.   
  33.     ......  
  34. }  
        函数把消息内容放在msg中，然后通过mH把消息分发出去，这里的成员变量mH我们在前面已经见过，消息分发出去后，最后会调用H类的handleMessage函数。

        Step 32. H.handleMessage

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final class H extends Handler {  
  6.   
  7.         ......  
  8.   
  9.         public void handleMessage(Message msg) {  
  10.             ......  
  11.             switch (msg.what) {  
  12.             case LAUNCH_ACTIVITY: {  
  13.                 ActivityClientRecord r = (ActivityClientRecord)msg.obj;  
  14.   
  15.                 r.packageInfo = getPackageInfoNoCheck(  
  16.                     r.activityInfo.applicationInfo);  
  17.                 handleLaunchActivity(r, null);  
  18.             } break;  
  19.             ......  
  20.             }  
  21.   
  22.         ......  
  23.   
  24.     }  
  25.   
  26.     ......  
  27. }  
        这里最后调用ActivityThread类的handleLaunchActivity函数进一步处理。

        Step 33. ActivityThread.handleLaunchActivity

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {  
  6.         ......  
  7.   
  8.         Activity a = performLaunchActivity(r, customIntent);  
  9.   
  10.         if (a != null) {  
  11.             r.createdConfig = new Configuration(mConfiguration);  
  12.             Bundle oldState = r.state;  
  13.             handleResumeActivity(r.token, false, r.isForward);  
  14.   
  15.             ......  
  16.         } else {  
  17.             ......  
  18.         }  
  19.     }  
  20.   
  21.     ......  
  22. }  
        这里首先调用performLaunchActivity函数来加载这个Activity类，即shy.luo.activity.MainActivity，然后调用它的onCreate函数，最后回到handleLaunchActivity函数时，再调用handleResumeActivity函数来使这个Activity进入Resumed状态，即会调用这个Activity的onResume函数，这是遵循Activity的生命周期的。

        Step 34. ActivityThread.performLaunchActivity
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

[java]  view plain copy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {  
  6.           
  7.         ActivityInfo aInfo = r.activityInfo;  
  8.         if (r.packageInfo == null) {  
  9.             r.packageInfo = getPackageInfo(aInfo.applicationInfo,  
  10.                 Context.CONTEXT_INCLUDE_CODE);  
  11.         }  
  12.   
  13.         ComponentName component = r.intent.getComponent();  
  14.         if (component == null) {  
  15.             component = r.intent.resolveActivity(  
  16.                 mInitialApplication.getPackageManager());  
  17.             r.intent.setComponent(component);  
  18.         }  
  19.   
  20.         if (r.activityInfo.targetActivity != null) {  
  21.             component = new ComponentName(r.activityInfo.packageName,  
  22.                 r.activityInfo.targetActivity);  
  23.         }  
  24.   
  25.         Activity activity = null;  
  26.         try {  
  27.             java.lang.ClassLoader cl = r.packageInfo.getClassLoader();  
  28.             activity = mInstrumentation.newActivity(  
  29.                 cl, component.getClassName(), r.intent);  
  30.             r.intent.setExtrasClassLoader(cl);  
  31.             if (r.state != null) {  
  32.                 r.state.setClassLoader(cl);  
  33.             }  
  34.         } catch (Exception e) {  
  35.             ......  
  36.         }  
  37.   
  38.         try {  
  39.             Application app = r.packageInfo.makeApplication(false, mInstrumentation);  
  40.   
  41.             ......  
  42.   
  43.             if (activity != null) {  
  44.                 ContextImpl appContext = new ContextImpl();  
  45.                 appContext.init(r.packageInfo, r.token, this);  
  46.                 appContext.setOuterContext(activity);  
  47.                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());  
  48.                 Configuration config = new Configuration(mConfiguration);  
  49.                 ......  
  50.                 activity.attach(appContext, this, getInstrumentation(), r.token,  
  51.                     r.ident, app, r.intent, r.activityInfo, title, r.parent,  
  52.                     r.embeddedID, r.lastNonConfigurationInstance,  
  53.                     r.lastNonConfigurationChildInstances, config);  
  54.   
  55.                 if (customIntent != null) {  
  56.                     activity.mIntent = customIntent;  
  57.                 }  
  58.                 r.lastNonConfigurationInstance = null;  
  59.                 r.lastNonConfigurationChildInstances = null;  
  60.                 activity.mStartedActivity = false;  
  61.                 int theme = r.activityInfo.getThemeResource();  
  62.                 if (theme != 0) {  
  63.                     activity.setTheme(theme);  
  64.                 }  
  65.   
  66.                 activity.mCalled = false;  
  67.                 mInstrumentation.callActivityOnCreate(activity, r.state);  
  68.                 ......  
  69.                 r.activity = activity;  
  70.                 r.stopped = true;  
  71.                 if (!r.activity.mFinished) {  
  72.                     activity.performStart();  
  73.                     r.stopped = false;  
  74.                 }  
  75.                 if (!r.activity.mFinished) {  
  76.                     if (r.state != null) {  
  77.                         mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);  
  78.                     }  
  79.                 }  
  80.                 if (!r.activity.mFinished) {  
  81.                     activity.mCalled = false;  
  82.                     mInstrumentation.callActivityOnPostCreate(activity, r.state);  
  83.                     if (!activity.mCalled) {  
  84.                         throw new SuperNotCalledException(  
  85.                             "Activity " + r.intent.getComponent().toShortString() +  
  86.                             " did not call through to super.onPostCreate()");  
  87.                     }  
  88.                 }  
  89.             }  
  90.             r.paused = true;  
  91.   
  92.             mActivities.put(r.token, r);  
  93.   
  94.         } catch (SuperNotCalledException e) {  
  95.             ......  
  96.   
  97.         } catch (Exception e) {  
  98.             ......  
  99.         }  
  100.   
  101.         return activity;  
  102.     }  
  103.   
  104.     ......  
  105. }  

       函数前面是收集要启动的Activity的相关信息，主要package和component信息：

[java]  view plain copy
  1. ActivityInfo aInfo = r.activityInfo;  
  2. if (r.packageInfo == null) {  
  3.      r.packageInfo = getPackageInfo(aInfo.applicationInfo,  
  4.              Context.CONTEXT_INCLUDE_CODE);  
  5. }  
  6.   

你可能感兴趣的:(Android应用程序启动过程源代码分析)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • 广州会刊小程序开发公司哪家好｜开发多少钱费用｜专业外包服务 红匣子实力推荐
    在选择广州会刊小程序开发公司时，有几个关键因素需要考虑。首先，您应该确定自己的需求和目标，以便找到最合适的开发公司。其次，您需要考虑公司的经验和专业知识。最后，您还应该考虑公司的信誉和口碑。开发-联系电话：13642679953（微信同号）首先，您应该明确自己的需求和目标。会刊小程序是一种用于展示会议信息和日程安排的应用程序。在选择开发公司之前，您应该明确自己的需求，包括功能要求、设计风格和用户体
  • 简介Shell、zsh、bash zhaosuningsn Shellzshbashshelllinuxbash
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • 计算机网络八股总结 Petrichorzncu 八股总结计算机网络笔记
    这里写目录标题网络模型划分（五层和七层）及每一层的功能五层网络模型七层网络模型（OSI模型）==三次握手和四次挥手具体过程及原因==三次握手四次挥手TCP/IP协议组成==UDP协议与TCP/IP协议的区别==Http协议相关知识网络地址，子网掩码等相关计算网络模型划分（五层和七层）及每一层的功能五层网络模型应用层：负责处理网络应用程序，如电子邮件、文件传输和网页浏览。主要协议包括HTTP、FTP
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • 效率神器来了：AI工具手把手教你快速提升工作效能 kkai人工智能 人工智能学习媒体aichatgpt
    随着科技的进步，AI工具已经成为提升工作效率的关键手段。本文将介绍一些实用的AI工具和方法，帮助你自动化繁琐的重复性任务、优化数据管理、促进团队协作与沟通，并提升决策质量。背景：OOPAI-免费问答学习交流-GPT自动化重复性任务Zapier：Zapier可以自动化多个应用程序之间的工作流程。例如，它能自动将Gmail中的附件保存至GoogleDrive，或在你发布新文章时，自动分享至社交媒体平台
  • TC27x启动过程（2）-TC277 赞哥哥s TC277学习笔记gnu单片机
    接上文，继续学习TC277的启动过程。分析启动函数有关用的寄存器说明，参考文章TC27x寄存器学习目录TC27x寄存器学习start函数分析isync汇编指令（同步指令）dsync汇编指令（同步数据），1清除endinit2设置中断堆栈3启用对系统全局寄存器的写访问4初始化SDA基指针5关闭对系统全局寄存器的写访问6关闭看门狗，恢复Endinit位7初始化CSA8初始化ram,拷贝rom数据到ra
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • python实现规则引擎_规则引擎python weixin_39601511 python实现规则引擎
    广告关闭回望2020，你在技术之路上，有什么收获和成长么？对于未来，你有什么期待么？云+社区年度征文，各种定制好礼等你！我正在用python编写日志收集分析应用程序，我需要编写一个“规则引擎”来匹配和处理日志消息。它需要具有以下特点：正则表达式匹配消息本身消息严重性优先级的算术比较布尔运算符我设想一个例子规则可能是这样的：(message~program:messageandseverity>=h
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • 导致格式错误的 Lambda 代理响应的原因以及如何修复它 zqhdz米时空 汇编
    当人们尝试使用AWSAPIGateway和AWSLambda构建无服务器应用程序时，经常出现的一个问题是_由于配置错误而执行失败：Lambda代理响应格式错误。_没有什么比通用错误消息更糟糕的了，它们不会告诉您解决问题所需的任何内容，对吧？AWS并不是以其错误消息设计而闻名，如果甚至可以这样称呼它的话，更不用说为您提供解决问题的方法了。那么如何修复这个Lambda错误以及是什么原因造成的呢？花椒壳
  • Nginx：高性能的Web服务器与反向代理 张某布响丸辣 nginx前端服务器javaSpringBoot
    在当今的互联网世界中，Web服务器的选择对于网站的性能、稳定性和安全性至关重要。Nginx（发音为“engineX”）凭借其卓越的性能、丰富的功能集和灵活的配置选项，成为了众多网站和应用程序的首选Web服务器和反向代理。本文将深入探讨Nginx的特点、应用场景、基本配置以及它如何助力你的Web项目。Nginx简介Nginx是一个开源的、高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • 【Python】tkinter及组件如何使用 小九不懂SAP 我的Python日记python开发语言tkinter
    一、tkinter的应用场景tkinter是Python的标准GUI（图形用户界面）库，它提供了丰富的控件和工具，使得开发者能够轻松创建跨平台的桌面应用程序。以下是一些tkinter的常见应用场景：桌面应用程序开发：开发者可以使用tkinter来创建各种桌面应用程序，如文本编辑器、计算器、图片查看器、游戏等。这些应用程序可以具有复杂的用户界面，包括窗口、按钮、文本框、下拉菜单、滚动条等。数据可视化
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 【JS】前端文件读取FileReader操作总结 程序员-张师傅 前端前端javascript开发语言
    前端文件读取FileReader操作总结FileReader是JavaScript中的一个WebAPI，它允许web应用程序异步读取用户计算机上的文件（或原始数据缓冲区）的内容，例如读取文件以获取其内容，并在不将文件发送到服务器的情况下在客户端使用它。这对于处理图片、文本文件等非常有用，尤其是当你想要在用户界面中即时显示文件内容或进行文件预览时。创建FileReader对象首先，你需要创建一个Fi
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • Go 语言基本架构 Fe_cow丿 Go
    Go基本架构一、Go基本架构：packagemainimport"fmt"funcmain(){fmt.Println("hello,world")}go文件的后缀是.go；packagemain：表示文件所在的包是main；每个Go应用程序都包含一个为main的包；所有包名都应该使用小写字母；import“fmt”：表示引入一个包，包名为fmt，引入该包后，就可以使用fmt包的函数；比如：fmt
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变 黑金IT fastapi微服务fastapi架构
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
  • Kafka详细解析与应用分析 芊言芊语 kafka分布式
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
  • PMP冲刺一 Cynric
    记录考点一、计算类考题一般就1题，主要涉及在三大过程组：启动过程组、规划过程组、控制过程组。1.启动过程组项目选择方法涉及名词：NPV净现值、IRR内部收益率、BCR投资回报率、ROI投资利润率、回收期2.规划过程组三点估算PERT法（默认使用贝塔分布）三角分布：Te=(O+M+P)/3贝塔分布：Te=(O+4M+P)/6关键路径法CPM关键路径是相对的，也可以是变化的。路径汇聚固定资产折旧沟通渠
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他