Android应用程序键盘（Keyboard）消息处理机制分析（25）

  Step 2. ActivityStack.activityIdleInternal

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

1. public class ActivityStack {  
2.     ......  
3.   
4.     final void activityIdleInternal(IBinder token, boolean fromTimeout,  
5.             Configuration config) {  
6.         ......  
7.   
8.         ArrayList<ActivityRecord> stops = null;  
9.         ......  
10.   
11.         int NS = 0;  
12.         ......  
13.   
14.         synchronized (mService) {  
15.             ......  
16.   
17.             // Atomically retrieve all of the other things to do.  
18.             stops = processStoppingActivitiesLocked(true);  
19.             NS = stops != null ? stops.size() : 0;  
20.             ......  
21.         }  
22.   
23.         int i;  
24.   
25.         ......  
26.   
27.         // Stop any activities that are scheduled to do so but have been  
28.         // waiting for the next one to start.  
29.         for (i=0; i<NS; i++) {  
30.             ActivityRecord r = (ActivityRecord)stops.get(i);  
31.             synchronized (mService) {  
32.                 if (r.finishing) {  
33.                     finishCurrentActivityLocked(r, FINISH_IMMEDIATELY);  
34.                 } else {  
35.                     ......  
36.                 }  
37.             }  
38.         }  
39.   
40.         ......  
41.     }  
42.   
43.     ......  
44. }  

        这个函数首先会调用processStoppingActivitiesLocked函数把所有处于Stopped状态的Activity取回来，然后逐个分析它们，如果它们的ActivityRecord中的finishing成员变量为true，就说明这个Activity需要销毁了，于是，就调用finishCurrentActivityLocked函数来销毁它们。

 

        Step 3. ActivityStack.finishCurrentActivityLocked

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

1. public class ActivityStack {  
2.     ......  
3.   
4.     private final ActivityRecord finishCurrentActivityLocked(ActivityRecord r,  
5.             int mode) {  
6.         ......  
7.   
8.         return finishCurrentActivityLocked(r, index, mode);  
9.     }  
10.   
11.     private final ActivityRecord finishCurrentActivityLocked(ActivityRecord r,  
12.             int index, int mode) {  
13.         ......  
14.   
15.         // make sure the record is cleaned out of other places.  
16.         mStoppingActivities.remove(r);  
17.         mWaitingVisibleActivities.remove(r);  
18.         ......  
19.   
20.         final ActivityState prevState = r.state;  
21.         r.state = ActivityState.FINISHING;  
22.   
23.         if (mode == FINISH_IMMEDIATELY  
24.             || prevState == ActivityState.STOPPED  
25.             || prevState == ActivityState.INITIALIZING) {  
26.             // If this activity is already stopped, we can just finish  
27.             // it right now.  
28.             return destroyActivityLocked(r, true) ? null : r;  
29.         } else {  
30.             ......  
31.         }  
32.   
33.         return r;  
34.     }  
35.   
36.     ......  
37. }  

        从上面的Step 2中传进来的参数mode为FINISH_IMMEDIATELY，并且这个即将要被销毁的Activity的状态为Stopped，因此，接下来就会调用destroyActivityLocked函数来销毁它。

 

        Step 4. ActivityStack.destroyActivityLocked

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

1. public class ActivityStack {  
2.     ......  
3.   
4.     final boolean destroyActivityLocked(ActivityRecord r,  
5.             boolean removeFromApp) {  
6.         ......  
7.   
8.         boolean removedFromHistory = false;  
9.   
10.         ......  
11.   
12.         final boolean hadApp = r.app != null;  
13.   
14.         if (hadApp) {  
15.             ......  
16.   
17.             try {  
18.                 ......  
19.                 r.app.thread.scheduleDestroyActivity(r, r.finishing,  
20.                     r.configChangeFlags);  
21.             } catch (Exception e) {  
22.                 ......  
23.             }  
24.   
25.             ......  
26.         } else {  
27.             ......  
28.         }  
29.   
30.         ......  
31.   
32.         return removedFromHistory;  
33.     }  
34.   
35.     ......  
36. }  

         在前面一篇文章Android应用程序启动过程源代码分析中，我们说到，每一个应用程序进程在ActivityManagerService中，都ProcessRecord记录与之对应，而每一个Activity，都是运行在一个进程上下文中，因此，在ActivityManagerService中，每一个ActivityRecord的app成员变量都应该指向一个ProcessRecord记录，于是，这里得到的hadApp为true。在ProcessRecord类中，有一个成员变量thread，它的类型为IApplicationThread。在文章Android应用程序启动过程源代码分析中，我们也曾经说过，每一个应用程序在启动的时候，它都会在内部创建一个ActivityThread对象，而在这个ActivityThread对象中，有一个成员变量mAppThread，它的类型为ApplicationThread，这是一个Binder对象，专门用来负责在应用程序和ActivityManagerService之间执行进程间通信工作的。应用程序在启动的时候，就会将这个Binder对象传递给ActivityManagerService，而ActivityManagerService就会把它保存在相应的ProcessRecord记录的thread成员变量中。因此，ProcessRecord记录的thread成员变量其实就是ApplicationThread对象的远程接口，于是，执行下面这个语句的时候：

1. r.app.thread.scheduleDestroyActivity(r, r.finishing,  
2.     r.configChangeFlags);  

        就会进入到ApplicationThread类中的scheduleDestroyActivity函数来。

 

        Step 5. ApplicationThread.scheduleDestroyActivity

        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {  
2.     ......  
3.   
4.     private final class ApplicationThread extends ApplicationThreadNative {  
5.         ......  
6.   
7.         public final void scheduleDestroyActivity(IBinder token, boolean finishing,  
8.                 int configChanges) {  
9.   
10.             queueOrSendMessage(H.DESTROY_ACTIVITY, token, finishing ? 1 : 0,  
11.                     configChanges);  
12.         }  
13.   
14.         ......  
15.     }  
16.   
17.     ......  
18. }  

        这个函数调用外部类ActivityThread的queueOrSendMessage函数来往应用程序的消息队列中发送一个H.DESTROY_ACTIVITY消息，这个消息最终由ActivityThread类的handleDestroyActivity函数来处理。

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966656，如需转载请自行联系原作者