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

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

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

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

        Step 1. Launcher.startActivitySafely

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

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

  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文件中配置的:

  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文件中:

  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文件中:

  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文件中:

  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.                 null0, token, target != null ? target.mEmbeddedID : null,   
  17.                 requestCode, falsefalse);   
  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文件中:

  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文件中:

  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, nullnull);   
  14.     }   
  15.    
  16.    
  17.     ......   
  18.    
  19. }   

        这里只是简单地将操作转发给成员变量mMainStack的startActivityMayWait函数,这里的mMainStack的类型为ActivityStack。

        Step 7. ActivityStack.startActivityMayWait

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

  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变量中:

  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进一步处理了。