`

android ActivityManagerService 源码分析----Activity管理(二)

ActivityManagerService 
阅读更多

本文为原创文章，欢迎转载！转载时请注明出处：http://blog.csdn.net/windskier

    上篇文章分析完了task的创建或者复用，接下来接着分析activity在启动过程中还有哪些工作需要去完成？首先给出整个activity的过程图。

    

1. Starting Window

    当该activity运行在新的task中或者进程中时，需要在activity显示之前显示一个Starting Window。如上图所示的setAppStartingWindow()方法，这个Starting Window上并没有绘制任何的view，它就是一个空白的Window，但是WMS赋予了它一个animation。这个Starting Window的处理过程需要注意几点：

    ·1. 在AMS请求WMS启动Starting Window时，这个过程是被置在WMS的消息队列中，也就是说这个过程是一个异步的过程，并且需要将其置在WMS消息队列的队首。

     一般情况下，Starting Window是在activity Window之前显示的，但是由于是异步过程，因此从理论上来说activity Window较早显示是有可能的，如果这样的话，Starting Window将会被清除而不再显示。例如在addStartingWindow()@PhoneWindowManager.java方法调用addView之前做一个sleep操作，结果就可能不显示Starting Window。

setAppStartingWindow()@WindowManagerService.java

 

[java] view plaincopy
 
 
  1. // The previous app was getting ready to show a  
  2. // starting window, but hasn't yet done so.  Steal it!  
  3. if (DEBUG_STARTING_WINDOW) Slog.v(TAG,  
  4.         "Moving pending starting from " + ttoken  
  5.         + " to " + wtoken);  
  6. wtoken.startingData = ttoken.startingData;  
  7. ttoken.startingData = null;  
  8. ttoken.startingMoved = true;  
  9. Message m = mH.obtainMessage(H.ADD_STARTING, wtoken);  
  10. // Note: we really want to do sendMessageAtFrontOfQueue() because we  
  11. // want to process the message ASAP, before any other queued  
  12. // messages.  
  13. mH.sendMessageAtFrontOfQueue(m);  
  14. return;  


    2. Starting Window是设置了Animation的

 

addStartingWindow()@PhoneWindowManager.java

 

[java] view plaincopy
 
 
  1. final WindowManager.LayoutParams params = win.getAttributes();  
  2. params.token = appToken;  
  3. params.packageName = packageName;  
  4. params.windowAnimations = win.getWindowStyle().getResourceId(  
  5.         com.android.internal.R.styleable.Window_windowAnimationStyle, 0);  
  6. params.setTitle("Starting " + packageName);  


    3. Starting Window同普通的activity Window一样，均为一个PhoneWindow，其中包看着DecorView和ViewRoot。

 

addStartingWindow()@PhoneWindowManager.java

 

[java] view plaincopy
 
 
  1.         try {  
  2.             Context context = mContext;  
  3.             boolean setTheme = false;  
  4.             //Log.i(TAG, "addStartingWindow " + packageName + ": nonLocalizedLabel="  
  5.             //        + nonLocalizedLabel + " theme=" + Integer.toHexString(theme));  
  6.             if (theme != 0 || labelRes != 0) {  
  7.                 try {  
  8.                     context = context.createPackageContext(packageName, 0);  
  9.                     if (theme != 0) {  
  10.                         context.setTheme(theme);  
  11.                         setTheme = true;  
  12.                     }  
  13.                 } catch (PackageManager.NameNotFoundException e) {  
  14.                     // Ignore  
  15.                 }  
  16.             }  
  17.             if (!setTheme) {  
  18.                 context.setTheme(com.android.internal.R.style.Theme);  
  19.             }  
  20.             //创建PhoneWindow  
  21.             Window win = PolicyManager.makeNewWindow(context);  
  22.             if (win.getWindowStyle().getBoolean(  
  23.                     com.android.internal.R.styleable.Window_windowDisablePreview, false)) {  
  24.                 return null;  
  25.             }  
  26.               
  27.             Resources r = context.getResources();  
  28.             win.setTitle(r.getText(labelRes, nonLocalizedLabel));  
  29.       
  30.             win.setType(  
  31.                 WindowManager.LayoutParams.TYPE_APPLICATION_STARTING);  
  32.             // Force the window flags: this is a fake window, so it is not really  
  33.             // touchable or focusable by the user.  We also add in the ALT_FOCUSABLE_IM  
  34.             // flag because we do know that the next window will take input  
  35.             // focus, so we want to get the IME window up on top of us right away.  
  36.             win.setFlags(  
  37.                 WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|  
  38.                 WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|  
  39.                 WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,  
  40.                 WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE|  
  41.                 WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|  
  42.                 WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);  
  43.       
  44.             win.setLayout(WindowManager.LayoutParams.MATCH_PARENT,  
  45.                                 WindowManager.LayoutParams.MATCH_PARENT);  
  46.       
  47.             final WindowManager.LayoutParams params = win.getAttributes();  
  48.             params.token = appToken;  
  49.             params.packageName = packageName;  
  50.             params.windowAnimations = win.getWindowStyle().getResourceId(  
  51.                     com.android.internal.R.styleable.Window_windowAnimationStyle, 0);  
  52.             params.setTitle("Starting " + packageName);  
  53.   
  54.             WindowManagerImpl wm = (WindowManagerImpl)  
  55.                     context.getSystemService(Context.WINDOW_SERVICE);  
  56.             View view = win.getDecorView();  
  57.   
  58.             if (win.isFloating()) {  
  59.                 // Whoops, there is no way to display an animation/preview  
  60.                 // of such a thing!  After all that work...  let's skip it.  
  61.                 // (Note that we must do this here because it is in  
  62.                 // getDecorView() where the theme is evaluated...  maybe  
  63.                 // we should peek the floating attribute from the theme  
  64.                 // earlier.)  
  65.                 return null;  
  66.             }  
  67.               
  68.             if (localLOGV) Log.v(  
  69.                 TAG, "Adding starting window for " + packageName  
  70.                 + " / " + appToken + ": "  
  71.                 + (view.getParent() != null ? view : null));  
  72. <span style="white-space: pre;">  </span>    //向WindowManager addView  
  73.             wm.addView(view, params);  
  74.   
  75.             // Only return the view if it was successfully added to the  
  76.             // window manager... which we can tell by it having a parent.  
  77.             return view.getParent() != null ? view : null;  
  78.         }   



    

 

2. 启动新进程

    如果新启动的activity需要运行在新的进程中，那么这个流程就涉及到了一个新进程的启动，由于画图的局限性，这个过程在上图中没有体现出来。

    所有的ProcessRecord被存储在mProcessNames变量中,以当前的进程的名字为索引。

@ActivityManagerService.java

 

[java] view plaincopy
 
 
  1. final ProcessMap<ProcessRecord> mProcessNames  
  2.         = new ProcessMap<ProcessRecord>();  

 

  进程名字的确定有如下规则： 

①如果Activity设置了android:process属性，则processName为属性设置的值；    

 

@ComponentInfo.java

 

[java] view plaincopy
 
 
  1. public String processName;  

   ②如果Activity没有设置android:process属性，那么Activity的processName为Application的processName。如果Application设置了process属性，那么processName为该值；如果没有设置，processName为Package的名字，即

 

@PackageItemInfo.java

 

[java] view plaincopy
 
 
  1. public String packageName;  

整个进程启动的过程前面有一篇文章介绍过，就不在介绍。

3. Application Transition

    Application Transition是android在实现窗口切换过程中，为了提供更好的用户体验和特定的指示，来呈现出的过渡效果。一般情况下，Application Transition是一个动画效果。

    Application Transition有两种，一种是启动activity时的Transition动画，一种是启动一些widget时的Transition动画。

    Transition类型的设置通过函数prepareAppTransition()@WindowManagerService.java来进行.

    设置完Transition类型之后,通过executeAppTransition()@WindowManagerService.java函数来执行这个Transition。

   prepareAppTransition()-->executeAppTransition()-->performLayoutAndPlaceSurfacesLocked();

   具体的Transition的animation绘制过程在分析WMS再做分析。

   

3.1 activity Transition

    当启动一个activity时，系统会给它的window呈现提供一个animation，这个animation可以在frameworks/base/core/res/res/values/styles.xml中进行设置

 

[html] view plaincopy
 
 
  1. <!-- Standard animations for a full-screen window or activity. -->  
  2. <style name="Animation.Activity">  
  3.     <item name="activityOpenEnterAnimation">@anim/activity_open_enter</item>  
  4.     <item name="activityOpenExitAnimation">@anim/activity_open_exit</item>  
  5.     <item name="activityCloseEnterAnimation">@anim/activity_close_enter</item>  
  6.     <item name="activityCloseExitAnimation">@anim/activity_close_exit</item>  
  7.     <item name="taskOpenEnterAnimation">@anim/task_open_enter</item>  
  8.     <item name="taskOpenExitAnimation">@anim/task_open_exit</item>  
  9.     <item name="taskCloseEnterAnimation">@anim/task_close_enter</item>  
  10.     <item name="taskCloseExitAnimation">@anim/task_close_exit</item>  
  11.     <item name="taskToFrontEnterAnimation">@anim/task_open_enter</item>  
  12.     <item name="taskToFrontExitAnimation">@anim/task_open_exit</item>  
  13.     <item name="taskToBackEnterAnimation">@anim/task_close_enter</item>  
  14.     <item name="taskToBackExitAnimation">@anim/task_close_exit</item>  
  15.     <item name="wallpaperOpenEnterAnimation">@anim/wallpaper_open_enter</item>  
  16.     <item name="wallpaperOpenExitAnimation">@anim/wallpaper_open_exit</item>  
  17.     <item name="wallpaperCloseEnterAnimation">@anim/wallpaper_close_enter</item>  
  18.     <item name="wallpaperCloseExitAnimation">@anim/wallpaper_close_exit</item>  
  19.     <item name="wallpaperIntraOpenEnterAnimation">@anim/wallpaper_intra_open_enter</item>  
  20.     <item name="wallpaperIntraOpenExitAnimation">@anim/wallpaper_intra_open_exit</item>  
  21.     <item name="wallpaperIntraCloseEnterAnimation">@anim/wallpaper_intra_close_enter</item>  
  22.     <item name="wallpaperIntraCloseExitAnimation">@anim/wallpaper_intra_close_exit</item>  
  23. </style>  

 

    activity启动的animation根据当前的activity所在的task状态有所不同，从上面的xml中的animation定义中就可以看出，它的分类：

    ★ 如果启动的activity运行在原来的task中，那么使用animation activityOpenEnterAnimation/activityOpenExitAnimation;

    ★ 如果启动的activity运行在新的task中，那么使用animation taskOpenEnterAnimation/taskOpenExitAnimation;

    ★ 如果结束的activity结束之后原来的task还存在，那么使用activityCloseEnterAnimation/activityCloseExitAnimation;

    ★ 如果结束的activity结束之后原来的task将不存在，也即次activity为task最后的activity，那么使用taskCloseEnterAnimation/taskCloseExitAnimation;

    ★ 一些特定的情况下，AMS需要将某个task move到最前面，例如上一篇文章中的task reparenting过程，此时使用taskToFrontEnterAnimation/taskToFrontExitAnimation;

    ★ 一些特定的情况下，AMS需要将某个task move到最底端，此时使用taskToBackEnterAnimation/taskToBackExitAnimation;

    ★ 如果当前的activity使用的theme中的参数android:windowShowWallpaper为true，此时的activity应该以当前的壁纸为背景，并且前一个显示的activity的背景不是当前的壁纸，此时使用wallpaperOpenEnterAnimation/wallpaperOpenExitAnimation/wallpaperCloseEnterAnimation/wallpaperCloseExitAnimation,

如下面activity所示：

    

    ★ 如果当前的activity使用的theme中的参数android:windowShowWallpaper为true，此时的activity应该以当前的壁纸为背景，并且前一个显示的activity的背景是当前的壁纸，此时使用wallpaperIntraOpenEnterAnimation/wallpaperIntraOpenExitAnimation/wallpaperIntraCloseEnterAnimation/wallpaperIntraCloseExitAnimation.

下面代码即是判断当前应该选择那些带有wallpaper的Transition类型。

performLayoutAndPlaceSurfacesLockedInner()@WindowManagerService.java

 

[java] view plaincopy
 
 
  1. final int NC = mClosingApps.size();  
  2.  NN = NC + mOpeningApps.size();  
  3.  for (i=0; i<NN; i++) {  
  4.      AppWindowToken wtoken;  
  5.      int mode;  
  6.      if (i < NC) {  
  7.          wtoken = mClosingApps.get(i);  
  8.          mode = 1;  
  9.      } else {  
  10.          wtoken = mOpeningApps.get(i-NC);  
  11.          mode = 2;  
  12.      }  
  13.      if (mLowerWallpaperTarget != null) {  
  14.          if (mLowerWallpaperTarget.mAppToken == wtoken  
  15.                  || mUpperWallpaperTarget.mAppToken == wtoken) {  
  16.              foundWallpapers |= mode;  
  17.          }  
  18.      }  
  19.      if (wtoken.appFullscreen) {  
  20.          WindowState ws = wtoken.findMainWindow();  
  21.          if (ws != null) {  
  22.              // If this is a compatibility mode  
  23.              // window, we will always use its anim.  
  24.              if ((ws.mAttrs.flags&FLAG_COMPATIBLE_WINDOW) != 0) {  
  25.                  animLp = ws.mAttrs;  
  26.                  animToken = ws.mAppToken;  
  27.                  bestAnimLayer = Integer.MAX_VALUE;  
  28.              } else if (ws.mLayer > bestAnimLayer) {  
  29.                  animLp = ws.mAttrs;  
  30.                  animToken = ws.mAppToken;  
  31.                  bestAnimLayer = ws.mLayer;  
  32.              }  
  33.          }  
  34.      }  
  35.  }  
  36.   
  37.  if (foundWallpapers == 3) {  
  38.      if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,  
  39.              "Wallpaper animation!");  
  40.      switch (transit) {  
  41.          case WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN:  
  42.          case WindowManagerPolicy.TRANSIT_TASK_OPEN:  
  43.          case WindowManagerPolicy.TRANSIT_TASK_TO_FRONT:  
  44.              transit = WindowManagerPolicy.TRANSIT_WALLPAPER_INTRA_OPEN;  
  45.              break;  
  46.          case WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE:  
  47.          case WindowManagerPolicy.TRANSIT_TASK_CLOSE:  
  48.          case WindowManagerPolicy.TRANSIT_TASK_TO_BACK:  
  49.              transit = WindowManagerPolicy.TRANSIT_WALLPAPER_INTRA_CLOSE;  
  50.              break;  
  51.      }  
  52.      if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,  
  53.              "New transit: " + transit);  
  54.  } else if (oldWallpaper != null) {  
  55.      // We are transitioning from an activity with  
  56.      // a wallpaper to one without.  
  57.      transit = WindowManagerPolicy.TRANSIT_WALLPAPER_CLOSE;  
  58.      if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,  
  59.              "New transit away from wallpaper: " + transit);  
  60.  } else if (mWallpaperTarget != null) {  
  61.      // We are transitioning from an activity without  
  62.      // a wallpaper to now showing the wallpaper  
  63.      transit = WindowManagerPolicy.TRANSIT_WALLPAPER_OPEN;  
  64.      if (DEBUG_APP_TRANSITIONS) Slog.v(TAG,  
  65.              "New transit into wallpaper: " + transit);  
  66.  }  

 

3.2 widget  Transition

    每个widget在启动时的animation和activity不一样,并且在frameworks/base/core/res/res/values/styles.xml中可以设置不同widget。

    

 

[java] view plaincopy
 
 
  1. private boolean applyAnimationLocked(WindowState win,  
  2.         int transit, boolean isEntrance) {  
  3.     if (win.mLocalAnimating && win.mAnimationIsEntrance == isEntrance) {  
  4.         // If we are trying to apply an animation, but already running  
  5.         // an animation of the same type, then just leave that one alone.  
  6.         return true;  
  7.     }  
  8.   
  9.     // Only apply an animation if the display isn't frozen.  If it is  
  10.     // frozen, there is no reason to animate and it can cause strange  
  11.     // artifacts when we unfreeze the display if some different animation  
  12.     // is running.  
  13.     if (!mDisplayFrozen && mPolicy.isScreenOn()) {  
  14.         int anim = mPolicy.selectAnimationLw(win, transit);  
  15.         int attr = -1;  
  16.         Animation a = null;  
  17.         if (anim != 0) {  
  18.             a = AnimationUtils.loadAnimation(mContext, anim);  
  19.         } else {  
  20.             switch (transit) {  
  21.                 case WindowManagerPolicy.TRANSIT_ENTER:  
  22.                     attr = com.android.internal.R.styleable.WindowAnimation_windowEnterAnimation;  
  23.                     break;  
  24.                 case WindowManagerPolicy.TRANSIT_EXIT:  
  25.                     attr = com.android.internal.R.styleable.WindowAnimation_windowExitAnimation;  
  26.                     break;  
  27.                 case WindowManagerPolicy.TRANSIT_SHOW:  
  28.                     attr = com.android.internal.R.styleable.WindowAnimation_windowShowAnimation;  
  29.                     break;  
  30.                 case WindowManagerPolicy.TRANSIT_HIDE:  
  31.                     attr = com.android.internal.R.styleable.WindowAnimation_windowHideAnimation;  
  32.                     break;  
  33.             }  
  34.             if (attr >= 0) {  
  35.                 a = loadAnimation(win.mAttrs, attr);  
  36.             }  
  37.         }  
  38.         if (DEBUG_ANIM) Slog.v(TAG, "applyAnimation: win=" + win  
  39.                 + " anim=" + anim + " attr=0x" + Integer.toHexString(attr)  
  40.                 + " mAnimation=" + win.mAnimation  
  41.                 + " isEntrance=" + isEntrance);  
  42.         if (a != null) {  
  43.             if (DEBUG_ANIM) {  
  44.                 RuntimeException e = null;  
  45.                 if (!HIDE_STACK_CRAWLS) {  
  46.                     e = new RuntimeException();  
  47.                     e.fillInStackTrace();  
  48.                 }  
  49.                 Slog.v(TAG, "Loaded animation " + a + " for " + win, e);  
  50.             }  
  51.             win.setAnimation(a);  
  52.             win.mAnimationIsEntrance = isEntrance;  
  53.         }  
  54.     } else {  
  55.         win.clearAnimation();  
  56.     }  
  57.   
  58.     return win.mAnimation != null;  
  59. }  

 

4. Activity启动

    文章的前面的内容中分析的一直是AMS对一个新启动的activity的管理，activity在AMS中的形态是以ActivityRecord的形式来管理的，下面的时序图中则是描绘了应用中一个activity的创建并启动的过程。

 

5. Activity pausing过程

    Activity pausing过程有3种情况：

    1. 第一种情况是从一个activity启动另一个activity的同时，也伴随着前一个activity的pause过程。

resumeTopActivityLocked()@ActivityStack.java

 

[java] view plaincopy
 
 
  1. // We need to start pausing the current activity so the top one  
  2. // can be resumed...  
  3. if (mResumedActivity != null) {  
  4.     if (DEBUG_SWITCH) Slog.v(TAG, "Skip resume: need to start pausing");  
  5.     startPausingLocked(userLeaving, false);  
  6.     return true;  
  7. }  

 

    2. 第二种情况是当PowerManagerService要求AMS休眠或者设备shutDown时；

@ActivityStack.java

 

[java] view plaincopy
 
 
  1. void pauseIfSleepingLocked() {  
  2.     if (mService.mSleeping || mService.mShuttingDown) {  
  3.         if (!mGoingToSleep.isHeld()) {  
  4.             mGoingToSleep.acquire();  
  5.             if (mLaunchingActivity.isHeld()) {  
  6.                 mLaunchingActivity.release();  
  7.                 mService.mHandler.removeMessages(LAUNCH_TIMEOUT_MSG);  
  8.             }  
  9.         }  
  10.   
  11.         // If we are not currently pausing an activity, get the current  
  12.         // one to pause.  If we are pausing one, we will just let that stuff  
  13.         // run and release the wake lock when all done.  
  14.         if (mPausingActivity == null) {  
  15.             if (DEBUG_PAUSE) Slog.v(TAG, "Sleep needs to pause...");  
  16.             if (DEBUG_USER_LEAVING) Slog.v(TAG, "Sleep => pause with userLeaving=false");  
  17.             startPausingLocked(false, true);  
  18.         }  
  19.     }  
  20. }  

 

    3.第三种情况是一个activity finish过程中。这个下面再介绍。

下图为第一种情况的时序图，整个pausing过程的是相同的，因此以一种情况的时序图来体现activity的pausing过程。

 

6. Activity Stoping 过程

     我们知道，当Activity不可见时会执行stoping的过程，下面我们就来分析以下一个activity是怎么来进行stop的。下面给出整个stop过程的时序图：

    

    在stop中有一个很重要的概念就是activity idle状态，不论是activity被新启动的activity完全覆盖，还是activity被finish，也就是activity的stop过程以及finsh过程，均是在最新被resume的activity已经resume完成之后才去处理。

    我们可以想象一下，每个应用程序的主线程ActivityThread中，当没有任何的消息待处理时，此时我们可以认为此时的已被resumed的activity状态时空闲的，没有任何的人机交互。因此android设计者将前一个被完全覆盖不可见的或者finish的activity的stop或finish操作放在此时来处理。这样做是合情合理，毕竟stop或者finish一个activity以及显示新的activity之间的关系是同步，是必须有先后顺序的，为了达到更好的用户体验，理所当然应该是先显示新的activity，然后采取stop或者finish旧的activity。为了实现这个目的，android设计者使用了MessageQueue的这个IdleHandler机制。

    首先，我们看一下MessageQueue的IdleHandler机制。

next ()@MessageQueue.java

 

[java] view plaincopy
 
 
  1. // Run the idle handlers.  
  2. // We only ever reach this code block during the first iteration.  
  3. for (int i = 0; i < pendingIdleHandlerCount; i++) {  
  4.     final IdleHandler idler = mPendingIdleHandlers[i];  
  5.     mPendingIdleHandlers[i] = null; // release the reference to the handler  
  6.   
  7.     boolean keep = false;  
  8.     try {  
  9.         keep = idler.queueIdle();  
  10.     } catch (Throwable t) {  
  11.         Log.wtf("MessageQueue", "IdleHandler threw exception", t);  
  12.     }  
  13.   
  14.     if (!keep) {  
  15.         synchronized (this) {  
  16.             mIdleHandlers.remove(idler);  
  17.         }  
  18.     }  
  19. }  

    在ActivityThread线程的Looper中，Looper会不停的去查找消息队列中是否有消息需要处理，如果没有任何的消息待处理，那么将查看当前的消息队列是否有IdleHandler注册，如果有逐个执行这些IdleHandler。
    明白了IdleHandler的机制，回过头来了看ActivityThread的IdleHandler的注册过程，代码如下。

 

handleResumeActivity()@ActivityThread.java

 

[java] view plaincopy
 
 
  1. r.nextIdle = mNewActivities;  
  2. mNewActivities = r;  
  3. if (localLOGV) Slog.v(  
  4.     TAG, "Scheduling idle handler for " + r);  
  5. Looper.myQueue().addIdleHandler(new Idler());  

 

7. Activity finishing过程

    用户从application结束当前的activity，如按back键；

   

    如同activity不可见时的处理一样，activity的finishing过程同样是在新的activity被resume之后才去执行，但是存在一种情况，当mHistory栈中存在多个(多于4个)activity时，假如此时user以很快的速度去按back键，并且在第一个需resume的activity尚未被resume完成时，已经被user触发了多次back键，此时应该怎么处理finish过程呢？

    按照上面的逻辑来看，user不停的以很快的速度去触发back键，直到回到home activity，这种情况下ActivityThread的Looper一直会有消息需要处理，根本不可能去处理它的IdleHandler，也就不可能去处理各个activity的finish过程，直到回到home activity之后才能有空闲去处理。我们可以想象一下如果按照这个逻辑去操作的话，会有什么问题？

    设想一下，我们累计了多个activity在ActivityThread的Looper在idle状态下处理，那么这个过程将是比较长的，假如此时又有user触发了启动actibity的操作，那么ActivityThread将会同时处理累计的activity的finish过程，同时又需要处理activity的启动过程，那么这么做的结果只能是给用户带来系统很慢的用户体验。因此上面的finish逻辑需要进行一定的矫正与修改。

    AMS在累计的activity超过3个时，就会强制调用Idle处理操作。这么做就有效的消耗了累计的activity的finish过程，就很大程度上减轻了上述所说的问题。

finishCurrentActivityLocked()@ActivityStack.java

 

[java] view plaincopy
 
 
  1. // First things first: if this activity is currently visible,  
  2. // and the resumed activity is not yet visible, then hold off on  
  3. // finishing until the resumed one becomes visible.  
  4. if (mode == FINISH_AFTER_VISIBLE && r.nowVisible) {  
  5.     if (!mStoppingActivities.contains(r)) {  
  6.         mStoppingActivities.add(r);  
  7.         Slog.d(TAG, "finishCurrentActivityLocked mStoppingActivities size:" + mStoppingActivities.size());  
  8.         if (mStoppingActivities.size() > 3) {  
  9.             // If we already have a few activities waiting to stop,  
  10.             // then give up on things going idle and start clearing  
  11.             // them out.  
  12.             Message msg = Message.obtain();  
  13.             msg.what = IDLE_NOW_MSG;  
  14.             mHandler.sendMessage(msg);  
  15.         }  
  16.     }  
  17.     r.state = ActivityState.STOPPING;  
  18.     mService.updateOomAdjLocked();  
  19.     return r;  
  20. }  

    同样的问题也存在与activity启动过程中，假如user以很快的速度去不停的启动activity，那么被覆盖的activity的stop过程很上述的finish过程一样，也会不停的累计，出现相同的问题。解决的思路也是一致的。
completePauseLocked()@ActivityStack.java

 

 

[java] view plaincopy
 
 
  1. mStoppingActivities.add(prev);  
  2. if (mStoppingActivities.size() > 3) {  
  3.     // If we already have a few activities waiting to stop,  
  4.     // then give up on things going idle and start clearing  
  5.     // them out.  
  6.     if (DEBUG_PAUSE) Slog.v(TAG, "To many pending stops, forcing idle");  
  7.     Message msg = Message.obtain();  
  8.     msg.what = IDLE_NOW_MSG;  
  9.     mHandler.sendMessage(msg);  
  10. }  
分享到：
| android ActivityManagerService 源码分析 ...
评论
1 楼 haobooo 2014-07-17  
hi, can you tell me what tool do you use to generate the figure of Activity?
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    android ActivityManagerService 源码分析----Activity管理

    android ActivityManagerService 学习资料

    AMS注释源码(ActivityManagerService)

    ams注释源码，startActivity相关逻辑已添加注释！快速帮助你理解AMS的处理逻辑，该资源配合我的博客Android进阶 — ActivityManagerService模块分析（https://blog.csdn.net/jackzhouyu/article/details/109021412）

    Android系统源代码情景分析-罗升阳-源码

    《Android系统源代码情景分析》随书光盘内容（源代码） 目录如下： 第1篇 初识Android系统 第1章　准备知识 1.1　Linux内核参考书籍 1.2　Android应用程序参考书籍 1.3　下载、编译和运行Android源代码 1.3.1　下载...

    Android代码-android-advanced-decode

    《Android进阶解密》源码 ...第6章介绍ActivityManagerService，包括AMS家族、AMS的启动过程、AMS重要的数据结构和Activity栈管理等内容。 第7章介绍WindowManager，包括WindowManager的关联类、Window的属性和Window

    深入理解Android--卷2.pdf

    对Android的源代码进行深入分析。内容广泛，以对Framework层的分析为主，分析系统服务源码，如ActivityManagerService、PackageManagerservice等。

    java8集合源码分析-AndroidLearn:Android学习笔记

    ActivityManagerService PMS Art/Dalvik Http Http WebSocket Udp Kotlin 算法 快速排序 链表 重新排版 RxJava2 Glide GreenDao 其他 反编译 Hook 动态加载 编译构建 设计模式 代理模式 装饰者模式 架构 MVVM 组件化...

    深入理解Android：卷I--详细书签版

    4.4.1 ActivityManagerService发送请求 84 4.4.2 有求必应之响应请求 86 4.4.3 关于zygote分裂的总结 88 4.5 拓展思考 88 4.5.1 虚拟机heapsize的限制 88 4.5.2 开机速度优化 89 4.5.3 Watchdog分析 90 4.6 ...

    《深入理解Android》卷Ⅱ

    6.2.1　ActivityManagerService的main函数分析 6.2.2　AMS的 setSystemProcess分析 6.2.3　AMS的 installSystemProviders函数分析 6.2.4　AMS的 systemReady分析 6.2.5　初识ActivityManagerService总结 6.3　start...

    深入理解Android:卷2，中文完整扫描版

    第6章以ActivityManagerService为分析重点，它的启动、Activity的创建和启动、BroadcastReceiver的工作原理、Android中的进程管理等内容展开了较为深入的研究；第7章对ContentProvider的创建和启动、SQLite、Cursor ...

    深入理解Android(卷2)

    第6章以ActivityManagerService为分析重点，它的启动、Activity的创建和启动、BroadcastReceiver的工作原理、Android中的进程管理等内容展开了较为深入的研究；第7章对ContentProvider的创建和启动、SQLite、Cursor ...

    Android系统源代码情景分析光盘

    Android系统源代码情景分析光盘资料 目录 第1篇初识Android系统 第1章　准备知识................................................................ 2 1.1　Linux内核参考书籍......................................

    《深入理解Android》卷Ⅰ

    4.4.1 ActivityManagerService发送请求 4.4.2 有求必应之响应请求 4.4.3 关于zygote分裂的总结 4.5 拓展思考 4.5.1 虚拟机heapsize的限制 4.5.2 开机速度优化 4.5.3 Watchdog分析 4.6 本章小结 第5章 深入理解常见...

    深入理解Android卷1全

    4.4.1 ActivityManagerService发送请求 / 84 4.4.2 有求必应之响应请求 / 86 4.4.3 关于zygote分裂的总结 / 88 4.5 拓展思考 / 88 4.5.1 虚拟机heapsize的限制 / 88 4.5.2 开机速度优化 / 89 4.5.3 Watchdog分析 / ...

    Android开发艺术探索

    1.1 Activity的生命周期全面分析 ／ 1 1.1.1 典型情况下的生命周期分析 ／ 2 1.1.2 异常情况下的生命周期分析 ／ 8 1.2 Activity的启动模式 ／ 16 1.2.1 Activity的Launch Mode ／ 16 1.2.2 Activity的Flags ／...

    android开发艺术探索高清完整版PDF

    《Android开发艺术探索》是一本Android进阶类书籍，采用理论、源码和实践相结合的方式来阐述高水准的Android应用开发要点。《Android开发艺术探索》从三个方面来组织内容。第一，介绍Android开发者不容易掌握的一些...

Magicbox
Global site tag (gtag.js) - Google Analytics