logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

【转】[android ActivityManagerService 源码分析----Activity管理(二)

 techres 2012-05-22

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

楼主
发表于 2012-2-2 07:22:39 | 查看: 899| 回复: 2
上篇文章分析完了task的创建或者复用，接下来接着分析activity在启动过程中还有哪些工作需要去完成？首先给出整个activity的过程图。
      1.jpg 
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
  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
  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
  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);

  54.             WindowManagerImpl wm = (WindowManagerImpl)
  55.                     context.getSystemService(Context.WINDOW_SERVICE);
  56.             View view = win.getDecorView();

  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);

  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.jpg 

2. 启动新进程    如果新启动的activity需要运行在新的进程中，那么这个流程就涉及到了一个新进程的启动，由于画图的局限性，这个过程在上图中没有体现出来。
    所有的ProcessRecord被存储在mProcessNames变量中,以当前的进程的名字为索引。
@ActivityManagerService.java
  1.     final ProcessMap<ProcessRecord> mProcessNames
  2.             = new ProcessMap<ProcessRecord>();
复制代码
进程名字的确定有如下规则：
①如果Activity设置了android:process属性，则processName为属性设置的值；   

@ComponentInfo.java
  1. public String processName;
复制代码
②
如果Activity没有设置android:process属性，那么Activity的processName为Application的processName。如果Application设置了process属性，那么processName为该值；如果没有设置，processName为Package的名字，即

@PackageItemInfo.java
  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.jpg
3.1 activity Transition
    当启动一个activity时，系统会给它的window呈现提供一个animation，这个animation可以在frameworks/base/core/res/res/values/styles.xml中进行设置
  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所示：
    4.jpg
    ★ 如果当前的activity使用的theme中的参数android:windowShowWallpaper为true，此时的activity应该以当前的壁纸为背景，并且前一个显示的activity的背景是当前的壁纸，此时使用wallpaperIntraOpenEnterAnimation/wallpaperIntraOpenExitAnimation/wallpaperIntraCloseEnterAnimation/wallpaperIntraCloseExitAnimation.
下面代码即是判断当前应该选择那些带有wallpaper的Transition类型。
performLayoutAndPlaceSurfacesLockedInner()@WindowManagerService.java
  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.                         }

  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。
  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.         }

  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.         }

  58.         return win.mAnimation != null;
  59.     }
复制代码
4. Activity启动
    文章的前面的内容中分析的一直是AMS对一个新启动的activity的管理，activity在AMS中的形态是以ActivityRecord的形式来管理的，下面的时序图中则是描绘了应用中一个activity的创建并启动的过程。

5.jpg


5. Activity pausing过程    Activity pausing过程有3种情况：
    1. 第一种情况是从一个activity启动另一个activity的同时，也伴随着前一个activity的pause过程。??
resumeTopActivityLocked()@ActivityStack.java
  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
  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.             }

  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.jpg 

6. Activity Stoping 过程     我们知道，当Activity不可见时会执行stoping的过程，下面我们就来分析以下一个activity是怎么来进行stop的。下面给出整个stop过程的时序图：
      7.jpg 
    在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
  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

  7.                 boolean keep = false;
  8.                 try {
  9.                     keep = idler.queueIdle();
  10.                 } catch (Throwable t) {
  11.                     Log.wtf("MessageQueue", "IdleHandler threw exception", t);
  12.                 }

  14.                 if (!keep) {
  15.                     synchronized (this) {
  16.                         mIdleHandlers.remove(idler);
  17.                     }
  18.                 }
  19.             }
复制代码
在ActivityThread线程的Looper中，Looper会不停的去查找消息队列中是否有消息需要处理，如果没有任何的消息待处理，那么将查看当前的消息队列是否有IdleHandler注册，如果有逐个执行这些IdleHandler。

    明白了IdleHandler的机制，回过头来了看ActivityThread的IdleHandler的注册过程，代码如下。

handleResumeActivity()@ActivityThread.java
  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键；
      8.jpg 
    如同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
  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
  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.                     }
复制代码

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： techres > 《Android源码解读》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多