备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

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

2017-11-08 812
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

       Step 16. ActivityThread.handlePauseActivity

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

 
 
     
  
  1.  public final class ActivityThread {   
    2.  
  
  2.        
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     private final void handlePauseActivity(IBinder token, boolean finished,   
    6.  
  
  6.             boolean userLeaving, int configChanges) {   
    7.  
  
  7.    
    8.  
  
  8.         ActivityClientRecord r = mActivities.get(token);   
    9.  
  
  9.         if (r != null) {   
    10.  
  
  10.             //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);   
    11.  
  
  11.             if (userLeaving) {   
    12.  
  
  12.                 performUserLeavingActivity(r);   
    13.  
  
  13.             }   
    14.  
  
  14.    
    15.  
  
  15.             r.activity.mConfigChangeFlags |= configChanges;   
    16.  
  
  16.             Bundle state = performPauseActivity(token, finished, true);   
    17.  
  
  17.    
    18.  
  
  18.             // Make sure any pending writes are now committed.   
    19.  
  
  19.             QueuedWork.waitToFinish();   
    20.  
  
  20.    
    21.  
  
  21.             // Tell the activity manager we have paused.   
    22.  
  
  22.             try {   
    23.  
  
  23.                 ActivityManagerNative.getDefault().activityPaused(token, state);   
    24.  
  
  24.             } catch (RemoteException ex) {   
    25.  
  
  25.             }   
    26.  
  
  26.         }   
    27.  
  
  27.     }   
    28.  
  
  28.    
    29.  
  
  29.     ......   
    30.  
  
  30.    
    31.  
  
  31. }   
    32.  
 
 
 
         函数首先将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文件中：
 
 
 
 
     
  
  1.  class ActivityManagerProxy implements IActivityManager   
    2.  
  
  2. {   
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     public void activityPaused(IBinder token, Bundle state) throws RemoteException   
    6.  
  
  6.     {   
    7.  
  
  7.         Parcel data = Parcel.obtain();   
    8.  
  
  8.         Parcel reply = Parcel.obtain();   
    9.  
  
  9.         data.writeInterfaceToken(IActivityManager.descriptor);   
    10.  
  
  10.         data.writeStrongBinder(token);   
    11.  
  
  11.         data.writeBundle(state);   
    12.  
  
  12.         mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);   
    13.  
  
  13.         reply.readException();   
    14.  
  
  14.         data.recycle();   
    15.  
  
  15.         reply.recycle();   
    16.  
  
  16.     }   
    17.  
  
  17.    
    18.  
  
  18.     ......   
    19.  
  
  19.    
    20.  
  
  20. }   
    21.  
 
 
 

 
        这里通过Binder进程间通信机制就进入到ActivityManagerService.activityPaused函数中去了。
 
 
        Step 18. ActivityManagerService.activityPaused
 
 
        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
 
 
 
 
     
  
  1.  public final class ActivityManagerService extends ActivityManagerNative   
    2.  
  
  2.             implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     public final void activityPaused(IBinder token, Bundle icicle) {   
    6.  
  
  6.            
    7.  
  
  7.         ......   
    8.  
  
  8.    
    9.  
  
  9.         final long origId = Binder.clearCallingIdentity();   
    10.  
  
  10.         mMainStack.activityPaused(token, icicle, false);   
    11.  
  
  11.            
    12.  
  
  12.         ......   
    13.  
  
  13.     }   
    14.  
  
  14.    
    15.  
  
  15.     ......   
    16.  
  
  16.    
    17.  
  
  17. }   
    18.  
 
 
 

 
       这里，又再次进入到ActivityStack类中，执行activityPaused函数。       Step 19. ActivityStack.activityPaused
 
 
       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
 
 
 
 
     
  
  1. public class ActivityStack {   
    2.  
  
  2.    
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {   
    6.  
  
  6.            
    7.  
  
  7.         ......   
    8.  
  
  8.    
    9.  
  
  9.         ActivityRecord r = null;   
    10.  
  
  10.    
    11.  
  
  11.         synchronized (mService) {   
    12.  
  
  12.             int index = indexOfTokenLocked(token);   
    13.  
  
  13.             if (index >= 0) {   
    14.  
  
  14.                 r = (ActivityRecord)mHistory.get(index);   
    15.  
  
  15.                 if (!timeout) {   
    16.  
  
  16.                     r.icicle = icicle;   
    17.  
  
  17.                     r.haveState = true;   
    18.  
  
  18.                 }   
    19.  
  
  19.                 mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);   
    20.  
  
  20.                 if (mPausingActivity == r) {   
    21.  
  
  21.                     r.state = ActivityState.PAUSED;   
    22.  
  
  22.                     completePauseLocked();   
    23.  
  
  23.                 } else {   
    24.  
  
  24.                     ......   
    25.  
  
  25.                 }   
    26.  
  
  26.             }   
    27.  
  
  27.         }   
    28.  
  
  28.     }   
    29.  
  
  29.    
    30.  
  
  30.     ......   
    31.  
  
  31.    
    32.  
  
  32. }   
    33.  
 
 
 
       这里通过参数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文件中：
 
 
 
 
     
  
  1. public class ActivityStack {   
    2.  
  
  2.    
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     private final void completePauseLocked() {   
    6.  
  
  6.         ActivityRecord prev = mPausingActivity;   
    7.  
  
  7.            
    8.  
  
  8.         ......   
    9.  
  
  9.    
    10.  
  
  10.         if (prev != null) {   
    11.  
  
  11.    
    12.  
  
  12.             ......   
    13.  
  
  13.    
    14.  
  
  14.             mPausingActivity = null;   
    15.  
  
  15.         }   
    16.  
  
  16.    
    17.  
  
  17.         if (!mService.mSleeping && !mService.mShuttingDown) {   
    18.  
  
  18.             resumeTopActivityLocked(prev);   
    19.  
  
  19.         } else {   
    20.  
  
  20.             ......   
    21.  
  
  21.         }   
    22.  
  
  22.    
    23.  
  
  23.         ......   
    24.  
  
  24.     }   
    25.  
  
  25.    
    26.  
  
  26.     ......   
    27.  
  
  27.    
    28.  
  
  28. }   
    29.  
 
 
 
 
 
 
        函数首先把mPausingActivity变量清空，因为现在不需要它了，然后调用resumeTopActivityLokced进一步操作，它传入的参数即为代表Launcher这个Activity的ActivityRecord。
 
 
        Step 21. ActivityStack.resumeTopActivityLokced
         这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：
 
 
 
 
     
  
  1. public class ActivityStack {   
    2.  
  
  2.    
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     final boolean resumeTopActivityLocked(ActivityRecord prev) {   
    6.  
  
  6.         ......   
    7.  
  
  7.    
    8.  
  
  8.         // Find the first activity that is not finishing.   
    9.  
  
  9.         ActivityRecord next = topRunningActivityLocked(null);   
    10.  
  
  10.    
    11.  
  
  11.         // Remember how we'll process this pause/resume situation, and ensure   
    12.  
  
  12.         // that the state is reset however we wind up proceeding.   
    13.  
  
  13.         final boolean userLeaving = mUserLeaving;   
    14.  
  
  14.         mUserLeaving = false;   
    15.  
  
  15.    
    16.  
  
  16.         ......   
    17.  
  
  17.    
    18.  
  
  18.         next.delayedResume = false;   
    19.  
  
  19.    
    20.  
  
  20.         // If the top activity is the resumed one, nothing to do.   
    21.  
  
  21.         if (mResumedActivity == next && next.state == ActivityState.RESUMED) {   
    22.  
  
  22.             ......   
    23.  
  
  23.             return false;   
    24.  
  
  24.         }   
    25.  
  
  25.    
    26.  
  
  26.         // If we are sleeping, and there is no resumed activity, and the top   
    27.  
  
  27.         // activity is paused, well that is the state we want.   
    28.  
  
  28.         if ((mService.mSleeping || mService.mShuttingDown)   
    29.  
  
  29.             && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {   
    30.  
  
  30.             ......   
    31.  
  
  31.             return false;   
    32.  
  
  32.         }   
    33.  
  
  33.    
    34.  
  
  34.         .......   
    35.  
  
  35.    
    36.  
  
  36.    
    37.  
  
  37.         // We need to start pausing the current activity so the top one   
    38.  
  
  38.         // can be resumed...   
    39.  
  
  39.         if (mResumedActivity != null) {   
    40.  
  
  40.             ......   
    41.  
  
  41.             return true;   
    42.  
  
  42.         }   
    43.  
  
  43.    
    44.  
  
  44.         ......   
    45.  
  
  45.    
    46.  
  
  46.    
    47.  
  
  47.         if (next.app != null && next.app.thread != null) {   
    48.  
  
  48.             ......   
    49.  
  
  49.    
    50.  
  
  50.         } else {   
    51.  
  
  51.             ......   
    52.  
  
  52.             startSpecificActivityLocked(next, true, true);   
    53.  
  
  53.         }   
    54.  
  
  54.    
    55.  
  
  55.         return true;   
    56.  
  
  56.     }   
    57.  
  
  57.    
    58.  
  
  58.    
    59.  
  
  59.     ......   
    60.  
  
  60.    
    61.  
  
  61. }   
    62.  
 
 
 
 
 
 
        通过上面的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文件中：
 
 
 
 
     
  
  1. public class ActivityStack {   
    2.  
  
  2.    
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     private final void startSpecificActivityLocked(ActivityRecord r,   
    6.  
  
  6.             boolean andResume, boolean checkConfig) {   
    7.  
  
  7.         // Is this activity's application already running?   
    8.  
  
  8.         ProcessRecord app = mService.getProcessRecordLocked(r.processName,   
    9.  
  
  9.             r.info.applicationInfo.uid);   
    10.  
  
  10.    
    11.  
  
  11.         ......   
    12.  
  
  12.    
    13.  
  
  13.         if (app != null && app.thread != null) {   
    14.  
  
  14.             try {   
    15.  
  
  15.                 realStartActivityLocked(r, app, andResume, checkConfig);   
    16.  
  
  16.                 return;   
    17.  
  
  17.             } catch (RemoteException e) {   
    18.  
  
  18.                 ......   
    19.  
  
  19.             }   
    20.  
  
  20.         }   
    21.  
  
  21.    
    22.  
  
  22.         mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,   
    23.  
  
  23.             "activity", r.intent.getComponent(), false);   
    24.  
  
  24.     }   
    25.  
  
  25.    
    26.  
  
  26.    
    27.  
  
  27.     ......   
    28.  
  
  28.    
    29.  
  
  29. }   
    30.  
 
 
 
 
 
 
       注意，这里由于是第一次启动应用程序的Activity，所以下面语句：
 
 
 
 
     
  
  1. ProcessRecord app = mService.getProcessRecordLocked(r.processName,   
    2.  
  
  2.     r.info.applicationInfo.uid);   
    3.  
 
 
 
        取回来的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文件中：
 
 
 
 
     
  
  1. public final class ActivityManagerService extends ActivityManagerNative   
    2.  
  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
    3.  
  
  3.    
    4.  
  
  4.     ......   
    5.  
  
  5.    
    6.  
  
  6.     final ProcessRecord startProcessLocked(String processName,   
    7.  
  
  7.             ApplicationInfo info, boolean knownToBeDead, int intentFlags,   
    8.  
  
  8.             String hostingType, ComponentName hostingName, boolean allowWhileBooting) {   
    9.  
  
  9.    
    10.  
  
  10.         ProcessRecord app = getProcessRecordLocked(processName, info.uid);   
    11.  
  
  11.            
    12.  
  
  12.         ......   
    13.  
  
  13.    
    14.  
  
  14.         String hostingNameStr = hostingName != null   
    15.  
  
  15.             ? hostingName.flattenToShortString() : null;   
    16.  
  
  16.    
    17.  
  
  17.         ......   
    18.  
  
  18.    
    19.  
  
  19.         if (app == null) {   
    20.  
  
  20.             app = new ProcessRecordLocked(null, info, processName);   
    21.  
  
  21.             mProcessNames.put(processName, info.uid, app);   
    22.  
  
  22.         } else {   
    23.  
  
  23.             // If this is a new package in the process, add the package to the list   
    24.  
  
  24.             app.addPackage(info.packageName);   
    25.  
  
  25.         }   
    26.  
  
  26.    
    27.  
  
  27.         ......   
    28.  
  
  28.    
    29.  
  
  29.         startProcessLocked(app, hostingType, hostingNameStr);   
    30.  
  
  30.         return (app.pid != 0) ? app : null;   
    31.  
  
  31.     }   
    32.  
  
  32.    
    33.  
  
  33.     ......   
    34.  
  
  34.    
    35.  
  
  35. }   
    36.  
 
 
 
 
 
 
        这里再次检查是否已经有以process + uid命名的进程存在，在我们这个情景中，返回值app为null，因此，后面会创建一个ProcessRecord，并存保存在成员变量mProcessNames中，最后，调用另一个startProcessLocked函数进一步操作：
 
 
 
 
     
  
  1. public final class ActivityManagerService extends ActivityManagerNative   
    2.  
  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
    3.  
  
  3.    
    4.  
  
  4.     ......   
    5.  
  
  5.    
    6.  
  
  6.     private final void startProcessLocked(ProcessRecord app,   
    7.  
  
  7.                 String hostingType, String hostingNameStr) {   
    8.  
  
  8.    
    9.  
  
  9.         ......   
    10.  
  
  10.    
    11.  
  
  11.         try {   
    12.  
  
  12.             int uid = app.info.uid;   
    13.  
  
  13.             int[] gids = null;   
    14.  
  
  14.             try {   
    15.  
  
  15.                 gids = mContext.getPackageManager().getPackageGids(   
    16.  
  
  16.                     app.info.packageName);   
    17.  
  
  17.             } catch (PackageManager.NameNotFoundException e) {   
    18.  
  
  18.                 ......   
    19.  
  
  19.             }   
    20.  
  
  20.                
    21.  
  
  21.             ......   
    22.  
  
  22.    
    23.  
  
  23.             int debugFlags = 0;   
    24.  
  
  24.                
    25.  
  
  25.             ......   
    26.  
  
  26.                
    27.  
  
  27.             int pid = Process.start("android.app.ActivityThread",   
    28.  
  
  28.                 mSimpleProcessManagement ? app.processName : null, uid, uid,   
    29.  
  
  29.                 gids, debugFlags, null);   
    30.  
  
  30.                
    31.  
  
  31.             ......   
    32.  
  
  32.    
    33.  
  
  33.         } catch (RuntimeException e) {   
    34.  
  
  34.                
    35.  
  
  35.             ......   
    36.  
  
  36.    
    37.  
  
  37.         }   
    38.  
  
  38.     }   
    39.  
  
  39.    
    40.  
  
  40.     ......   
    41.  
  
  41.    
    42.  
  
  42. }   
    43.  
 
 
 
        这里主要是调用Process.start接口来创建一个新的进程，新的进程会导入android.app.ActivityThread类，并且执行它的main函数，这就是为什么我们前面说每一个应用程序都有一个ActivityThread实例来对应的原因。
 
 
        Step 24. ActivityThread.main
 
 
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：
 
 
 
 
     
  
  1. public final class ActivityThread {   
    2.  
  
  2.    
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     private final void attach(boolean system) {   
    6.  
  
  6.         ......   
    7.  
  
  7.    
    8.  
  
  8.         mSystemThread = system;   
    9.  
  
  9.         if (!system) {   
    10.  
  
  10.    
    11.  
  
  11.             ......   
    12.  
  
  12.    
    13.  
  
  13.             IActivityManager mgr = ActivityManagerNative.getDefault();   
    14.  
  
  14.             try {   
    15.  
  
  15.                 mgr.attachApplication(mAppThread);   
    16.  
  
  16.             } catch (RemoteException ex) {   
    17.  
  
  17.             }   
    18.  
  
  18.         } else {   
    19.  
  
  19.    
    20.  
  
  20.             ......   
    21.  
  
  21.    
    22.  
  
  22.         }   
    23.  
  
  23.     }   
    24.  
  
  24.    
    25.  
  
  25.     ......   
    26.  
  
  26.    
    27.  
  
  27.     public static final void main(String[] args) {   
    28.  
  
  28.            
    29.  
  
  29.         .......   
    30.  
  
  30.    
    31.  
  
  31.         ActivityThread thread = new ActivityThread();   
    32.  
  
  32.         thread.attach(false);   
    33.  
  
  33.    
    34.  
  
  34.         ......   
    35.  
  
  35.    
    36.  
  
  36.         Looper.loop();   
    37.  
  
  37.    
    38.  
  
  38.         .......   
    39.  
  
  39.    
    40.  
  
  40.         thread.detach();   
    41.  
  
  41.            
    42.  
  
  42.         ......   
    43.  
  
  43.     }   
    44.  
  
  44. }   
    45.  
 
 
 
 
 
 
       这个函数在进程中创建一个ActivityThread实例，然后调用它的attach函数，接着就进入消息循环了，直到最后进程退出。
 
 
       函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的attachApplication函数，传入的参数是mAppThread，这是一个ApplicationThread类型的Binder对象，它的作用是用来进行进程间通信的。
 
 
      Step 25. ActivityManagerProxy.attachApplication
 
 
      这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：
 
 
 
 
     
  
  1. class ActivityManagerProxy implements IActivityManager   
    2.  
  
  2. {   
    3.  
  
  3.     ......   
    4.  
  
  4.    
    5.  
  
  5.     public void attachApplication(IApplicationThread app) throws RemoteException   
    6.  
  
  6.     {   
    7.  
  
  7.         Parcel data = Parcel.obtain();   
    8.  
  
  8.         Parcel reply = Parcel.obtain();   
    9.  
  
  9.         data.writeInterfaceToken(IActivityManager.descriptor);   
    10.  
  
  10.         data.writeStrongBinder(app.asBinder());   
    11.  
  
  11.         mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);   
    12.  
  
  12.         reply.readException();   
    13.  
  
  13.         data.recycle();   
    14.  
  
  14.         reply.recycle();   
    15.  
  
  15.     }   
    16.  
  
  16.    
    17.  
  
  17.     ......   
    18.  
  
  18.    
    19.  
  
  19. }   
    20.  
 
 
 
 
 
 
       这里通过Binder驱动程序，最后进入ActivityManagerService的attachApplication函数中。
 
 
       Step 26. ActivityManagerService.attachApplication
 
 
       这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
 
 
 
 
     
  
  1. public final class ActivityManagerService extends ActivityManagerNative   
    2.  
  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
    3.  
  
  3.    
    4.  
  
  4.     ......   
    5.  
  
  5.    
    6.  
  
  6.     public final void attachApplication(IApplicationThread thread) {   
    7.  
  
  7.         synchronized (this) {   
    8.  
  
  8.             int callingPid = Binder.getCallingPid();   
    9.  
  
  9.             final long origId = Binder.clearCallingIdentity();   
    10.  
  
  10.             attachApplicationLocked(thread, callingPid);   
    11.  
  
  11.             Binder.restoreCallingIdentity(origId);   
    12.  
  
  12.         }   
    13.  
  
  13.     }   
    14.  
  
  14.    
    15.  
  
  15.     ......   
    16.  
  
  16.    
    17.  
  
  17. }   
    18.  
 
 
 
 
 
 
      这里将操作转发给attachApplicationLocked函数。
 
 
        Step 27. ActivityManagerService.attachApplicationLocked
 
 
        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：
 
 
 
 
     
  
  1. public final class ActivityManagerService extends ActivityManagerNative   
    2.  
  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
    3.  
  
  3.    
    4.  
  
  4.     ......   
    5.  
  
  5.    
    6.  
  
  6.     private final boolean attachApplicationLocked(IApplicationThread thread,   
    7.  
  
  7.             int pid) {   
    8.  
  
  8.         // Find the application record that is being attached...  either via   
    9.  
  
  9.         // the pid if we are running in multiple processes, or just pull the   
    10.  
  
  10.         // next app record if we are emulating process with anonymous threads.   
    11.  
  
  11.         ProcessRecord app;   
    12.  
  
  12.         if (pid != MY_PID && pid >= 0) {   
    13.  
  
  13.             synchronized (mPidsSelfLocked) {   
    14.  
  
  14.                 app = mPidsSelfLocked.get(pid);   
    15.  
  
  15.             }   
    16.  
  
  16.         } else if (mStartingProcesses.size() > 0) {   
    17.  
  
  17.             ......   
    18.  
  
  18.         } else {   
    19.  
  
  19.             ......   
    20.  
  
  20.         }   
    21.  
  
  21.    
    22.  
  
  22.         if (app == null) {   
    23.  
  
  23.             ......   
    24.  
  
  24.             return false;   
    25.  
  
  25.         }   
    26.  
  
  26.    
    27.  
  
  27.         ......   
    28.  
  
  28.    
    29.  
  
  29.         String processName = app.processName;   
    30.  
  
  30.         try {   
    31.  
  
  31.             thread.asBinder().linkToDeath(new AppDeathRecipient(   
    32.  
  
  32.                 app, pid, thread), 0);   
    33.  
  
  33.         } catch (RemoteException e) {   
    34.  
  
  34.             ......   
    35.  
  
  35.             return false;   
    36.  
  
  36.         }   
    37.  
  
  37.    
    38.  
  
  38.         ......   
    39.  
  
  39.    
    40.  
  
  40.         app.thread = thread;   
    41.  
  
  41.         app.curAdj = app.setAdj = -100;   
    42.  
  
  42.         app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;   
    43.  
  
  43.         app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;   
    44.  
  
  44.         app.forcingToForeground = null;   
    45.  
  
  45.         app.foregroundServices = false;   
    46.  
  
  46.         app.debugging = false;   
    47.  
  
  47.    
    48.  
  
  48.         ......   
    49.  
  
  49.    
    50.  
  
  50.         boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);   
    51.  
  
  51.    
    52.  
  
  52.         ......   
    53.  
  
  53.    
    54.  
  
  54.         boolean badApp = false;   
    55.  
  
  55.         boolean didSomething = false;   
    56.  
  
  56.    
    57.  
  
  57.         // See if the top visible activity is waiting to run in this process...   
    58.  
  
  58.         ActivityRecord hr = mMainStack.topRunningActivityLocked(null);   
    59.  
  
  59.         if (hr != null && normalMode) {   
    60.  
  
  60.             if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid   
    61.  
  
  61.                 && processName.equals(hr.processName)) {   
    62.  
  
  62.                     try {   
    63.  
  
  63.                         if (mMainStack.realStartActivityLocked(hr, app, true, true)) {   
    64.  
  
  64.                             didSomething = true;   
    65.  
  
  65.                         }   
    66.  
  
  66.                     } catch (Exception e) {   
    67.  
  
  67.                         ......   
    68.  
  
  68.                     }   
    69.  
  
  69.             } else {   
    70.  
  
  70.                 ......   
    71.  
  
  71.             }   
    72.  
  
  72.         }   
    73.  
  
  73.    
    74.  
  
  74.         ......   
    75.  
  
  75.    
    76.  
  
  76.         return true;   
    77.  
  
  77.     }   
    78.  
  
  78.    
    79.  
  
  79.     ......   
    80.  
  
  80.    
    81.  
  
  81. }   
    82.  
 
 
 
 
 
 
        在前面的Step 23中，已经创建了一个ProcessRecord，这里首先通过pid将它取回来，放在app变量中，然后对app的其它成员进行初始化，最后调用mMainStack.realStartActivityLocked执行真正的Activity启动操作。这里要启动的Activity通过调用mMainStack.topRunningActivityLocked(null)从堆栈顶端取回来，这时候在堆栈顶端的Activity就是MainActivity了。
 

 


 


 


 


 


 


 


 


 


 本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/965990，如需转载请自行联系原作者

 


 



                        
                    

                    
                        

                            

    
文章标签：

    

        

            Android开发
        

        

            Java
        

    



                            

    
关键词：

    

        

            Android应用
        

        

            Android分析
        

        

            Android应用程序
        

        

            Android启动过程
        

        

            Android启动
        

    



                            
                        

                        
                        
                    
                

                


                

                    

                        

                            
                                
                            
                            

                        

                        余二五
                        

                        

                    

                    

                        

                            

                            
目录

                        

                        

                    

                

                

                    

                


                

    
相关文章

    

        

            

                

                    一歲抬頭
                    
                

                |
                
2天前

                |
                

                    Android开发
                

            

            

                

                    
                        Android源代码定制：Overlay目录定制|调试Overlay资源是否生效
                    
                    
Android源代码定制：Overlay目录定制|调试Overlay资源是否生效

                    

                        

                            

                                一歲抬頭
                                
                            

                            8
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    一歲抬頭
                    
                

                |
                
2天前

                |
                

                    存储
                    缓存
                    安全
                

            

            

                

                    
                        Android系统 应用存储路径与权限
                    
                    
Android系统 应用存储路径与权限

                    

                        

                            

                                一歲抬頭
                                
                            

                            5
                            0
                            
                        

                    

                

                
                    Android系统 应用存储路径与权限
                
            

        

        

            

                

                    一歲抬頭
                    
                

                |
                
2天前

                |
                

                    存储
                    安全
                    Android开发
                

            

            

                

                    
                        Android系统 自定义系统和应用权限
                    
                    
Android系统 自定义系统和应用权限

                    

                        

                            

                                一歲抬頭
                                
                            

                            14
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    一歲抬頭
                    
                

                |
                
2天前

                |
                

                    存储
                    Java
                    Android开发
                

            

            

                

                    
                        Android系统 设置第三方应用为默认Launcher实现和原理分析
                    
                    
Android系统 设置第三方应用为默认Launcher实现和原理分析

                    

                        

                            

                                一歲抬頭
                                
                            

                            9
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    一歲抬頭
                    
                

                |
                
2天前

                |
                

                    存储
                    Java
                    Linux
                

            

            

                

                    
                        Android系统获取event事件回调等几种实现和原理分析
                    
                    
Android系统获取event事件回调等几种实现和原理分析

                    

                        

                            

                                一歲抬頭
                                
                            

                            16
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    一歲抬頭
                    
                

                |
                
2天前

                |
                

                    Android开发
                

            

            

                

                    
                        Android源代码定制：添加customize.mk文件进行分项目和分客户的定制
                    
                    
Android源代码定制：添加customize.mk文件进行分项目和分客户的定制

                    

                        

                            

                                一歲抬頭
                                
                            

                            2
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    游客799
                    
                

                |
                
7天前

                |
                

                    缓存
                    移动开发
                    Android开发
                

            

            

                

                    
                        构建高效Android应用：从优化用户体验到提升性能表现
                    
                    
【4月更文挑战第18天】
在移动开发的世界中，打造一个既快速又流畅的Android应用并非易事。本文深入探讨了如何通过一系列创新的技术策略来提升应用性能和用户体验。我们将从用户界面(UI)设计的简约性原则出发，探索响应式布局和Material Design的实践，再深入剖析后台任务处理、内存管理和电池寿命优化的技巧。此外，文中还将讨论最新的Android Jetpack组件如何帮助开发者更高效地构建高质量的应用。此内容不仅适合经验丰富的开发者深化理解，也适合初学者构建起对Android高效开发的基础认识。



                    

                        

                            

                                游客799
                                
                            

                            5
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    游客799
                    
                

                |
                
7天前

                |
                

                    移动开发
                    Android开发
                    开发者
                

            

            

                

                    
                        构建高效Android应用：采用Kotlin进行内存优化的策略
                    
                    
【4月更文挑战第18天】
在移动开发领域，性能优化一直是开发者关注的焦点。特别是对于Android应用而言，由于设备和版本的多样性，确保应用流畅运行且占用资源少是一大挑战。本文将探讨使用Kotlin语言开发Android应用时，如何通过内存优化来提升应用性能。我们将从减少不必要的对象创建、合理使用数据结构、避免内存泄漏等方面入手，提供实用的代码示例和最佳实践，帮助开发者构建更加高效的Android应用。



                    

                        

                            

                                游客799
                                
                            

                            11
                            0
                            
                        

                    

                

                
            

        

        

            

                

                    我不是游客20240119
                    
                

                |
                
8天前

                |
                

                    缓存
                    移动开发
                    Java
                

            

            

                

                    
                        构建高效的Android应用：内存优化策略
                    
                    
【4月更文挑战第16天】
在移动开发领域，尤其是针对资源有限的Android设备，内存优化是提升应用性能和用户体验的关键因素。本文将深入探讨Android应用的内存管理机制，分析常见的内存泄漏问题，并提出一系列实用的内存优化技巧。通过这些策略的实施，开发者可以显著减少应用的内存占用，避免不必要的后台服务，以及提高垃圾回收效率，从而延长设备的电池寿命并确保应用的流畅运行。



                    

                        

                            

                                我不是游客20240119
                                
                            

                            15
                            1
                            
                        

                    

                

                
            

        

        

            

                

                    桃李春风一杯酒
                    
                

                |
                
10天前

                |
                

                    搜索推荐
                    开发工具
                    Android开发
                

            

            

                

                    
                        安卓即时应用(Instant Apps)开发指南
                    
                    
【4月更文挑战第14天】Android Instant Apps让用户体验部分应用功能而无需完整下载。开发者需将应用拆分成模块，基于已上线的基础应用构建。使用Android Studio的Instant Apps Feature Library定义模块特性，优化代码与资源以减小模块大小，同步管理即时应用和基础应用的版本。经过测试，可发布至Google Play Console，提升用户便利性，创造新获客机会。

                    

                        

                            

                                桃李春风一杯酒
                                
                            

                            18
                            1