1. 全栈程序员必看首页

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

全栈程序员-用户IM • • 未分类

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

         Step 28. ActivityStack.realStartActivityLocked

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

 
     
  1. public class ActivityStack {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     final boolean realStartActivityLocked(ActivityRecord r,   
    6.  
  6.             Proce***ecord app, boolean andResume, boolean checkConfig)   
    7.  
  7.             throws RemoteException {   
    8.  
  8.            
    9.  
  9.         ……   
    10.  
  10.    
    11.  
  11.         r.app = app;   
    12.  
  12.    
    13.  
  13.         ……   
    14.  
  14.    
    15.  
  15.         int idx = app.activities.indexOf(r);   
    16.  
  16.         if (idx < 0) {   
    17.  
  17.             app.activities.add(r);   
    18.  
  18.         }   
    19.  
  19.            
    20.  
  20.         ……   
    21.  
  21.    
    22.  
  22.         try {   
    23.  
  23.             ……   
    24.  
  24.    
    25.  
  25.             List<ResultInfo> results = null;   
    26.  
  26.             List<Intent> newIntents = null;   
    27.  
  27.             if (andResume) {   
    28.  
  28.                 results = r.results;   
    29.  
  29.                 newIntents = r.newIntents;   
    30.  
  30.             }   
    31.  
  31.        
    32.  
  32.             ……   
    33.  
  33.                
    34.  
  34.             app.thread.scheduleLaunchActivity(new Intent(r.intent), r,   
    35.  
  35.                 System.identityHashCode(r),   
    36.  
  36.                 r.info, r.icicle, results, newIntents, !andResume,   
    37.  
  37.                 mService.isNextTransitionForward());   
    38.  
  38.    
    39.  
  39.             ……   
    40.  
  40.    
    41.  
  41.         } catch (RemoteException e) {   
    42.  
  42.             ……   
    43.  
  43.         }   
    44.  
  44.    
    45.  
  45.         ……   
    46.  
  46.    
    47.  
  47.         return true;   
    48.  
  48.     }   
    49.  
  49.    
    50.  
  50.     ……   
    51.  
  51.    
    52.  
  52. }   
    53.  
 
        这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中，注意，这里的第二个参数r，是一个ActivityRecord类型的Binder对象，用来作来这个Activity的token值。
 
        Step 29. ApplicationThreadProxy.scheduleLaunchActivity
         这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中：
 
 
     
  1. class ApplicationThreadProxy implements IApplicationThread {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,   
    6.  
  6.             ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,   
    7.  
  7.             List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)   
    8.  
  8.             throws RemoteException {   
    9.  
  9.         Parcel data = Parcel.obtain();   
    10.  
  10.         data.writeInterfaceToken(IApplicationThread.descriptor);   
    11.  
  11.         intent.writeToParcel(data, 0);   
    12.  
  12.         data.writeStrongBinder(token);   
    13.  
  13.         data.writeInt(ident);   
    14.  
  14.         info.writeToParcel(data, 0);   
    15.  
  15.         data.writeBundle(state);   
    16.  
  16.         data.writeTypedList(pendingResults);   
    17.  
  17.         data.writeTypedList(pendingNewIntents);   
    18.  
  18.         data.writeInt(notResumed ? 1 : 0);   
    19.  
  19.         data.writeInt(isForward ? 1 : 0);   
    20.  
  20.         mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,   
    21.  
  21.             IBinder.FLAG_ONEWAY);   
    22.  
  22.         data.recycle();   
    23.  
  23.     }   
    24.  
  24.    
    25.  
  25.     ……   
    26.  
  26.    
    27.  
  27. }   
    28.  
 
 
 
        这个函数最终通过Binder驱动程序进入到ApplicationThread的scheduleLaunchActivity函数中。
 
        Step 30. ApplicationThread.scheduleLaunchActivity
         这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：
 
 
     
  1. public final class ActivityThread {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     private final class ApplicationThread extends ApplicationThreadNative {   
    6.  
  6.    
    7.  
  7.         ……   
    8.  
  8.    
    9.  
  9.         // we use token to identify this activity without having to send the   
    10.  
  10.         // activity itself back to the activity manager. (matters more with ipc)   
    11.  
  11.         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,   
    12.  
  12.                 ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,   
    13.  
  13.                 List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {   
    14.  
  14.             ActivityClientRecord r = new ActivityClientRecord();   
    15.  
  15.    
    16.  
  16.             r.token = token;   
    17.  
  17.             r.ident = ident;   
    18.  
  18.             r.intent = intent;   
    19.  
  19.             r.activityInfo = info;   
    20.  
  20.             r.state = state;   
    21.  
  21.    
    22.  
  22.             r.pendingResults = pendingResults;   
    23.  
  23.             r.pendingIntents = pendingNewIntents;   
    24.  
  24.    
    25.  
  25.             r.startsNotResumed = notResumed;   
    26.  
  26.             r.isForward = isForward;   
    27.  
  27.    
    28.  
  28.             queueOrSendMessage(H.LAUNCH_ACTIVITY, r);   
    29.  
  29.         }   
    30.  
  30.    
    31.  
  31.         ……   
    32.  
  32.    
    33.  
  33.     }   
    34.  
  34.    
    35.  
  35.     ……   
    36.  
  36. }   
    37.  
 
 
 
         函数首先创建一个ActivityClientRecord实例，并且初始化它的成员变量，然后调用ActivityThread类的queueOrSendMessage函数进一步处理。
 
         Step 31. ActivityThread.queueOrSendMessage
          这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：
 
 
     
  1. public final class ActivityThread {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     private final class ApplicationThread extends ApplicationThreadNative {   
    6.  
  6.    
    7.  
  7.         ……   
    8.  
  8.    
    9.  
  9.         // if the thread hasn’t started yet, we don’t have the handler, so just   
    10.  
  10.         // save the messages until we’re ready.   
    11.  
  11.         private final void queueOrSendMessage(int what, Object obj) {   
    12.  
  12.             queueOrSendMessage(what, obj, 0, 0);   
    13.  
  13.         }   
    14.  
  14.    
    15.  
  15.         ……   
    16.  
  16.    
    17.  
  17.         private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {   
    18.  
  18.             synchronized (this) {   
    19.  
  19.                 ……   
    20.  
  20.                 Message msg = Message.obtain();   
    21.  
  21.                 msg.what = what;   
    22.  
  22.                 msg.obj = obj;   
    23.  
  23.                 msg.arg1 = arg1;   
    24.  
  24.                 msg.arg2 = arg2;   
    25.  
  25.                 mH.sendMessage(msg);   
    26.  
  26.             }   
    27.  
  27.         }   
    28.  
  28.    
    29.  
  29.         ……   
    30.  
  30.    
    31.  
  31.     }   
    32.  
  32.    
    33.  
  33.     ……   
    34.  
  34. }   
    35.  
 
 
 
        函数把消息内容放在msg中，然后通过mH把消息分发出去，这里的成员变量mH我们在前面已经见过，消息分发出去后，最后会调用H类的handleMessage函数。
 
        Step 32. H.handleMessage
 
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：
 
 
     
  1. public final class ActivityThread {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     private final class H extends Handler {   
    6.  
  6.    
    7.  
  7.         ……   
    8.  
  8.    
    9.  
  9.         public void handleMessage(Message msg) {   
    10.  
  10.             ……   
    11.  
  11.             switch (msg.what) {   
    12.  
  12.             case LAUNCH_ACTIVITY: {   
    13.  
  13.                 ActivityClientRecord r = (ActivityClientRecord)msg.obj;   
    14.  
  14.    
    15.  
  15.                 r.packageInfo = getPackageInfoNoCheck(   
    16.  
  16.                     r.activityInfo.applicationInfo);   
    17.  
  17.                 handleLaunchActivity(r, null);   
    18.  
  18.             } break;   
    19.  
  19.             ……   
    20.  
  20.             }   
    21.  
  21.    
    22.  
  22.         ……   
    23.  
  23.    
    24.  
  24.     }   
    25.  
  25.    
    26.  
  26.     ……   
    27.  
  27. }   
    28.  
 
 
 
       这里最后调用ActivityThread类的handleLaunchActivity函数进一步处理。
 
        Step 33. ActivityThread.handleLaunchActivity
 
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：
 
 
     
  1. public final class ActivityThread {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {   
    6.  
  6.         ……   
    7.  
  7.    
    8.  
  8.         Activity a = performLaunchActivity(r, customIntent);   
    9.  
  9.    
    10.  
  10.         if (a != null) {   
    11.  
  11.             r.createdConfig = new Configuration(mConfiguration);   
    12.  
  12.             Bundle oldState = r.state;   
    13.  
  13.             handleResumeActivity(r.token, false, r.isForward);   
    14.  
  14.    
    15.  
  15.             ……   
    16.  
  16.         } else {   
    17.  
  17.             ……   
    18.  
  18.         }   
    19.  
  19.     }   
    20.  
  20.    
    21.  
  21.     ……   
    22.  
  22. }   
    23.  
 
 
 
       这里首先调用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文件中：
 
 
     
  1. public final class ActivityThread {   
    2.  
  2.    
    3.  
  3.     ……   
    4.  
  4.    
    5.  
  5.     private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {   
    6.  
  6.            
    7.  
  7.         ActivityInfo aInfo = r.activityInfo;   
    8.  
  8.         if (r.packageInfo == null) {   
    9.  
  9.             r.packageInfo = getPackageInfo(aInfo.applicationInfo,   
    10.  
  10.                 Context.CONTEXT_INCLUDE_CODE);   
    11.  
  11.         }   
    12.  
  12.    
    13.  
  13.         ComponentName component = r.intent.getComponent();   
    14.  
  14.         if (component == null) {   
    15.  
  15.             component = r.intent.resolveActivity(   
    16.  
  16.                 mInitialApplication.getPackageManager());   
    17.  
  17.             r.intent.setComponent(component);   
    18.  
  18.         }   
    19.  
  19.    
    20.  
  20.         if (r.activityInfo.targetActivity != null) {   
    21.  
  21.             component = new ComponentName(r.activityInfo.packageName,   
    22.  
  22.                 r.activityInfo.targetActivity);   
    23.  
  23.         }   
    24.  
  24.    
    25.  
  25.         Activity activity = null;   
    26.  
  26.         try {   
    27.  
  27.             java.lang.ClassLoader cl = r.packageInfo.getClassLoader();   
    28.  
  28.             activity = mInstrumentation.newActivity(   
    29.  
  29.                 cl, component.getClassName(), r.intent);   
    30.  
  30.             r.intent.setExtrasClassLoader(cl);   
    31.  
  31.             if (r.state != null) {   
    32.  
  32.                 r.state.setClassLoader(cl);   
    33.  
  33.             }   
    34.  
  34.         } catch (Exception e) {   
    35.  
  35.             ……   
    36.  
  36.         }   
    37.  
  37.    
    38.  
  38.         try {   
    39.  
  39.             Application app = r.packageInfo.makeApplication(false, mInstrumentation);   
    40.  
  40.    
    41.  
  41.             ……   
    42.  
  42.    
    43.  
  43.             if (activity != null) {   
    44.  
  44.                 ContextImpl appContext = new ContextImpl();   
    45.  
  45.                 appContext.init(r.packageInfo, r.token, this);   
    46.  
  46.                 appContext.setOuterContext(activity);   
    47.  
  47.                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());   
    48.  
  48.                 Configuration config = new Configuration(mConfiguration);   
    49.  
  49.                 ……   
    50.  
  50.                 activity.attach(appContext, this, getInstrumentation(), r.token,   
    51.  
  51.                     r.ident, app, r.intent, r.activityInfo, title, r.parent,   
    52.  
  52.                     r.embeddedID, r.lastNonConfigurationInstance,   
    53.  
  53.                     r.lastNonConfigurationChildInstances, config);   
    54.  
  54.    
    55.  
  55.                 if (customIntent != null) {   
    56.  
  56.                     activity.mIntent = customIntent;   
    57.  
  57.                 }   
    58.  
  58.                 r.lastNonConfigurationInstance = null;   
    59.  
  59.                 r.lastNonConfigurationChildInstances = null;   
    60.  
  60.                 activity.mStartedActivity = false;   
    61.  
  61.                 int theme = r.activityInfo.getThemeResource();   
    62.  
  62.                 if (theme != 0) {   
    63.  
  63.                     activity.setTheme(theme);   
    64.  
  64.                 }   
    65.  
  65.    
    66.  
  66.                 activity.mCalled = false;   
    67.  
  67.                 mInstrumentation.callActivityOnCreate(activity, r.state);   
    68.  
  68.                 ……   
    69.  
  69.                 r.activity = activity;   
    70.  
  70.                 r.stopped = true;   
    71.  
  71.                 if (!r.activity.mFinished) {   
    72.  
  72.                     activity.performStart();   
    73.  
  73.                     r.stopped = false;   
    74.  
  74.                 }   
    75.  
  75.                 if (!r.activity.mFinished) {   
    76.  
  76.                     if (r.state != null) {   
    77.  
  77.                         mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);   
    78.  
  78.                     }   
    79.  
  79.                 }   
    80.  
  80.                 if (!r.activity.mFinished) {   
    81.  
  81.                     activity.mCalled = false;   
    82.  
  82.                     mInstrumentation.callActivityOnPostCreate(activity, r.state);   
    83.  
  83.                     if (!activity.mCalled) {   
    84.  
  84.                         throw new SuperNotCalledException(   
    85.  
  85.                             “Activity “ + r.intent.getComponent().toShortString() +   
    86.  
  86.                             ” did not call through to super.onPostCreate()”);   
    87.  
  87.                     }   
    88.  
  88.                 }   
    89.  
  89.             }   
    90.  
  90.             r.paused = true;   
    91.  
  91.    
    92.  
  92.             mActivities.put(r.token, r);   
    93.  
  93.    
    94.  
  94.         } catch (SuperNotCalledException e) {   
    95.  
  95.             ……   
    96.  
  96.    
    97.  
  97.         } catch (Exception e) {   
    98.  
  98.             ……   
    99.  
  99.         }   
    100.  
  100.    
    101.  
  101.         return activity;   
    102.  
  102.     }   
    103.  
  103.    
    104.  
  104.     ……   
    105.  
  105. }   
    106.  
 
 
 
       函数前面是收集要启动的Activity的相关信息，主要package和component信息：
 
 
     
  1. ActivityInfo aInfo = r.activityInfo;   
    2.  
  2. if (r.packageInfo == null) {   
    3.  
  3.      r.packageInfo = getPackageInfo(aInfo.applicationInfo,   
    4.  
  4.              Context.CONTEXT_INCLUDE_CODE);   
    5.  
  5. }   
    6.  
  6.    
    7.  
  7. ComponentName component = r.intent.getComponent();   
    8.  
  8. if (component == null) {   
    9.  
  9.     component = r.intent.resolveActivity(   
    10.  
  10.         mInitialApplication.getPackageManager());   
    11.  
  11.     r.intent.setComponent(component);   
    12.  
  12. }   
    13.  
  13.    
    14.  
  14. if (r.activityInfo.targetActivity != null) {   
    15.  
  15.     component = new ComponentName(r.activityInfo.packageName,   
    16.  
  16.             r.activityInfo.targetActivity);   
    17.  
  17. }   
    18.  
 
     然后通过ClassLoader将shy.luo.activity.MainActivity类加载进来：
 
 
     
  1.   Activity activity = null;   
    2.  
  2.   try {   
    3.  
  3. java.lang.ClassLoader cl = r.packageInfo.getClassLoader();   
    4.  
  4. activity = mInstrumentation.newActivity(   
    5.  
  5.     cl, component.getClassName(), r.intent);   
    6.  
  6. r.intent.setExtrasClassLoader(cl);   
    7.  
  7. if (r.state != null) {   
    8.  
  8.     r.state.setClassLoader(cl);   
    9.  
  9. }   
    10.  
  10.   } catch (Exception e) {   
    11.  
  11. ……   
    12.  
  12.   }   
    13.  
 
   接下来是创建Application对象，这是根据AndroidManifest.xml配置文件中的Application标签的信息来创建的：
 
 
     
  1. Application app = r.packageInfo.makeApplication(false, mInstrumentation);   
    2.  
 
 后面的代码主要创建Activity的上下文信息，并通过attach方法将这些上下文信息设置到MainActivity中去：
 
 
     
  1.   activity.attach(appContext, this, getInstrumentation(), r.token,   
    2.  
  2. r.ident, app, r.intent, r.activityInfo, title, r.parent,   
    3.  
  3. r.embeddedID, r.lastNonConfigurationInstance,   
    4.  
  4. r.lastNonConfigurationChildInstances, config);   
    5.  
 
      最后还要调用MainActivity的onCreate函数：
 
 
     
  1. mInstrumentation.callActivityOnCreate(activity, r.state);   
    2.  
 
      这里不是直接调用MainActivity的onCreate函数，而是通过mInstrumentation的callActivityOnCreate函数来间接调用，前面我们说过，mInstrumentation在这里的作用是监控Activity与系统的交互操作，相当于是系统运行日志。
 
 
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。 
发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/110569.html原文链接：https://javaforall.cn
 
 【正版授权，激活自己账号】：  Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛  
 
 【官方授权 正版激活】：  官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...  


 赞 (0)




  全栈程序员-用户IM全栈程序员-用户IM 


  0  0
 









相关推荐




发表回复
您的电子邮箱地址不会被公开。 


  










                                                                        
 关注全栈程序员社区公众号