您的位置: 首页  >  文章  >  Activity启动的生命周期回调

Activity启动的生命周期回调

分类: 文章 • 2024-10-28 12:11:16

转载请标明原文地址：http://blog.****.net/yalinfendou/article/details/46909173【yalinfendou的博客】

        学习Android近一年，最近几天总算把Activity启动的生命周期回调流程走通了，因为所涉及的知识点太多，赶快做了笔记，不然过几天就忘了。强烈推荐《Android内核剖析》这本书，虽然随着Android版本的不断迭代更新，代码变化了不少，仍具有很强的参考价值。

本篇所涉及知识点：

  • Android 从开机到第一个Activity onCreate的过程粗略分析
  • Activity_A进入Activity_B生命周期的回调详细过程（Activity_A的onPause-->Activity_B的onCreate，onStart，onResume-->Activity_A的onStop，期间会看到Activity的onSaveInstanceState()，OnRestoreInstanceState()，OnRestart()方法的回调源码）

需要了解的几点概念和知识点：

  1. Instrumentation是执行application instrumentation代码的基类，这个类在任何application code之前实例化，让你可以监听所有的system与application之间的交互，一个应用程序中只有一个Instrumentation对象，每个Activity内部都有一个该对象的引用Instrumentation可以帮助管理Activity生命周期的回调，通过追踪源码会发现，Instrumentation的callActivityOnPause最终会去调用activity的performPause()，
  2. ActivityResult是Instrumentation的一个内部类，是Activity返回的一个结果，包含了resultCode和resultData
  3. ActivityThread类: 该类为应用程序的主线程类，所有的APK程序都有且仅有一个ActivityThread类 ，程序的入口为该类中的static main()函数
  4.  IApplicationThread是一个接口
  5.  ApplicationThreadNative是一个抽象类，实现了IApplicationThread接口，并继承Binder，具有Binder通信能力，public abstract class ApplicationThreadNative extends Binder implements IApplicationThread 
  6. ApplicationThread 继承了ApplicationThreadNative，是ActivityThread 的一个内部类       
  7. H也是ActivityThread的一个内部类，继承Handler，处理Activty,Service等生命周期的回调消息
  8. ActivityStackSupervisor 类是用来辅助管理ActivityStack的，里面有mHomeStack，mFocusedStack 和 mLastFocusedStack，它们的类型都是ActivityStack ，ActivityStackSupervisor 中主要是对它们的调度算法的一些操作
  9. 盗用一张图，出自http://blog.****.net/caowenbin/article/details/6036726Activity启动的生命周期回调
  10. 关于上图的说明：
    1. Binder是一种架构，这种架构提供了服务端接口、Binder驱动、客户端接口三个模块，用于完成进程间通信（IPC）
    2. IActivityManager是一个接口
    3. ActivityManagerNative 继承了 Binder 和实现了IActivityManager接口 ，具有Binder通信能力
    4. ActivityManagerService 继承了 ActivityManagerNative，是最核心的服务之一，负责管理Activity
    5. ActivityManagerProxy是ActivityManagerNative的一个内部类，也实现了IActivityManager接口
    6. 在开发过程中，程序员能接触到的也就是ActivityManager，系统不希望用户直接访问ActivityManagerService，而是经过ActivityManager类去访问，比如说通过activityManager.getRecentTasks得到最近使用的程序，在前面的博客《一个叫GUN的有趣的APP》使用过这个方法
    7. 但是ActivityManagerService和ActivityManager运行在不同的进程中，它们到底是如何通信的？这就是Proxy代理模式：为其他对象提供一种代理以控制这个对象的访问。
    8. activityManager.getRecentTasks动作真正的执行者是ActivityManagerService.getRecentTasks，关于这点，下面会有具体的代码分析

       说明：以下源码基于android-22（5.1）分析。

Android 从开机到第一个Activity onCreate的过程大致分析

  1. 开机后,Linux启动，然后Linux再启动第一个进程init 
  2. 在init中，又会启动Zygote
  3. Zygote则会启动SystemServer
  4. SystemServer又会开启Application FrameWork中的AMS（Activity Manager Service），PMS（package Manager Service），WMS（WindowManager Service）等，这导致的结果就是Android 开机比较慢
  5. 在被SystemServer启动的AMS中，有一个叫startHomeActivityLocked的函数，它创建一个CATEGORY_HOME类型的Intent，而PackageManagerService会查询Category类型为HOME的Activity，因为只有系统自带的Launcher应用程序注册了HOME类型的Activity（如果有多个Launcher的话，系统会弹出一个选择框让用户选择进入哪一个Launcher）
  6. 然后又会执行mMainStack.startActivityLocked启动Launcher的Activity
  7. 接下来就是调用它的onCreate
        这样总算从开机一步一步走到了Activity的第一个执行的生命周期。

        说明1：android的launcher应用程序，即桌面应用程序（注意，Android开机启动后的桌面也是一个APP，只不过这个APP有点特殊，开发难度有点大而已，Android原生系统的launcher的包名叫"com.android.launcher"，小米launcher的包名叫"com.miui.home"，这是以前写《一个叫GUN的有趣的APP》时发现的），这个launcher负责把安装在手机上的APP以快捷图标的形式展示出来。
        说明2：因为以上涉及到Linux方面知识，因为完全不懂，只弄懂了大致流程，所以不敢保证上面的进程步骤严谨正确（以后待研究）。

Activity_A进入Activity_B生命周期的回调详细过程

        执行代码：
[java] view plain copy
  1. Intent intent = new Intent(Activity_A.this, Activity_B.class);    
  2. startActivity(intent);  
        它们的生命周期执行过程：
Activity启动的生命周期回调
        对于这个生命周期的执行过程，应该都很熟了，但是有一点疑问：为什么执行了Activity_A的onPause之后就直接去执行Activity_B的onCreate，onStart，onResume，最后才掉过头回去执行Activity_A的onStop？
        进入源码分析（因为所涉及到的代码逻辑太多太多，所以以下分析主要基于Activity生命周期回调执行的主线）。
        Activity.class
[java] view plain copy
  1. public void startActivity(Intent intent) {  
  2.     this.startActivity(intent, null);  
  3. }  
  4.   
  5. public void startActivity(Intent intent, @Nullable Bundle options) {  
  6.     if (options != null) {  
  7.         startActivityForResult(intent, -1, options);  
  8.     } else {  
  9.         // Note we want to go through this call for compatibility with  
  10.         // applications that may have overridden the method.  
  11.         startActivityForResult(intent, -1);  
  12.     }  
  13. }  
  14.   
  15. public void startActivityForResult(Intent intent, int requestCode,  
  16.         @Nullable Bundle options) {  
  17.     if (mParent == null) {  
  18.         //这是关键的一句，启动新的Activity  
  19.         Instrumentation.ActivityResult ar = mInstrumentation  
  20.                 .execStartActivity(this,  
  21.                         mMainThread.getApplicationThread(), mToken, this,  
  22.                         intent, requestCode, options);  
  23.         if (ar != null) {  
  24.             mMainThread.sendActivityResult(mToken, mEmbeddedID,  
  25.                     requestCode, ar.getResultCode(), ar.getResultData());  
  26.         }  
  27.         if (requestCode >= 0) {  
  28.             // If this start is requesting a result, we can avoid making  
  29.             // the activity visible until the result is received. Setting  
  30.             // this code during onCreate(Bundle savedInstanceState) or  
  31.             // onResume() will keep the  
  32.             // activity hidden during this time, to avoid flickering.  
  33.             // This can only be done when a result is requested because  
  34.             // that guarantees we will get information back when the  
  35.             // activity is finished, no matter what happens to it.  
  36.             mStartedActivity = true;  
  37.         }  
  38.   
  39.         final View decor = mWindow != null ? mWindow.peekDecorView() : null;  
  40.         if (decor != null) {  
  41.             decor.cancelPendingInputEvents();  
  42.         }  
  43.         // TODO Consider clearing/flushing other event sources and events  
  44.         // for child windows.  
  45.     } else {  
  46.         if (options != null) {  
  47.             mParent.startActivityFromChild(this, intent, requestCode,  
  48.                     options);  
  49.         } else {  
  50.             // Note we want to go through this method for compatibility with  
  51.             // existing applications that may have overridden it.  
  52.             mParent.startActivityFromChild(this, intent, requestCode);  
  53.         }  
  54.     }  
  55.     if (options != null && !isTopOfTask()) {  
  56.         mActivityTransitionState.startExitOutTransition(this, options);  
  57.     }  
  58. }  
        非常非常关键的mInstrumentation.execStartActivity(this,  mMainThread.getApplicationThread(), mToken, this,  intent, requestCode, options);     
        这个mInstrumentation就是上面提到的Instrumentation，引用《Android内核剖析》对它的描述：一个应用程序中只有一个Instrumentation对象，每个Activity内部都有一个该对象的引用。Instrumentation可以理解为应用进程的管家， ActivityThread要创建或者暂停某 个 Activity时，是 通 过 这 个“ 管家” 进行的，设置这个管家的好处是可以统计所有的“ 开销”，开销的信息保存在“ 管家” 那里。其实正如其名称所示，Instrumentation就是为了 “测量”、 “统计”，因为管家掌握了所有的“ 开销”，自然也就具有了统计的功能。当然，Instrumentation类 和 ActivityThread的分工是有本质区别的，后者就像是这个家里的主人，负责创建这个“家庭”，并负责和外界打交道，比如 接 收AMS的通知等。 
        Instrumentation可以帮助管理Activity生命周期的回调。
        Instrumentation.class
[java] view plain copy
  1. public ActivityResult execStartActivity(  
  2.             Context who, IBinder contextThread, IBinder token, Activity target,  
  3.             Intent intent, int requestCode, Bundle options) {  
  4.         IApplicationThread whoThread = (IApplicationThread) contextThread;  
  5.         if (mActivityMonitors != null) {  
  6.             synchronized (mSync) {  
  7.                 final int N = mActivityMonitors.size();  
  8.                 for (int i=0; i<N; i++) {  
  9.                     final ActivityMonitor am = mActivityMonitors.get(i);  
  10.                     if (am.match(who, null, intent)) {  
  11.                         am.mHits++;  
  12.                         if (am.isBlocking()) {  
  13.                             return requestCode >= 0 ? am.getResult() : null;  
  14.                         }  
  15.                         break;  
  16.                     }  
  17.                 }  
  18.             }  
  19.         }  
  20.         try {  
  21.             intent.migrateExtraStreamToClipData();  
  22.             intent.prepareToLeaveProcess();  
  23.             //关键，Proxy代理模式，真正的动作执行者是ActivityManagerService.startActivity  
  24.             int result = ActivityManagerNative.getDefault()  
  25.                 .startActivity(whoThread, who.getBasePackageName(), intent,  
  26.                         intent.resolveTypeIfNeeded(who.getContentResolver()),  
  27.                         token, target != null ? target.mEmbeddedID : null,  
  28.                         requestCode, 0, null, options);  
  29.             checkStartActivityResult(result, intent);  
  30.         } catch (RemoteException e) {  
  31.         }  
  32.         return null;  
  33.     }  

        大致介绍一下Proxy代理模式，看看这个ActivityManagerNative.getDefault()到底是什么？
        ActivityManagerNative.class
[java] view plain copy
  1. /** 
  2.  * Retrieve the system's default/global activity manager. 
  3.  */  
  4. static public IActivityManager getDefault() {  
  5.     return gDefault.get();  
  6. }  
  7.   
  8. private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {  
  9.     protected IActivityManager create() {  
  10.         IBinder b = ServiceManager.getService("activity");  
  11.         if (false) {  
  12.             Log.v("ActivityManager", "default service binder = " + b);  
  13.         }  
  14.         IActivityManager am = asInterface(b);  
  15.         if (false) {  
  16.             Log.v("ActivityManager", "default service = " + am);  
  17.         }  
  18.         return am;  
  19.     }  
  20. };  
        说明：
        IBinder是用来通信的，getDefault()返回的是一个IActivityManager类型的ActivityManagerProxy对象，代理的是ActivityManagerNative类的子类ActivityManagerService，代理成功之后，便可以通过这个代理对象使用IBinder和系统不希望用户直接访问的ActivityManagerService进行通信，并执行ActivityManagerService中具体定义的动作了。
        再次以activityManager.getRecentTasks为例再进行说明：
        ActivityManager.class
[java] view plain copy
  1. @Deprecated  
  2. public List<RecentTaskInfo> getRecentTasks(int maxNum, int flags)  
  3.         throws SecurityException {  
  4.     try {  
  5.         return ActivityManagerNative.getDefault().getRecentTasks(maxNum,  
  6.                 flags, UserHandle.myUserId());  
  7.     } catch (RemoteException e) {  
  8.         // System dead, we will be dead too soon!  
  9.         return null;  
  10.     }  
  11. }  
        这里也是通过ActivityManagerNative.getDefault()代理，ActivityManager并没有执行其具体的动作，真正动作的执行在通过ActivityManagerNative.getDefault()代理的ActivityManagerService里面。

        代理模式大致理解了，继续分析:

  1. ActivityManagerNative.getDefault()  
  2.                 .startActivity(whoThread, who.getBasePackageName(), intent,  
  3.                         intent.resolveTypeIfNeeded(who.getContentResolver()),  
  4.                         token, target != null ? target.mEmbeddedID : null,  
  5.                         requestCode, 0, null, options); 

        里面的参数whoThread就是前面的MainThread.getApplicationThread，mMainThread的类型是ActivityThread，它代表的是应用程序的主线程，这里通过 mMainThread.getApplicationThread获得它里面的ApplicationThread成员变量，具有Binder通信能力。
        按照上面的分析，现在可以知道ActivityManagerNative.getDefault().startActivity真正的动作执行是在ActivityManagerService.startActivity里面，跟踪源码：
        ActivityManagerService.class
[java] view plain copy
  1. @Override  
  2. public final int startActivity(IApplicationThread caller, String callingPackage,  
  3.         Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,  
  4.         int startFlags, ProfilerInfo profilerInfo, Bundle options) {  
  5.     return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,  
  6.         resultWho, requestCode, startFlags, profilerInfo, options,  
  7.         UserHandle.getCallingUserId());  
  8. }  
  9.   
  10. @Override  
  11. public final int startActivityAsUser(IApplicationThread caller, String callingPackage,  
  12.         Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,  
  13.         int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) {  
  14.     enforceNotIsolatedCaller("startActivity");  
  15.     userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId,  
  16.             false, ALLOW_FULL_ONLY, "startActivity", null);  
  17.     // TODO: Switch to user app stacks here.  
  18.     return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent,  
  19.             resolvedType, null, null, resultTo, resultWho, requestCode, startFlags,  
  20.             profilerInfo, null, null, options, userId, null, null);  
  21. }  
        ActivityStackSupervisor.class
[java] view plain copy
  1. final int startActivityMayWait(IApplicationThread caller, int callingUid,  
  2.         String callingPackage, Intent intent, String resolvedType,  
  3.         IVoiceInteractionSession voiceSession,  
  4.         IVoiceInteractor voiceInteractor, IBinder resultTo,  
  5.         String resultWho, int requestCode, int startFlags,  
  6.         ProfilerInfo profilerInfo, WaitResult outResult,  
  7.         Configuration config, Bundle options, int userId,  
  8.         IActivityContainer iContainer, TaskRecord inTask) {  
  9.     // Refuse possible leaked file descriptors  
  10.     if (intent != null && intent.hasFileDescriptors()) {  
  11.         throw new IllegalArgumentException(  
  12.                 "File descriptors passed in Intent");  
  13.     }  
  14.     // ...  
  15.   
  16.     if (aInfo != null  
  17.             && (aInfo.applicationInfo.flags & ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {  
  18.     // ...  
  19.     }  
  20.   
  21.     int res = startActivityLocked(caller, intent, resolvedType, aInfo,  
  22.             voiceSession, voiceInteractor, resultTo, resultWho,  
  23.             requestCode, callingPid, callingUid, callingPackage,  
  24.             realCallingPid, realCallingUid, startFlags, options,  
  25.             componentSpecified, null, container, inTask);  
  26.       
  27.     // ...  
  28.       
  29.     return res;  
  30. }  

        ActivityStackSupervisor 类是用来辅助管理ActivityStack的，在ActivityStackSupervisor中可以看到
        ActivityStackSupervisor.class
[java] view plain copy
  1. /** The stack containing the launcher app. Assumed to always be attached to 
  2.  * Display.DEFAULT_DISPLAY. */  
  3. private ActivityStack mHomeStack;  
  4.   
  5. /** The stack currently receiving input or launching the next activity. */  
  6. private ActivityStack mFocusedStack;  
  7.   
  8. /** If this is the same as mFocusedStack then the activity on the top of the focused stack has 
  9.  * been resumed. If stacks are changing position this will hold the old stack until the new 
  10.  * stack becomes resumed after which it will be set to mFocusedStack. */  
  11. private ActivityStack mLastFocusedStack;  
        里面有mHomeStack，mFocusedStack 和 mLastFocusedStack，它们的类型都是ActivityStack 。从Google注释中可以理解,mHomeStack保存launcher app的Activity，mFocusedStack保存当前接受输入事件和正启动的下一个Activity。ActivityStackSupervisor 中主要是对它们的调度算法的一些操作。
        上面startActivityMayWait返回的结果是通过startActivityLocked得到的res，继续追踪startActivityLocked：
        ActivityStackSupervisor.class
[java] view plain copy
  1. final int startActivityLocked(IApplicationThread caller,  
  2.            Intent intent, String resolvedType, ActivityInfo aInfo,  
  3.            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,  
  4.            IBinder resultTo, String resultWho, int requestCode,  
  5.            int callingPid, int callingUid, String callingPackage,  
  6.            int realCallingPid, int realCallingUid, int startFlags, Bundle options,  
  7.            boolean componentSpecified, ActivityRecord[] outActivity, ActivityContainer container,  
  8.            TaskRecord inTask) {  
  9.        int err = ActivityManager.START_SUCCESS;  
  10.        ProcessRecord callerApp = null;  
  11.        if (caller != null) {  
  12.         //...  
  13.        }  
  14.        //...  
  15.       if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {  
  16.         //...  
  17.        }  
  18.   
  19.        if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {  
  20.            // We couldn't find a class that can handle the given Intent.  
  21.            // That's the end of that!  
  22.            err = ActivityManager.START_INTENT_NOT_RESOLVED;  
  23.        }  
  24.          
  25.        if (err == ActivityManager.START_SUCCESS && aInfo == null) {  
  26.            // We couldn't find the specific class specified in the Intent.  
  27.            // Also the end of the line.  
  28.            err = ActivityManager.START_CLASS_NOT_FOUND;  
  29.        }  
  30.       //...          
  31.        err = startActivityUncheckedLocked(r, sourceRecord, voiceSession, voiceInteractor,  
  32.                startFlags, true, options, inTask);  
  33.       //...  
  34.        return err;  
  35.    }  
        主要是检查目标APP或者Activity的一些信息，包括是否存在，是否拥有权限等，最后又会调用startActivityUncheckedLocked，此时目标Activity经过了通过了检查。
        startActivityUncheckedLocked中又调用了targetStack.startActivityLocked(r, newTask, doResume, keepCurTransition, options)，这里跟上面的ActivityStackSupervisor.startActivityLocked方法名相同。
        ActivityStack.class
[java] view plain copy
  1. final void startActivityLocked(ActivityRecord r, boolean newTask,  
  2.         boolean doResume, boolean keepCurTransition, Bundle options) {  
  3.     TaskRecord rTask = r.task;  
  4.     final int taskId = rTask.taskId;  
  5.     // mLaunchTaskBehind tasks get placed at the back of the task stack.  
  6.     if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) {  
  7.         // Last activity in task had been removed or ActivityManagerService is reusing task.  
  8.         // Insert or replace.  
  9.         // Might not even be in.  
  10.         //如果是新任务，插入栈顶  
  11.         insertTaskAtTop(rTask);  
  12.         mWindowManager.moveTaskToTop(taskId);  
  13.     }  
  14.     TaskRecord task = null;  
  15.     if (!newTask) {  
  16.         // If starting in an existing task, find where that is...  
  17.         //如果不是是新任务  
  18.         boolean startIt = true;  
  19.         //遍历mHistory  
  20.         for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {  
  21.             task = mTaskHistory.get(taskNdx);  
  22.             if (task.getTopActivity() == null) {  
  23.                 // All activities in task are finishing.  
  24.                 continue;  
  25.             }  
  26.             if (task == r.task) {  
  27.                 // Here it is!  Now, if this is not yet visible to the  
  28.                 // user, then just add it without starting; it will  
  29.                 // get started when the user navigates back to it.  
  30.                 if (!startIt) {  
  31.                     if (DEBUG_ADD_REMOVE) Slog.i(TAG, "Adding activity " + r + " to task "  
  32.                             + task, new RuntimeException("here").fillInStackTrace());  
  33.                     task.addActivityToTop(r);  
  34.                     r.putInHistory();  
  35.                     mWindowManager.addAppToken(task.mActivities.indexOf(r), r.appToken,  
  36.                             r.task.taskId, mStackId, r.info.screenOrientation, r.fullscreen,  
  37.                             (r.info.flags & ActivityInfo.FLAG_SHOW_ON_LOCK_SCREEN) != 0,  
  38.                             r.userId, r.info.configChanges, task.voiceSession != null,  
  39.                             r.mLaunchTaskBehind);  
  40.                     if (VALIDATE_TOKENS) {  
  41.                         validateAppTokensLocked();  
  42.                     }  
  43.                     ActivityOptions.abort(options);  
  44.                     return;  
  45.                 }  
  46.                 break;  
  47.             } else if (task.numFullscreen > 0) {  
  48.                 startIt = false;  
  49.             }  
  50.         }  
  51.     }  
  52.   
  53.     // Place a new activity at top of stack, so it is next to interact  
  54.     // with the user.  
  55.   
  56.     // If we are not placing the new activity frontmost, we do not want  
  57.     // to deliver the onUserLeaving callback to the actual frontmost  
  58.     // activity  
  59.     if (task == r.task && mTaskHistory.indexOf(task) != (mTaskHistory.size() - 1)) {  
  60.         //...   
  61.     }  
  62.   
  63.    //...   
  64.     if (!isHomeStack() || numActivities() > 0) {  
  65.         //...   
  66.     } else {  
  67.         //...   
  68.     }  
  69.     if (VALIDATE_TOKENS) {  
  70.         validateAppTokensLocked();  
  71.     }  
  72.   
  73.     if (doResume) {  
  74.         mStackSupervisor.resumeTopActivitiesLocked(this, r, options);  
  75.     }  
  76. }  
        在ActivityStackSupervisor.startActivityUncheckedLocked和ActivityStack.startActivityLocked主要是找到或创建合适的Task，根据FLAG_ACTIVITY_XX（启动模式）进行不同的Task操作，这里调度task的算法很复杂。
        上面执行完成之后，调用mStackSupervisor.resumeTopActivitiesLocked(this, r, options);ActivityStack
        ActivityStackSupervisor.class
[java] view plain copy
  1. boolean resumeTopActivitiesLocked(ActivityStack targetStack, ActivityRecord target,  
  2.         Bundle targetOptions) {  
  3.     if (targetStack == null) {  
  4.         targetStack = getFocusedStack();  
  5.     }  
  6.     // Do targetStack first.  
  7.     boolean result = false;  
  8.     if (isFrontStack(targetStack)) {  
  9.         result = targetStack.resumeTopActivityLocked(target, targetOptions);  
  10.     }  
  11.     for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {  
  12.         final ArrayList<ActivityStack> stacks = mActivityDisplays.valueAt(displayNdx).mStacks;  
  13.         for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) {  
  14.             final ActivityStack stack = stacks.get(stackNdx);  
  15.             if (stack == targetStack) {  
  16.                 // Already started above.  
  17.                 continue;  
  18.             }  
  19.             if (isFrontStack(stack)) {  
  20.                 stack.resumeTopActivityLocked(null);  
  21.             }  
  22.         }  
  23.     }  
  24.     return result;  
  25. }  
        ActivityStack.class
[java] view plain copy
  1. final boolean resumeTopActivityLocked(ActivityRecord prev) {  
  2.     return resumeTopActivityLocked(prev, null);  
  3. }  
  4.   
  5. final boolean resumeTopActivityLocked(ActivityRecord prev, Bundle options) {  
  6.     if (mStackSupervisor.inResumeTopActivity) {  
  7.         // Don't even start recursing.  
  8.         return false;  
  9.     }  
  10.   
  11.     boolean result = false;  
  12.     try {  
  13.         // Protect against recursion.  
  14.         mStackSupervisor.inResumeTopActivity = true;  
  15.         if (mService.mLockScreenShown == ActivityManagerService.LOCK_SCREEN_LEAVING) {  
  16.             mService.mLockScreenShown = ActivityManagerService.LOCK_SCREEN_HIDDEN;  
  17.             mService.updateSleepIfNeededLocked();  
  18.         }  
  19.         result = resumeTopActivityInnerLocked(prev, options);  
  20.     } finally {  
  21.         mStackSupervisor.inResumeTopActivity = false;  
  22.     }  
  23.     return result;  
  24. }  
        ActivityStack.class
        resumeTopActivityInnerLocked方法里面代码太多
[java] view plain copy
  1. final boolean resumeTopActivityInnerLocked(ActivityRecord prev, Bundle options) {  
  2.     //...  
  3.   
  4.     // Find the first activity that is not finishing.  
  5.     //找到第一个没有finish的activity，这个Activity就是Activity_A  
  6.     final ActivityRecord next = topRunningActivityLocked(null);  
  7.   
  8.     // Remember how we'll process this pause/resume situation, and ensure  
  9.     // that the state is reset however we wind up proceeding.  
  10.     final boolean userLeaving = mStackSupervisor.mUserLeaving;  
  11.     mStackSupervisor.mUserLeaving = false;  
  12.   
  13.     final TaskRecord prevTask = prev != null ? prev.task : null;  
  14.     //如果是开机启动，则next==null，所以就是启动Launcher了  
  15.     if (next == null) {  
  16.         // There are no more activities!  Let's just start up the  
  17.         // Launcher...  
  18.         ActivityOptions.abort(options);  
  19.         if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: No more activities go home");  
  20.         if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();  
  21.         // Only resume home if on home display  
  22.         final int returnTaskType = prevTask == null || !prevTask.isOverHomeStack() ?  
  23.                 HOME_ACTIVITY_TYPE : prevTask.getTaskToReturnTo();  
  24.         return isOnHomeDisplay() &&  
  25.                 mStackSupervisor.resumeHomeStackTask(returnTaskType, prev, "noMoreActivities");  
  26.     }  
  27.   
  28.     
  29.     //...  
  30.     // We need to start pausing the current activity so the top one  
  31.     // can be resumed...  
  32.     //去 pause当前处于resumed状态的Activity，也就是Activity_A  
  33.     boolean dontWaitForPause = (next.info.flags&ActivityInfo.FLAG_RESUME_WHILE_PAUSING) != 0;  
  34.     boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, true, dontWaitForPause);  
  35.     if (mResumedActivity != null) {  
  36.         if (DEBUG_STATES) Slog.d(TAG, "resumeTopActivityLocked: Pausing " + mResumedActivity);  
  37.         pausing |= startPausingLocked(userLeaving, false, true, dontWaitForPause);  
  38.     }  
  39.    //...  
  40.    if (prev != null && prev != next) {}  
  41.   
  42.    //...  
  43.   
  44.     return true;  
  45. }   
        这里先分析Launcher的启动函数 resumeHomeStackTask
        ActivityStackSupervisor.class
[java] view plain copy
  1. boolean resumeHomeStackTask(int homeStackTaskType, ActivityRecord prev, String reason) {  
  2.        if (!mService.mBooting && !mService.mBooted) {  
  3.            // Not ready yet!  
  4.            return false;  
  5.        }  
  6.   
  7.        if (homeStackTaskType == RECENTS_ACTIVITY_TYPE) {  
  8.            mWindowManager.showRecentApps();  
  9.            return false;  
  10.        }  
  11.        moveHomeStackTaskToTop(homeStackTaskType, reason);  
  12.        if (prev != null) {  
  13.            prev.task.setTaskToReturnTo(APPLICATION_ACTIVITY_TYPE);  
  14.        }  
  15.   
  16.        ActivityRecord r = mHomeStack.topRunningActivityLocked(null);  
  17.        // if (r != null && (r.isHomeActivity() || r.isRecentsActivity())) {  
  18.        if (r != null && r.isHomeActivity()) {  
  19.            mService.setFocusedActivityLocked(r, reason);  
  20.            return resumeTopActivitiesLocked(mHomeStack, prev, null);  
  21.        }  
  22.        //启动Launcher  
  23.        return mService.startHomeActivityLocked(mCurrentUser, reason);  
  24.    }  
        mService.startHomeActivityLocked(mCurrentUser, reason)启动Launcher
        ActivityManagerService.class
[java] view plain copy
  1. boolean startHomeActivityLocked(int userId, String reason) {  
  2.     if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL  
  3.             && mTopAction == null) {  
  4.         // We are running in factory test mode, but unable to find  
  5.         // the factory test app, so just sit around displaying the  
  6.         // error message and don't try to start anything.  
  7.         return false;  
  8.     }  
  9.     Intent intent = getHomeIntent();  
  10.     ActivityInfo aInfo =  
  11.         resolveActivityInfo(intent, STOCK_PM_FLAGS, userId);  
  12.     if (aInfo != null) {  
  13.         intent.setComponent(new ComponentName(  
  14.                 aInfo.applicationInfo.packageName, aInfo.name));  
  15.         // Don't do this if the home app is currently being  
  16.         // instrumented.  
  17.         aInfo = new ActivityInfo(aInfo);  
  18.         aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId);  
  19.         ProcessRecord app = getProcessRecordLocked(aInfo.processName,  
  20.                 aInfo.applicationInfo.uid, true);  
  21.         if (app == null || app.instrumentationClass == null) {  
  22.             intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK);  
  23.             mStackSupervisor.startHomeActivity(intent, aInfo, reason);  
  24.         }  
  25.     }  
  26.   
  27.     return true;  
  28. }  
        ActivityStackSupervisor.class
[java] view plain copy
  1. void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason) {  
  2.     moveHomeStackTaskToTop(HOME_ACTIVITY_TYPE, reason);  
  3.     startActivityLocked(null, intent, null, aInfo, null, null, null, null, 0, 0, 0, null,  
  4.             0, 0, 0, null, false, null, null, null);  
  5. }     
         里面也是调用了startActivityLocked，如果想定义自己的Launcher的话，貌似就可以在这里修改代码了。
        再去追踪startPausingLocked
        ActivityStack.class
[java] view plain copy
  1. final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, boolean resuming,  
  2.         boolean dontWait) {  
  3.     if (mPausingActivity != null) {  
  4.         Slog.wtf(TAG, "Going to pause when pause is already pending for " + mPausingActivity);  
  5.         completePauseLocked(false);  
  6.     }  
  7.     //prev包含了Activity_A,所以prev.app != null && prev.app.thread != null  
  8.     ActivityRecord prev = mResumedActivity;  
  9.     if (prev == null) {  
  10.         if (!resuming) {  
  11.             Slog.wtf(TAG, "Trying to pause when nothing is resumed");  
  12.             mStackSupervisor.resumeTopActivitiesLocked();  
  13.         }  
  14.         return false;  
  15.     }  
  16.     //...  
  17.     if (prev.app != null && prev.app.thread != null) {  
  18.         if (DEBUG_PAUSE) Slog.v(TAG, "Enqueueing pending pause: " + prev);  
  19.         try {  
  20.             EventLog.writeEvent(EventLogTags.AM_PAUSE_ACTIVITY,  
  21.                     prev.userId, System.identityHashCode(prev),  
  22.                     prev.shortComponentName);  
  23.             mService.updateUsageStats(prev, false);  
  24.             //这句是关键，通过Binder调用ActivityThread中的方法，AmS 会通过 IPC 调用到 ActivityThread 的schedulePauseActivity  
  25.             prev.app.thread.schedulePauseActivity(prev.appToken, prev.finishing,  
  26.                     userLeaving, prev.configChangeFlags, dontWait);  
  27.         } catch (Exception e) {  
  28.             // Ignore exception, if process died other code will cleanup.  
  29.             Slog.w(TAG, "Exception thrown during pause", e);  
  30.             mPausingActivity = null;  
  31.             mLastPausedActivity = null;  
  32.             mLastNoHistoryActivity = null;  
  33.         }  
  34.     } else {  
  35.         mPausingActivity = null;  
  36.         mLastPausedActivity = null;  
  37.         mLastNoHistoryActivity = null;  
  38.     }  
  39.   
  40.      //...  
  41.         return false;  
  42.     }  
        疑问：为什么prev.app.thread.schedulePauseActivity能调用到ApplicationThread中的schedulePauseActivity方法？
        ----Binder机制，具体怎么实现的我也没弄明白。
        ActivityThread.class
        ApplicationThread是ActivityThread的一个内部类，有木有感觉里面的方法是那么熟悉？
[java] view plain copy
  1. private class ApplicationThread extends ApplicationThreadNative {  
  2.    
  3.    //...  
  4.     public final void schedulePauseActivity(IBinder token, boolean finished,  
  5.             boolean userLeaving, int configChanges, boolean dontReport) {  
  6.         sendMessage(  
  7.                 finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,  
  8.                 token,  
  9.                 (userLeaving ? 1 : 0) | (dontReport ? 2 : 0),  
  10.                 configChanges);  
  11.     }  
  12.   
  13.     public final void scheduleStopActivity(IBinder token, boolean showWindow,  
  14.             int configChanges) {  
  15.        sendMessage(  
  16.             showWindow ? H.STOP_ACTIVITY_SHOW : H.STOP_ACTIVITY_HIDE,  
  17.             token, 0, configChanges);  
  18.     }  
  19.   
  20.     public final void scheduleWindowVisibility(IBinder token, boolean showWindow) {  
  21.         sendMessage(  
  22.             showWindow ? H.SHOW_WINDOW : H.HIDE_WINDOW,  
  23.             token);  
  24.     }  
  25.   
  26.     public final void scheduleSleeping(IBinder token, boolean sleeping) {  
  27.         sendMessage(H.SLEEPING, token, sleeping ? 1 : 0);  
  28.     }  
  29.   
  30.     public final void scheduleResumeActivity(IBinder token, int processState,  
  31.             boolean isForward, Bundle resumeArgs) {  
  32.         updateProcessState(processState, false);  
  33.         sendMessage(H.RESUME_ACTIVITY, token, isForward ? 1 : 0);  
  34.     }  
  35.   
  36.     public final void scheduleSendResult(IBinder token, List<ResultInfo> results) {  
  37.         ResultData res = new ResultData();  
  38.         res.token = token;  
  39.         res.results = results;  
  40.         sendMessage(H.SEND_RESULT, res);  
  41.     }  
  42.   
  43.     // we use token to identify this activity without having to send the  
  44.     // activity itself back to the activity manager. (matters more with ipc)  
  45.     public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,  
  46.             ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,  
  47.             String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,  
  48.             PersistableBundle persistentState, List<ResultInfo> pendingResults,  
  49.             List<ReferrerIntent> pendingNewIntents, boolean notResumed, boolean isForward,  
  50.             ProfilerInfo profilerInfo) {  
  51.   
  52.         updateProcessState(procState, false);  
  53.   
  54.         ActivityClientRecord r = new ActivityClientRecord();  
  55.   
  56.         r.token = token;  
  57.         r.ident = ident;  
  58.         r.intent = intent;  
  59.         r.referrer = referrer;  
  60.         r.voiceInteractor = voiceInteractor;  
  61.         r.activityInfo = info;  
  62.         r.compatInfo = compatInfo;  
  63.         r.state = state;  
  64.         r.persistentState = persistentState;  
  65.   
  66.         r.pendingResults = pendingResults;  
  67.         r.pendingIntents = pendingNewIntents;  
  68.   
  69.         r.startsNotResumed = notResumed;  
  70.         r.isForward = isForward;  
  71.   
  72.         r.profilerInfo = profilerInfo;  
  73.   
  74.         updatePendingConfiguration(curConfig);  
  75.   
  76.         sendMessage(H.LAUNCH_ACTIVITY, r);  
  77.     }  
  78.   
  79.     public final void scheduleRelaunchActivity(IBinder token,  
  80.             List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,  
  81.             int configChanges, boolean notResumed, Configuration config) {  
  82.         requestRelaunchActivity(token, pendingResults, pendingNewIntents,  
  83.                 configChanges, notResumed, config, true);  
  84.     }  
  85.   
  86.     public final void scheduleNewIntent(List<ReferrerIntent> intents, IBinder token) {  
  87.         NewIntentData data = new NewIntentData();  
  88.         data.intents = intents;  
  89.         data.token = token;  
  90.   
  91.         sendMessage(H.NEW_INTENT, data);  
  92.     }  
  93.   
  94.     public final void scheduleDestroyActivity(IBinder token, boolean finishing,  
  95.             int configChanges) {  
  96.         sendMessage(H.DESTROY_ACTIVITY, token, finishing ? 1 : 0,  
  97.                 configChanges);  
  98.     }  
  99.   
  100.     public final void scheduleReceiver(Intent intent, ActivityInfo info,  
  101.             CompatibilityInfo compatInfo, int resultCode, String data, Bundle extras,  
  102.             boolean sync, int sendingUser, int processState) {  
  103.         updateProcessState(processState, false);  
  104.         ReceiverData r = new ReceiverData(intent, resultCode, data, extras,  
  105.                 sync, false, mAppThread.asBinder(), sendingUser);  
  106.         r.info = info;  
  107.         r.compatInfo = compatInfo;  
  108.         sendMessage(H.RECEIVER, r);  
  109.     }  
  110.   
  111.    //...  
  112.     public final void scheduleCreateService(IBinder token,  
  113.             ServiceInfo info, CompatibilityInfo compatInfo, int processState) {  
  114.         updateProcessState(processState, false);  
  115.         CreateServiceData s = new CreateServiceData();  
  116.         s.token = token;  
  117.         s.info = info;  
  118.         s.compatInfo = compatInfo;  
  119.   
  120.         sendMessage(H.CREATE_SERVICE, s);  
  121.     }  
  122.   
  123.     public final void scheduleBindService(IBinder token, Intent intent,  
  124.             boolean rebind, int processState) {  
  125.         updateProcessState(processState, false);  
  126.         BindServiceData s = new BindServiceData();  
  127.         s.token = token;  
  128.         s.intent = intent;  
  129.         s.rebind = rebind;  
  130.   
  131.         if (DEBUG_SERVICE)  
  132.             Slog.v(TAG, "scheduleBindService token=" + token + " intent=" + intent + " uid="  
  133.                     + Binder.getCallingUid() + " pid=" + Binder.getCallingPid());  
  134.         sendMessage(H.BIND_SERVICE, s);  
  135.     }  
  136.   
  137.     //...     
  138. }  
        schedulePauseActivity里面有个H.PAUSE_ACTIVITY_FINISHING。
        前面说过，H也是ActivityThread的一个内部类，继承Handler，用来处理Activty,Service等生命周期的回调消息。关于Handler Loopr的通信原理，可以参考一下以前写过一篇博文《从Android源码角度对Handler，MessageQueue，Looper之间消息传递工作原理的理解》。
        ActivityThread.class
[java] view plain copy
  1. private class H extends Handler {  
  2.           
  3.     public void handleMessage(Message msg) {  
  4.         if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));  
  5.         switch (msg.what) {  
  6.             case LAUNCH_ACTIVITY: {  
  7.                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");  
  8.                 final ActivityClientRecord r = (ActivityClientRecord) msg.obj;  
  9.   
  10.                 r.packageInfo = getPackageInfoNoCheck(  
  11.                         r.activityInfo.applicationInfo, r.compatInfo);  
  12.                 handleLaunchActivity(r, null);  
  13.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  14.             } break;  
  15.             case RELAUNCH_ACTIVITY: {  
  16.                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityRestart");  
  17.                 ActivityClientRecord r = (ActivityClientRecord)msg.obj;  
  18.                 handleRelaunchActivity(r);  
  19.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  20.             } break;  
  21.             case PAUSE_ACTIVITY:  
  22.                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");  
  23.                 handlePauseActivity((IBinder)msg.obj, false, (msg.arg1&1) != 0, msg.arg2,  
  24.                         (msg.arg1&2) != 0);  
  25.                 maybeSnapshot();  
  26.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  27.                 break;  
  28.             case PAUSE_ACTIVITY_FINISHING:  
  29.                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityPause");  
  30.                 handlePauseActivity((IBinder)msg.obj, true, (msg.arg1&1) != 0, msg.arg2,  
  31.                         (msg.arg1&1) != 0);  
  32.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  33.                 break;  
  34.             case STOP_ACTIVITY_SHOW:  
  35.                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");  
  36.                 handleStopActivity((IBinder)msg.obj, true, msg.arg2);  
  37.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  38.                 break;  
  39.             case STOP_ACTIVITY_HIDE:  
  40.                 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStop");  
  41.                 handleStopActivity((IBinder)msg.obj, false, msg.arg2);  
  42.                 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  43.                 break;  
  44.            //...       
  45.         }  

        ActivityThread.class
[java] view plain copy
  1. private void handlePauseActivity(IBinder token, boolean finished,  
  2.           boolean userLeaving, int configChanges, boolean dontReport) {  
  3.       ActivityClientRecord r = mActivities.get(token);  
  4.       if (r != null) {  
  5.           //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);  
  6.           if (userLeaving) {  
  7.               performUserLeavingActivity(r);  
  8.           }  
  9.   
  10.           r.activity.mConfigChangeFlags |= configChanges;  
  11.           performPauseActivity(token, finished, r.isPreHoneycomb());  
  12.   
  13.           // Make sure any pending writes are now committed.  
  14.           if (r.isPreHoneycomb()) {  
  15.               QueuedWork.waitToFinish();  
  16.           }  
  17.   
  18.           // Tell the activity manager we have paused.  
  19.           if (!dontReport) {  
  20.               try {  
  21.                   ActivityManagerNative.getDefault().activityPaused(token);  
  22.               } catch (RemoteException ex) {  
  23.               }  
  24.           }  
  25.           mSomeActivitiesChanged = true;  
  26.       }  
  27.   }  
        ActivityThread.class
[java] view plain copy
  1. final Bundle performPauseActivity(IBinder token, boolean finished,  
  2.         boolean saveState) {  
  3.     ActivityClientRecord r = mActivities.get(token);  
  4.     return r != null ? performPauseActivity(r, finished, saveState) : null;  
  5. }  
  6.   
  7.   
  8. final Bundle performPauseActivity(ActivityClientRecord r, boolean finished,  
  9.         boolean saveState) {  
  10.     if (r.paused) {  
  11.        //...  
  12.     }  
  13.     if (finished) {  
  14.          //...  
  15.     }  
  16.     try {  
  17.         // Next have the activity save its current state and managed dialogs...  
  18.         //通知Activity_A调用onSaveInstanceState保存状态  
  19.         if (!r.activity.mFinished && saveState) {  
  20.             callCallActivityOnSaveInstanceState(r);  
  21.         }  
  22.         // Now we are idle.  
  23.       //通知Activity_A调用OnPause方法  
  24.         r.activity.mCalled = false;  
  25.         mInstrumentation.callActivityOnPause(r.activity);  
  26.         EventLog.writeEvent(LOG_ON_PAUSE_CALLED, UserHandle.myUserId(),  
  27.                 r.activity.getComponentName().getClassName());  
  28.         if (!r.activity.mCalled) {  
  29.             throw new SuperNotCalledException(  
  30.                 "Activity " + r.intent.getComponent().toShortString() +  
  31.                 " did not call through to super.onPause()");  
  32.         }  
  33.   
  34.     } catch (SuperNotCalledException e) {  
  35.         throw e;  
  36.   
  37.     } catch (Exception e) {  
  38.         //...  
  39.     }  
  40.     r.paused = true;  
  41.     return !r.activity.mFinished && saveState ? r.state : null;  
  42. }  
        在这里终于明白了，在启动目标Activity前，如果当前正在运行任何Activity，那么必须首先暂停。
        追踪mInstrumentation.callActivityOnPause(r.activity)
        Instrumentation.class
[java] view plain copy
  1. public void callActivityOnPause(Activity activity) {  
  2.     activity.performPause();  
  3. }  
        Activity.class
[java] view plain copy
  1. final void performPause() {  
  2.     mDoReportFullyDrawn = false;  
  3.     mFragments.dispatchPause();  
  4.     mCalled = false;  
  5.     onPause();  
  6.     mResumed = false;  
  7.     if (!mCalled && getApplicationInfo().targetSdkVersion  
  8.             >= android.os.Build.VERSION_CODES.GINGERBREAD) {  
  9.         throw new SuperNotCalledException(  
  10.                 "Activity " + mComponent.toShortString() +  
  11.                 " did not call through to super.onPause()");  
  12.     }  
  13.     mResumed = false;  
  14. }  
        终于看到了Activity的onPause方法，至此，Activity_A已经执行onPause方法，Activity_B未执行其生命周期的任何方法。
        在下一篇中将继续去追踪Activity_B生命周期回调源码。

相关推荐