devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android程序入口ActivityThread和Android应用程序启动流程详解_update_package_compatibility_info

作者：小丑西瓜9 | 2024-03-02 01:19:20

赞

踩

update_package_compatibility_info

          大家初学java时候都知道java的程序入口是从main方法进入,那么Android是基于java编写的,那Android的程序入口做了哪些操作呢?还有Android的应用程序到底是怎样启动的呢?我们一起来看一下.

首先附上ActivityThread.java的main方法:

  1. public static void main(String[] args) {
  2.         Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain"); 
  3.         SamplingProfilerIntegration.start(); 
  4.  
  5.         // CloseGuard defaults to true and can be quite spammy.  We
  6.         // disable it here, but selectively enable it later (via
  7.         // StrictMode) on debug builds, but using DropBox, not logs.
  8.         CloseGuard.setEnabled(false);
  9.  
  10.         Environment.initForCurrentUser();
  11.  
  12.         // Set the reporter for event logging in libcore
  13.         EventLogger.setReporter(new EventLoggingReporter());
  14.  
  15.         AndroidKeyStoreProvider.install();
  16.  
  17.         // Make sure TrustedCertificateStore looks in the right place for CA certificates
  18.         final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
  19.         TrustedCertificateStore.setDefaultUserDirectory(configDir);
  20.  
  21.         Process.setArgV0("<pre-initialized>");
  22.  
  23.         Looper.prepareMainLooper(); //实例化Looper并设置到ThreadLocal里面,赋值MainLooper
  24.         
  25.         ActivityThread thread = new ActivityThread();  //实例化一个ActivityThread
  26.         thread.attach(false);      //主要是获取AMS接口 然后设置ApplicationThread 的接口 给AMS和应用程序通信
  27.  
  28.         if (sMainThreadHandler == null) {    
  29.             sMainThreadHandler = thread.getHandler();  //设置MainHandler 是一些接受生命周期的方法
  30.         }
  31.  
  32.         if (false) { 
  33.             Looper.myLooper().setMessageLogging(new
  34.                     LogPrinter(Log.DEBUG, "ActivityThread"));
  35.         }
  36.  
  37.         // End of event ActivityThreadMain.
  38.         Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  39.         Looper.loop();  //开始接收消息
  40.  
  41.         throw new RuntimeException("Main thread loop unexpectedly exited");
  42.     }

首先我们看第23行:

Looper.prepareMainLooper();

做Android的都知道Looper是handler机制的一个组件

(那么这里就延伸了一个问题,子线程里面能不能创建Handler呢?答案是可以的,但是必须要创建Looper,那么就有人问了,为什么主线程里面不用创建呢?看了Android的代码以后知道了,原来Android已经默默的给创建好了,Android的组件的生命周期也都是由Handler来调用的,下面就会看到)

那么我们来看一下prepareMainLooper()都做了一些什么事情:

  1. public static void prepareMainLooper() {
  2.         prepare(false);
  3.         synchronized (Looper.class) {
  4.             if (sMainLooper != null) {
  5.                 throw new IllegalStateException("The main Looper has already been prepared.");
  6.             }
  7.             sMainLooper = myLooper();
  8.         }
  9. }
  1. private static void prepare(boolean quitAllowed) {
  2.         if (sThreadLocal.get() != null) {
  3.             throw new RuntimeException("Only one Looper may be created per thread");
  4.         }
  5.         sThreadLocal.set(new Looper(quitAllowed));
  6. }
  1. /**
  2.      * Return the Looper object associated with the current thread.  Returns
  3.      * null if the calling thread is not associated with a Looper.
  4.      */
  5.     public static @Nullable Looper myLooper() {
  6.         return sThreadLocal.get();
  7. }

  1. private Looper(boolean quitAllowed) {
  2.         mQueue = new MessageQueue(quitAllowed);
  3.         mThread = Thread.currentThread();
  4. }


好大家看进入了prepareMainLooper以后首先调用了prepare方法,在prepare方法里面判断了sThreadLocal!=null以后才往下走,这就解释了一个线程只能有一个Looper,实例化了一个Looper并设置给sThreadLocal,那么看到Looper的构造方法里面创建了MessageQueue一个消息队列和获取当前的线程Thread并赋值.

然后在prepareMainLooper下面又执行了一句代码把刚才创建的Looper赋值给sMainLooper.

(这个sMainLooper就是主线程的Looper也就是UI线程的Looper,在开发Android应用时有时也会获取它和当前线程的Looper比较,可以知道当前是不是在主线程....额...有点跑题了)

那么这段代码就结束了,我们继续往下看.

第25行实例化了ActivityThread对象:

第26行调用了AcitivityThread对象的attach方法,那么来看一下究竟做了什么:

  1. private void attach(boolean system) {
  2.         sCurrentActivityThread = this;
  3.         mSystemThread = system;
  4.         if (!system) {
  5.             ViewRootImpl.addFirstDrawHandler(new Runnable() {
  6.                 @Override
  7.                 public void run() {
  8.                     ensureJitEnabled();
  9.                 }
  10.             });
  11.             android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
  12.                                                     UserHandle.myUserId());
  13.             RuntimeInit.setApplicationObject(mAppThread.asBinder());
  14.             final IActivityManager mgr = ActivityManagerNative.getDefault();
  15.             try {
  16.                 mgr.attachApplication(mAppThread);
  17.             } catch (RemoteException ex) {
  18.                 // Ignore
  19.             }
  20.             // Watch for getting close to heap limit.
  21.             BinderInternal.addGcWatcher(new Runnable() {
  22.                 @Override public void run() {
  23.                     if (!mSomeActivitiesChanged) {
  24.                         return;
  25.                     }
  26.                     Runtime runtime = Runtime.getRuntime();
  27.                     long dalvikMax = runtime.maxMemory();
  28.                     long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
  29.                     if (dalvikUsed > ((3*dalvikMax)/4)) {
  30.                         if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
  31.                                 + " total=" + (runtime.totalMemory()/1024)
  32.                                 + " used=" + (dalvikUsed/1024));
  33.                         mSomeActivitiesChanged = false;
  34.                         try {
  35.                             mgr.releaseSomeActivities(mAppThread);
  36.                         } catch (RemoteException e) {
  37.                         }
  38.                     }
  39.                 }
  40.             });
  41.         } else {
  42.             // Don't set application object here -- if the system crashes,
  43.             // we can't display an alert, we just want to die die die.
  44.             android.ddm.DdmHandleAppName.setAppName("system_process",
  45.                     UserHandle.myUserId());
  46.             try {
  47.                 mInstrumentation = new Instrumentation();
  48.                 ContextImpl context = ContextImpl.createAppContext(
  49.                         this, getSystemContext().mPackageInfo);
  50.                 mInitialApplication = context.mPackageInfo.makeApplication(true, null);
  51.                 mInitialApplication.onCreate();
  52.             } catch (Exception e) {
  53.                 throw new RuntimeException(
  54.                         "Unable to instantiate Application():" + e.toString(), e);
  55.             }
  56.         }
  57.  
  58.         // add dropbox logging to libcore
  59.         DropBox.setReporter(new DropBoxReporter());
  60.  
  61.         ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
  62.             @Override
  63.             public void onConfigurationChanged(Configuration newConfig) {
  64.                 synchronized (mResourcesManager) {
  65.                     // We need to apply this change to the resources
  66.                     // immediately, because upon returning the view
  67.                     // hierarchy will be informed about it.
  68.                     if (mResourcesManager.applyConfigurationToResourcesLocked(newConfig, null)) {
  69.                         // This actually changed the resources!  Tell
  70.                         // everyone about it.
  71.                         if (mPendingConfiguration == null ||
  72.                                 mPendingConfiguration.isOtherSeqNewer(newConfig)) {
  73.                             mPendingConfiguration = newConfig;
  74.  
  75.                             sendMessage(H.CONFIGURATION_CHANGED, newConfig);
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.             @Override
  81.             public void onLowMemory() {
  82.             }
  83.             @Override
  84.             public void onTrimMemory(int level) {
  85.             }
  86.         });
  87. }
调用的时候参数传递false说明不是系统调用的,那么我们就看if语句块里面的,主要就看14行和16行的代码:

 final IActivityManager mgr = ActivityManagerNative.getDefault();        
 mgr.attachApplication(mAppThread);

那么这两句代码首先Android系统中存在一个ActivityManagerService(简称AMS)(大白话就叫Activity管理服务),他是来调度Android程序里面的Activity的开启等工作.

那么ActivityManagerNative.getDefault()就是获取了这个ActivityManagerService的Binder接口(Binder:跨进程通信),然后调用了attachApplication传入了一个mAppThread.

那么这个mAppThread是什么呢?

它是ApplicationThread在全局声明并初始化,这个东西也是一个继承了Binder的类,把他传递给AMS,以后AMS就拿这个东西和应用程序进行通信.
            

然后再回到ActivityThread的代码中,设置了一个sMainThreadHandler,这个thread.getHandler()方法返回了一个名为H的继承自Handler的一个类:

  1. private class H extends Handler {
  2.         public static final int LAUNCH_ACTIVITY         = 100;
  3.         public static final int PAUSE_ACTIVITY          = 101;
  4.         public static final int PAUSE_ACTIVITY_FINISHING= 102;
  5.         public static final int STOP_ACTIVITY_SHOW      = 103;
  6.         public static final int STOP_ACTIVITY_HIDE      = 104;
  7.         public static final int SHOW_WINDOW             = 105;
  8.         public static final int HIDE_WINDOW             = 106;
  9.         public static final int RESUME_ACTIVITY         = 107;
  10.         public static final int SEND_RESULT             = 108;
  11.         public static final int DESTROY_ACTIVITY        = 109;
  12.         public static final int BIND_APPLICATION        = 110;
  13.         public static final int EXIT_APPLICATION        = 111;
  14.         public static final int NEW_INTENT              = 112;
  15.         public static final int RECEIVER                = 113;
  16.         public static final int CREATE_SERVICE          = 114;
  17.         public static final int SERVICE_ARGS            = 115;
  18.         public static final int STOP_SERVICE            = 116;
  19.  
  20.         public static final int CONFIGURATION_CHANGED   = 118;
  21.         public static final int CLEAN_UP_CONTEXT        = 119;
  22.         public static final int GC_WHEN_IDLE            = 120;
  23.         public static final int BIND_SERVICE            = 121;
  24.         public static final int UNBIND_SERVICE          = 122;
  25.         public static final int DUMP_SERVICE            = 123;
  26.         public static final int LOW_MEMORY              = 124;
  27.         public static final int ACTIVITY_CONFIGURATION_CHANGED = 125;
  28.         public static final int RELAUNCH_ACTIVITY       = 126;
  29.         public static final int PROFILER_CONTROL        = 127;
  30.         public static final int CREATE_BACKUP_AGENT     = 128;
  31.         public static final int DESTROY_BACKUP_AGENT    = 129;
  32.         public static final int SUICIDE                 = 130;
  33.         public static final int REMOVE_PROVIDER         = 131;
  34.         public static final int ENABLE_JIT              = 132;
  35.         public static final int DISPATCH_PACKAGE_BROADCAST = 133;
  36.         public static final int SCHEDULE_CRASH          = 134;
  37.         public static final int DUMP_HEAP               = 135;
  38.         public static final int DUMP_ACTIVITY           = 136;
  39.         public static final int SLEEPING                = 137;
  40.         public static final int SET_CORE_SETTINGS       = 138;
  41.         public static final int UPDATE_PACKAGE_COMPATIBILITY_INFO = 139;
  42.         public static final int TRIM_MEMORY             = 140;
  43.         public static final int DUMP_PROVIDER           = 141;
  44.         public static final int UNSTABLE_PROVIDER_DIED  = 142;
  45.         public static final int REQUEST_ASSIST_CONTEXT_EXTRAS = 143;
  46.         public static final int TRANSLUCENT_CONVERSION_COMPLETE = 144;
  47.         public static final int INSTALL_PROVIDER        = 145;
  48.         public static final int ON_NEW_ACTIVITY_OPTIONS = 146;
  49.         public static final int CANCEL_VISIBLE_BEHIND = 147;
  50.         public static final int BACKGROUND_VISIBLE_BEHIND_CHANGED = 148;
  51.         public static final int ENTER_ANIMATION_COMPLETE = 149;
  52.  
  53.         String codeToString(int code) {
  54.             if (DEBUG_MESSAGES) {
  55.                 switch (code) {
  56.                     case LAUNCH_ACTIVITY: return "LAUNCH_ACTIVITY";
  57.                     case PAUSE_ACTIVITY: return "PAUSE_ACTIVITY";
  58.                     case PAUSE_ACTIVITY_FINISHING: return "PAUSE_ACTIVITY_FINISHING";
  59.                     case STOP_ACTIVITY_SHOW: return "STOP_ACTIVITY_SHOW";
  60.                     case STOP_ACTIVITY_HIDE: return "STOP_ACTIVITY_HIDE";
  61.                     case SHOW_WINDOW: return "SHOW_WINDOW";
  62.                     case HIDE_WINDOW: return "HIDE_WINDOW";
  63.                     case RESUME_ACTIVITY: return "RESUME_ACTIVITY";
  64.                     case SEND_RESULT: return "SEND_RESULT";
  65.                     case DESTROY_ACTIVITY: return "DESTROY_ACTIVITY";
  66.                     case BIND_APPLICATION: return "BIND_APPLICATION";
  67.                     case EXIT_APPLICATION: return "EXIT_APPLICATION";
  68.                     case NEW_INTENT: return "NEW_INTENT";
  69.                     case RECEIVER: return "RECEIVER";
  70.                     case CREATE_SERVICE: return "CREATE_SERVICE";
  71.                     case SERVICE_ARGS: return "SERVICE_ARGS";
  72.                     case STOP_SERVICE: return "STOP_SERVICE";
  73.                     case CONFIGURATION_CHANGED: return "CONFIGURATION_CHANGED";
  74.                     case CLEAN_UP_CONTEXT: return "CLEAN_UP_CONTEXT";
  75.                     case GC_WHEN_IDLE: return "GC_WHEN_IDLE";
  76.                     case BIND_SERVICE: return "BIND_SERVICE";
  77.                     case UNBIND_SERVICE: return "UNBIND_SERVICE";
  78.                     case DUMP_SERVICE: return "DUMP_SERVICE";
  79.                     case LOW_MEMORY: return "LOW_MEMORY";
  80.                     case ACTIVITY_CONFIGURATION_CHANGED: return "ACTIVITY_CONFIGURATION_CHANGED";
  81.                     case RELAUNCH_ACTIVITY: return "RELAUNCH_ACTIVITY";
  82.                     case PROFILER_CONTROL: return "PROFILER_CONTROL";
  83.                     case CREATE_BACKUP_AGENT: return "CREATE_BACKUP_AGENT";
  84.                     case DESTROY_BACKUP_AGENT: return "DESTROY_BACKUP_AGENT";
  85.                     case SUICIDE: return "SUICIDE";
  86.                     case REMOVE_PROVIDER: return "REMOVE_PROVIDER";
  87.                     case ENABLE_JIT: return "ENABLE_JIT";
  88.                     case DISPATCH_PACKAGE_BROADCAST: return "DISPATCH_PACKAGE_BROADCAST";
  89.                     case SCHEDULE_CRASH: return "SCHEDULE_CRASH";
  90.                     case DUMP_HEAP: return "DUMP_HEAP";
  91.                     case DUMP_ACTIVITY: return "DUMP_ACTIVITY";
  92.                     case SLEEPING: return "SLEEPING";
  93.                     case SET_CORE_SETTINGS: return "SET_CORE_SETTINGS";
  94.                     case UPDATE_PACKAGE_COMPATIBILITY_INFO: return "UPDATE_PACKAGE_COMPATIBILITY_INFO";
  95.                     case TRIM_MEMORY: return "TRIM_MEMORY";
  96.                     case DUMP_PROVIDER: return "DUMP_PROVIDER";
  97.                     case UNSTABLE_PROVIDER_DIED: return "UNSTABLE_PROVIDER_DIED";
  98.                     case REQUEST_ASSIST_CONTEXT_EXTRAS: return "REQUEST_ASSIST_CONTEXT_EXTRAS";
  99.                     case TRANSLUCENT_CONVERSION_COMPLETE: return "TRANSLUCENT_CONVERSION_COMPLETE";
  100.                     case INSTALL_PROVIDER: return "INSTALL_PROVIDER";
  101.                     case ON_NEW_ACTIVITY_OPTIONS: return "ON_NEW_ACTIVITY_OPTIONS";
  102.                     case CANCEL_VISIBLE_BEHIND: return "CANCEL_VISIBLE_BEHIND";
  103.                     case BACKGROUND_VISIBLE_BEHIND_CHANGED: return "BACKGROUND_VISIBLE_BEHIND_CHANGED";
  104.                     case ENTER_ANIMATION_COMPLETE: return "ENTER_ANIMATION_COMPLETE";
  105.                 }
  106.             }
  107.             return Integer.toString(code);
  108.         }
  109.         public void handleMessage(Message msg) {
  110.             if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
  111.             switch (msg.what) {
  112.                 case LAUNCH_ACTIVITY: {
  113.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
  114.                     final ActivityClientRecord r = (ActivityClientRecord) msg.obj;
  115.  
  116.                     r.packageInfo = getPackageInfoNoCheck(
  117.                             r.activityInfo.applicationInfo, r.compatInfo);
  118.                     handleLaunchActivity(r, null);
  119.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  120.                 } break;
  121.                 case RELAUNCH_ACTIVITY: {
  122.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");
  123.                     ActivityClientRecord r = (ActivityClientRecord)msg.obj;
  124.                     handleRelaunchActivity(r);
  125.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  126.                 } break;
  127.                 case PAUSE_ACTIVITY:
  128.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
  129.                     handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,
  130.                             (msg.arg1&2) != 0);
  131.                     maybeSnapshot();
  132.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  133.                     break;
  134.                 case PAUSE_ACTIVITY_FINISHING:
  135.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
  136.                     handlePauseActivity((IBinder)msg.obj, true, (msg.arg1&1) != 0, msg.arg2,
  137.                             (msg.arg1&1) != 0);
  138.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  139.                     break;
  140.                 case STOP_ACTIVITY_SHOW:
  141.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
  142.                     handleStopActivity((IBinder)msg.obj, true, msg.arg2);
  143.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  144.                     break;
  145.                 case STOP_ACTIVITY_HIDE:
  146.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");
  147.                     handleStopActivity((IBinder)msg.obj, false, msg.arg2);
  148.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  149.                     break;
  150.                 case SHOW_WINDOW:
  151.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityShowWindow");
  152.                     handleWindowVisibility((IBinder)msg.obj, true);
  153.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  154.                     break;
  155.                 case HIDE_WINDOW:
  156.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityHideWindow");
  157.                     handleWindowVisibility((IBinder)msg.obj, false);
  158.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  159.                     break;
  160.                 case RESUME_ACTIVITY:
  161.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
  162.                     handleResumeActivity((IBinder) msg.obj, true, msg.arg1 != 0, true);
  163.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  164.                     break;
  165.                 case SEND_RESULT:
  166.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDeliverResult");
  167.                     handleSendResult((ResultData)msg.obj);
  168.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  169.                     break;
  170.                 case DESTROY_ACTIVITY:
  171.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityDestroy");
  172.                     handleDestroyActivity((IBinder)msg.obj, msg.arg1 != 0,
  173.                             msg.arg2, false);
  174.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  175.                     break;
  176.                 case BIND_APPLICATION:
  177.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
  178.                     AppBindData data = (AppBindData)msg.obj;
  179.                     handleBindApplication(data);
  180.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  181.                     break;
  182.                 case EXIT_APPLICATION:
  183.                     if (mInitialApplication != null) {
  184.                         mInitialApplication.onTerminate();
  185.                     }
  186.                     Looper.myLooper().quit();
  187.                     break;
  188.                 case NEW_INTENT:
  189.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityNewIntent");
  190.                     handleNewIntent((NewIntentData)msg.obj);
  191.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  192.                     break;
  193.                 case RECEIVER:
  194.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp");
  195.                     handleReceiver((ReceiverData)msg.obj);
  196.                     maybeSnapshot();
  197.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  198.                     break;
  199.                 case CREATE_SERVICE:
  200.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceCreate");
  201.                     handleCreateService((CreateServiceData)msg.obj);
  202.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  203.                     break;
  204.                 case BIND_SERVICE:
  205.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
  206.                     handleBindService((BindServiceData)msg.obj);
  207.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  208.                     break;
  209.                 case UNBIND_SERVICE:
  210.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceUnbind");
  211.                     handleUnbindService((BindServiceData)msg.obj);
  212.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  213.                     break;
  214.                 case SERVICE_ARGS:
  215.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStart");
  216.                     handleServiceArgs((ServiceArgsData)msg.obj);
  217.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  218.                     break;
  219.                 case STOP_SERVICE:
  220.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop");
  221.                     handleStopService((IBinder)msg.obj);
  222.                     maybeSnapshot();
  223.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  224.                     break;
  225.                 case CONFIGURATION_CHANGED:
  226.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "configChanged");
  227.                     mCurDefaultDisplayDpi = ((Configuration)msg.obj).densityDpi;
  228.                     handleConfigurationChanged((Configuration)msg.obj, null);
  229.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  230.                     break;
  231.                 case CLEAN_UP_CONTEXT:
  232.                     ContextCleanupInfo cci = (ContextCleanupInfo)msg.obj;
  233.                     cci.context.performFinalCleanup(cci.who, cci.what);
  234.                     break;
  235.                 case GC_WHEN_IDLE:
  236.                     scheduleGcIdler();
  237.                     break;
  238.                 case DUMP_SERVICE:
  239.                     handleDumpService((DumpComponentInfo)msg.obj);
  240.                     break;
  241.                 case LOW_MEMORY:
  242.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "lowMemory");
  243.                     handleLowMemory();
  244.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  245.                     break;
  246.                 case ACTIVITY_CONFIGURATION_CHANGED:
  247.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityConfigChanged");
  248.                     handleActivityConfigurationChanged((ActivityConfigChangeData)msg.obj);
  249.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  250.                     break;
  251.                 case PROFILER_CONTROL:
  252.                     handleProfilerControl(msg.arg1 != 0, (ProfilerInfo)msg.obj, msg.arg2);
  253.                     break;
  254.                 case CREATE_BACKUP_AGENT:
  255.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupCreateAgent");
  256.                     handleCreateBackupAgent((CreateBackupAgentData)msg.obj);
  257.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  258.                     break;
  259.                 case DESTROY_BACKUP_AGENT:
  260.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "backupDestroyAgent");
  261.                     handleDestroyBackupAgent((CreateBackupAgentData)msg.obj);
  262.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  263.                     break;
  264.                 case SUICIDE:
  265.                     Process.killProcess(Process.myPid());
  266.                     break;
  267.                 case REMOVE_PROVIDER:
  268.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "providerRemove");
  269.                     completeRemoveProvider((ProviderRefCount)msg.obj);
  270.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  271.                     break;
  272.                 case ENABLE_JIT:
  273.                     ensureJitEnabled();
  274.                     break;
  275.                 case DISPATCH_PACKAGE_BROADCAST:
  276.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastPackage");
  277.                     handleDispatchPackageBroadcast(msg.arg1, (String[])msg.obj);
  278.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  279.                     break;
  280.                 case SCHEDULE_CRASH:
  281.                     throw new RemoteServiceException((String)msg.obj);
  282.                 case DUMP_HEAP:
  283.                     handleDumpHeap(msg.arg1 != 0, (DumpHeapData)msg.obj);
  284.                     break;
  285.                 case DUMP_ACTIVITY:
  286.                     handleDumpActivity((DumpComponentInfo)msg.obj);
  287.                     break;
  288.                 case DUMP_PROVIDER:
  289.                     handleDumpProvider((DumpComponentInfo)msg.obj);
  290.                     break;
  291.                 case SLEEPING:
  292.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "sleeping");
  293.                     handleSleeping((IBinder)msg.obj, msg.arg1 != 0);
  294.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  295.                     break;
  296.                 case SET_CORE_SETTINGS:
  297.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "setCoreSettings");
  298.                     handleSetCoreSettings((Bundle) msg.obj);
  299.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  300.                     break;
  301.                 case UPDATE_PACKAGE_COMPATIBILITY_INFO:
  302.                     handleUpdatePackageCompatibilityInfo((UpdateCompatibilityData)msg.obj);
  303.                     break;
  304.                 case TRIM_MEMORY:
  305.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "trimMemory");
  306.                     handleTrimMemory(msg.arg1);
  307.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  308.                     break;
  309.                 case UNSTABLE_PROVIDER_DIED:
  310.                     handleUnstableProviderDied((IBinder)msg.obj, false);
  311.                     break;
  312.                 case REQUEST_ASSIST_CONTEXT_EXTRAS:
  313.                     handleRequestAssistContextExtras((RequestAssistContextExtras)msg.obj);
  314.                     break;
  315.                 case TRANSLUCENT_CONVERSION_COMPLETE:
  316.                     handleTranslucentConversionComplete((IBinder)msg.obj, msg.arg1 == 1);
  317.                     break;
  318.                 case INSTALL_PROVIDER:
  319.                     handleInstallProvider((ProviderInfo) msg.obj);
  320.                     break;
  321.                 case ON_NEW_ACTIVITY_OPTIONS:
  322.                     Pair<IBinder, ActivityOptions> pair = (Pair<IBinder, ActivityOptions>) msg.obj;
  323.                     onNewActivityOptions(pair.first, pair.second);
  324.                     break;
  325.                 case CANCEL_VISIBLE_BEHIND:
  326.                     handleCancelVisibleBehind((IBinder) msg.obj);
  327.                     break;
  328.                 case BACKGROUND_VISIBLE_BEHIND_CHANGED:
  329.                     handleOnBackgroundVisibleBehindChanged((IBinder) msg.obj, msg.arg1 > 0);
  330.                     break;
  331.                 case ENTER_ANIMATION_COMPLETE:
  332.                     handleEnterAnimationComplete((IBinder) msg.obj);
  333.                     break;
  334.             }
  335.             if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
  336.         }
  337.  
  338.         private void maybeSnapshot() {
  339.             if (mBoundApplication != null && SamplingProfilerIntegration.isEnabled()) {
  340.                 // convert the *private* ActivityThread.PackageInfo to *public* known
  341.                 // android.content.pm.PackageInfo
  342.                 String packageName = mBoundApplication.info.mPackageName;
  343.                 android.content.pm.PackageInfo packageInfo = null;
  344.                 try {
  345.                     Context context = getSystemContext();
  346.                     if(context == null) {
  347.                         Log.e(TAG, "cannot get a valid context");
  348.                         return;
  349.                     }
  350.                     PackageManager pm = context.getPackageManager();
  351.                     if(pm == null) {
  352.                         Log.e(TAG, "cannot get a valid PackageManager");
  353.                         return;
  354.                     }
  355.                     packageInfo = pm.getPackageInfo(
  356.                             packageName, PackageManager.GET_ACTIVITIES);
  357.                 } catch (NameNotFoundException e) {
  358.                     Log.e(TAG, "cannot get package info for " + packageName, e);
  359.                 }
  360.                 SamplingProfilerIntegration.writeSnapshot(mBoundApplication.processName, packageInfo);
  361.             }
  362.         }
  363. }
看着是不是很亲切,有PAUSE_ACTIVITY、STOP_ACTIVITY、BIND_SERVICE等,就看到了组件的声明周期都是通过这去发起的.

最后ActivityThread第39行,调用Looper.loop()方法开始循环获取Message.

完事了? 没了?  怎么可能.... 记不记得咱们给AMS设置了一个ApplicationThread,设置了以后AMS就说了,行了可以.

当AMS看我能调用到你了,好,你可以干你的事了,那么它会通过ApplicationThread告诉你,那么来看一下ApplicationThread的类:

  1. private class ApplicationThread extends ApplicationThreadNative {
  2.         private static final String DB_INFO_FORMAT = "  %8s %8s %14s %14s  %s";
  3.  
  4.         private int mLastProcessState = -1;
  5.  
  6.         private void updatePendingConfiguration(Configuration config) {
  7.             synchronized (mResourcesManager) {
  8.                 if (mPendingConfiguration == null ||
  9.                         mPendingConfiguration.isOtherSeqNewer(config)) {
  10.                     mPendingConfiguration = config;
  11.                 }
  12.             }
  13.         }
  14.  
  15.         public final void schedulePauseActivity(IBinder token, boolean finished,
  16.                 boolean userLeaving, int configChanges, boolean dontReport) {
  17.             sendMessage(
  18.                     finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
  19.                     token,
  20.                     (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),
  21.                     configChanges);
  22.         }
  23.  
  24.         public final void scheduleStopActivity(IBinder token, boolean showWindow,
  25.                 int configChanges) {
  26.            sendMessage(
  27.                 showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,
  28.                 token, 0, configChanges);
  29.         }
  30.  
  31.         public final void scheduleWindowVisibility(IBinder token, boolean showWindow) {
  32.             sendMessage(
  33.                 showWindow ? H.SHOW_WINDOW : H.HIDE_WINDOW,
  34.                 token);
  35.         }
  36.  
  37.         public final void scheduleSleeping(IBinder token, boolean sleeping) {
  38.             sendMessage(H.SLEEPING, token, sleeping ? 1 : 0);
  39.         }
  40.  
  41.         public final void scheduleResumeActivity(IBinder token, int processState,
  42.                 boolean isForward, Bundle resumeArgs) {
  43.             updateProcessState(processState, false);
  44.             sendMessage(H.RESUME_ACTIVITY, token, isForward ? 1 : 0);
  45.         }
  46.  
  47.         public final void scheduleSendResult(IBinder token, List<ResultInfo> results) {
  48.             ResultData res = new ResultData();
  49.             res.token = token;
  50.             res.results = results;
  51.             sendMessage(H.SEND_RESULT, res);
  52.         }
  53.  
  54.         // we use token to identify this activity without having to send the
  55.         // activity itself back to the activity manager. (matters more with ipc)
  56.         @Override
  57.         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
  58.                 ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
  59.                 CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
  60.                 int procState, Bundle state, PersistableBundle persistentState,
  61.                 List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
  62.                 boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
  63.  
  64.             updateProcessState(procState, false);
  65.  
  66.             ActivityClientRecord r = new ActivityClientRecord();
  67.  
  68.             r.token = token;
  69.             r.ident = ident;
  70.             r.intent = intent;
  71.             r.referrer = referrer;
  72.             r.voiceInteractor = voiceInteractor;
  73.             r.activityInfo = info;
  74.             r.compatInfo = compatInfo;
  75.             r.state = state;
  76.             r.persistentState = persistentState;
  77.  
  78.             r.pendingResults = pendingResults;
  79.             r.pendingIntents = pendingNewIntents;
  80.  
  81.             r.startsNotResumed = notResumed;
  82.             r.isForward = isForward;
  83.  
  84.             r.profilerInfo = profilerInfo;
  85.  
  86.             r.overrideConfig = overrideConfig;
  87.             updatePendingConfiguration(curConfig);
  88.  
  89.             sendMessage(H.LAUNCH_ACTIVITY, r);
  90.         }
  91.  
  92.         @Override
  93.         public final void scheduleRelaunchActivity(IBinder token,
  94.                 List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
  95.                 int configChanges, boolean notResumed, Configuration config,
  96.                 Configuration overrideConfig) {
  97.             requestRelaunchActivity(token, pendingResults, pendingNewIntents,
  98.                     configChanges, notResumed, config, overrideConfig, true);
  99.         }
  100.  
  101.         public final void scheduleNewIntent(List<ReferrerIntent> intents, IBinder token) {
  102.             NewIntentData data = new NewIntentData();
  103.             data.intents = intents;
  104.             data.token = token;
  105.  
  106.             sendMessage(H.NEW_INTENT, data);
  107.         }
  108.  
  109.         public final void scheduleDestroyActivity(IBinder token, boolean finishing,
  110.                 int configChanges) {
  111.             sendMessage(H.DESTROY_ACTIVITY, token, finishing ? 1 : 0,
  112.                     configChanges);
  113. }
那么这里贴出了ApplicationThread的部分代码,这个类很多,都是一些创建组件啊,和组件的暂停,销毁的一些声明周期,通过Binder机制调用了以后,在方法里面调用sendMessage()方法,最后会走到刚才H类的handleMessage方法做处理.

那么主要看一下scheduleLaunchActivity,从AMS传递过来一堆参数,都是Activity的一些信息,把他们都封装到了ActivityClientRecord对象里,然后调用sendMessage方法最终调用到handleMessage里面.

那么看H类的handleMessage的switch语句,第一个就是LAUNCH_ACTIVITY那么看一下handleLaunchActivity把ActivityClientRecord传递进去,看一下代码:

  1. private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  2.         // If we are getting ready to gc after going to the background, well
  3.         // we are back active so skip it.
  4.         unscheduleGcIdler();
  5.         mSomeActivitiesChanged = true;
  6.  
  7.         if (r.profilerInfo != null) {
  8.             mProfiler.setProfiler(r.profilerInfo);
  9.             mProfiler.startProfiling();
  10.         }
  11.  
  12.         // Make sure we are running with the most recent config.
  13.         handleConfigurationChanged(null, null);
  14.  
  15.         if (localLOGV) Slog.v(
  16.             TAG, "Handling launch of " + r);
  17.  
  18.         // Initialize before creating the activity
  19.         WindowManagerGlobal.initialize(); //创建Activity之前初始化全局窗口管理者
  20.  
  21.         Activity a = performLaunchActivity(r, customIntent);   //获得一个Activity对象
  22.  
  23.         if (a != null) {
  24.             r.createdConfig = new Configuration(mConfiguration);
  25.             Bundle oldState = r.state;
  26.             handleResumeActivity(r.token, false, r.isForward,
  27.                     !r.activity.mFinished && !r.startsNotResumed);
  28.  
  29.             if (!r.activity.mFinished && r.startsNotResumed) {
  30.                 // The activity manager actually wants this one to start out
  31.                 // paused, because it needs to be visible but isn't in the
  32.                 // foreground.  We accomplish this by going through the
  33.                 // normal startup (because activities expect to go through
  34.                 // onResume() the first time they run, before their window
  35.                 // is displayed), and then pausing it.  However, in this case
  36.                 // we do -not- need to do the full pause cycle (of freezing
  37.                 // and such) because the activity manager assumes it can just
  38.                 // retain the current state it has.
  39.                 try {
  40.                     r.activity.mCalled = false;
  41.                     mInstrumentation.callActivityOnPause(r.activity);
  42.                     // We need to keep around the original state, in case
  43.                     // we need to be created again.  But we only do this
  44.                     // for pre-Honeycomb apps, which always save their state
  45.                     // when pausing, so we can not have them save their state
  46.                     // when restarting from a paused state.  For HC and later,
  47.                     // we want to (and can) let the state be saved as the normal
  48.                     // part of stopping the activity.
  49.                     if (r.isPreHoneycomb()) {
  50.                         r.state = oldState;
  51.                     }
  52.                     if (!r.activity.mCalled) {
  53.                         throw new SuperNotCalledException(
  54.                             "Activity " + r.intent.getComponent().toShortString() +
  55.                             " did not call through to super.onPause()");
  56.                     }
  57.  
  58.                 } catch (SuperNotCalledException e) {
  59.                     throw e;
  60.  
  61.                 } catch (Exception e) {
  62.                     if (!mInstrumentation.onException(r.activity, e)) {
  63.                         throw new RuntimeException(
  64.                                 "Unable to pause activity "
  65.                                 + r.intent.getComponent().toShortString()
  66.                                 + ": " + e.toString(), e);
  67.                     }
  68.                 }
  69.                 r.paused = true;
  70.             }
  71.         } else {
  72.             // If there was an error, for any reason, tell the activity
  73.             // manager to stop us.
  74.             try {
  75.                 ActivityManagerNative.getDefault()
  76.                     .finishActivity(r.token, Activity.RESULT_CANCELED, null, false);
  77.             } catch (RemoteException ex) {
  78.                 // Ignore
  79.             }
  80.         }
  81. }
那么主要看一下performLaunchActivity把Activity信息传递进去获取了一个Activity对象,那么下面直接就调用resume了,那么也就是说在performLaunchActivity里面已经调用了onCreate和onStart了,看一下代码: 

  1. private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  2.         // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");
  3.  
  4.         ActivityInfo aInfo = r.activityInfo; //Activity的信息,启动模式Theme 烂七八糟的
  5.         if (r.packageInfo == null) {
  6.             r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
  7.                     Context.CONTEXT_INCLUDE_CODE);
  8.         }
  9.  
  10.         ComponentName component = r.intent.getComponent();  //应该就是完整的包名+类名 
  11.         if (component == null) {
  12.             component = r.intent.resolveActivity(
  13.                 mInitialApplication.getPackageManager());
  14.             r.intent.setComponent(component);
  15.         }
  16.  
  17.         if (r.activityInfo.targetActivity != null) {
  18.             component = new ComponentName(r.activityInfo.packageName,
  19.                     r.activityInfo.targetActivity);
  20.         }
  21.  
  22.         Activity activity = null;
  23.         try {
  24.             java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  25.             activity = mInstrumentation.newActivity(
  26.                     cl, component.getClassName(), r.intent);      //ClassLoader加载Activity类
  27.             StrictMode.incrementExpectedActivityCount(activity.getClass());
  28.             r.intent.setExtrasClassLoader(cl);
  29.             r.intent.prepareToEnterProcess();
  30.             if (r.state != null) {
  31.                 r.state.setClassLoader(cl);
  32.             }
  33.         } catch (Exception e) {
  34.             if (!mInstrumentation.onException(activity, e)) {
  35.                 throw new RuntimeException(
  36.                     "Unable to instantiate activity " + component
  37.                     + ": " + e.toString(), e);
  38.             }
  39.         }
  40.  
  41.         try {
  42.             Application app = r.packageInfo.makeApplication(false, mInstrumentation);  //搞到Application
  43.  
  44.             if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
  45.             if (localLOGV) Slog.v(
  46.                     TAG, r + ": app=" + app
  47.                     + ", appName=" + app.getPackageName()
  48.                     + ", pkg=" + r.packageInfo.getPackageName()
  49.                     + ", comp=" + r.intent.getComponent().toShortString()
  50.                     + ", dir=" + r.packageInfo.getAppDir());
  51.  
  52.             if (activity != null) {
  53.                 Context appContext = createBaseContextForActivity(r, activity);
  54.                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager()); //Lable
  55.                 Configuration config = new Configuration(mCompatConfiguration);
  56.                 if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
  57.                         + r.activityInfo.name + " with config " + config);
  58.                 activity.attach(appContext, this, getInstrumentation(), r.token,
  59.                         r.ident, app, r.intent, r.activityInfo, title, r.parent,
  60.                         r.embeddedID, r.lastNonConfigurationInstances, config,
  61.                         r.referrer, r.voiceInteractor);
  62.  
  63.                 if (customIntent != null) {
  64.                     activity.mIntent = customIntent;
  65.                 }
  66.                 r.lastNonConfigurationInstances = null;
  67.                 activity.mStartedActivity = false;
  68.                 int theme = r.activityInfo.getThemeResource();
  69.                 if (theme != 0) {
  70.                     activity.setTheme(theme);
  71.                 }
  72.  
  73.                 activity.mCalled = false;
  74.                 if (r.isPersistable()) {
  75.                     mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
  76.                 } else {
  77.                     mInstrumentation.callActivityOnCreate(activity, r.state);
  78.                 }
  79.                 if (!activity.mCalled) {
  80.                     throw new SuperNotCalledException(
  81.                         "Activity " + r.intent.getComponent().toShortString() +
  82.                         " did not call through to super.onCreate()");
  83.                 }
  84.                 r.activity = activity;
  85.                 r.stopped = true;
  86.                 if (!r.activity.mFinished) {
  87.                     activity.performStart();
  88.                     r.stopped = false;
  89.                 }
  90.                 if (!r.activity.mFinished) {
  91.                     if (r.isPersistable()) {
  92.                         if (r.state != null || r.persistentState != null) {
  93.                             mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
  94.                                     r.persistentState);
  95.                         }
  96.                     } else if (r.state != null) {
  97.                         mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
  98.                     }
  99.                 }
  100.                 if (!r.activity.mFinished) {
  101.                     activity.mCalled = false;
  102.                     if (r.isPersistable()) {
  103.                         mInstrumentation.callActivityOnPostCreate(activity, r.state,
  104.                                 r.persistentState);
  105.                     } else {
  106.                         mInstrumentation.callActivityOnPostCreate(activity, r.state);
  107.                     }
  108.                     if (!activity.mCalled) {
  109.                         throw new SuperNotCalledException(
  110.                             "Activity " + r.intent.getComponent().toShortString() +
  111.                             " did not call through to super.onPostCreate()");
  112.                     }
  113.                 }
  114.             }
  115.             r.paused = true;
  116.  
  117.             mActivities.put(r.token, r);
  118.  
  119.         } catch (SuperNotCalledException e) {
  120.             throw e;
  121.  
  122.         } catch (Exception e) {
  123.             if (!mInstrumentation.onException(activity, e)) {
  124.                 throw new RuntimeException(
  125.                     "Unable to start activity " + component
  126.                     + ": " + e.toString(), e);
  127.             }
  128.         }
  129.  
  130.         return activity;
  131. }
首先呢通过ActivityClientRecord参数获取到AcitivtyInfo和组件的包名+类名,然后获取了ClassLoader类加载器,接下来使用mInstrumentation.newActivity把类加载器,包名及Intent传递进去,通过反射来获取到编写的Activity类,这样就获取到了Activity.

接下来依序获取了Context,Title之类的配置通过activity调用attach方法设置了以后,获取了Theme设置给Activity通过mInstrumentation.callActivityOnCreate()间接调用了Activity的方法,然后下面又调用了onStart方法,那么这个方法结束以后出去下面又调用了onResume(),至此Activity处于Active(活动状态).

那么最后说一下Activity的启动流程.首先呢从Launch(手机桌面),它本身就是一个应用程序.

1.点击一个图标后他会通过AMS接口告诉AMS我要开启一个应用程序,

2.然后AMS就通过ApplicationThread告诉Launch进入Pause状态,

3.然后进入了pause后会告诉AMS我已经pause了,

4.接下来AMS去创建进程啊,什么Acitivity的任务栈啊供ActivityThread运行

5.,ActivityThread通过AMS的Binder接口传递给它ApplicationThread,

6.AMS一看,好没有问题,你该干啥干啥吧,有事喊我.

那么这就是一个Android应用的启动流程了,那么至于Activity的开启过程呢,就是少了创建进程和Activity任务栈之类的,其他都差不多,都是通过AMS来管理,那么这篇文章就结束,谢谢.










声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/178134
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号