Android文件监控FileObserver介绍



转载地址：http://blog.csdn.net/yangwen123/article/details/36379763

在前面的Linux文件系统Inotify机制 中介绍了Linux对文件变更监控过程。Android系统在此基础上封装了一个FileObserver类来方便使用Inotify机制。FileObserver是一个抽象类，需要定义子类实现该类的onEvent抽象方法，当被监控的文件或者目录发生变更事件时，将回调FileObserver的onEvent()函数来处理文件或目录的变更事件。

事件监控过程

在FileObserver类中定义了一个静态内部类ObserverThread，该线程类才是真正实现文件或目录监控过程。各种类型的FileObserver都拥有一个ObserverThread实例：

frameworks\base\core\Java\android\os\FileObserver.java

[java]   view plain  copy

1. public abstract class FileObserver {  
2.     //可监控的事件类型  
3.     public static final int ALL_EVENTS = ACCESS | MODIFY | ATTRIB | CLOSE_WRITE  
4.             | CLOSE_NOWRITE | OPEN | MOVED_FROM | MOVED_TO | DELETE | CREATE | DELETE_SELF | MOVE_SELF;  
5.     //静态创建并启动一个文件监控线程  
6.     private static ObserverThread s_observerThread;  
7.     static {  
8.         s_observerThread = new ObserverThread();  
9.         s_observerThread.start();  
10.     }  
11.     // instance  
12.     private String m_path;  
13.     private Integer m_descriptor;  
14.     private int m_mask;  
15. }  

FileObserver类通过静态方式构造了一个ObserverThread对象：

[java]   view plain  copy

1. public ObserverThread() {  
2.     super("FileObserver");  
3.     m_fd = init();//初始化一个inotify实例，Observer线程就是对该inotify实例进行监控  
4. }  

frameworks\base\core\jni\android_util_FileObserver.cpp

[java]   view plain  copy

1. static jint android_os_fileobserver_init(JNIEnv* env, jobject object)  
2. {  
3. #ifdef HAVE_INOTIFY  
4.     return (jint)inotify_init();//初始化一个inotify实例     
5. #else // HAVE_INOTIFY  
6.     return -1;  
7. #endif // HAVE_INOTIFY  
8. }  

inotify_init()函数实现在Linux文件系统Inotify机制 有详细介绍，然后启动ObserverThread线程，ObserverThread线程运行体：

frameworks\base\core\java\android\os\FileObserve$ObserverThread

[java]   view plain  copy

1. public void run() {  
2.     observe(m_fd);//监控inotify实例句柄  
3. }  

frameworks\base\core\jni\android_util_FileObserver.cpp

[cpp]   view plain  copy

1. static void android_os_fileobserver_observe(JNIEnv* env, jobject object, jint fd)  
2. {  
3. #ifdef HAVE_INOTIFY  
4.     char event_buf[512];//定义事件数组  
5.     struct inotify_event* event;  
6.     while (1)  
7.     {  
8.         int event_pos = 0;  
9.         //从inotify实例句柄中读取事件  
10.         int num_bytes = read(fd, event_buf, sizeof(event_buf));  
11.         if (num_bytes < (int)sizeof(*event))  
12.         {  
13.             if (errno == EINTR)  
14.                 continue;  
15.             ALOGE("***** ERROR! android_os_fileobserver_observe() got a short event!");  
16.             return;  
17.         }  
18.         //循环处理读取到的事件  
19.         while (num_bytes >= (int)sizeof(*event))  
20.         {  
21.             int event_size;  
22.             event = (struct inotify_event *)(event_buf + event_pos);  
23.             jstring path = NULL;  
24.             if (event->len > 0)  
25.             {  
26.                 path = env->NewStringUTF(event->name);  
27.             }  
28.             //调用ObserverThread的onEvent函数通知上层响应  
29.             env->CallVoidMethod(object, method_onEvent, event->wd, event->mask, path);  
30.             if (env->ExceptionCheck()) {  
31.                 env->ExceptionDescribe();  
32.                 env->ExceptionClear();  
33.             }  
34.             if (path != NULL)  
35.             {  
36.                 env->DeleteLocalRef(path);  
37.             }  
38.             event_size = sizeof(*event) + event->len;  
39.             num_bytes -= event_size;  
40.             event_pos += event_size;  
41.         }  
42.     }  
43. #endif // HAVE_INOTIFY  
44. }  

ObserverThread线程循环从inotify实例句柄中读取事件，然后回调ObserverThread的onEvent函数来处理事件。

frameworks\base\core\java\android\os\FileObserve$ObserverThread

[java]   view plain  copy

1. public void onEvent(int wfd, int mask, String path) {  
2.     // look up our observer, fixing up the map if necessary...  
3.     FileObserver observer = null;  
4.     synchronized (m_observers) {  
5.         //根据wfd句柄从m_observers表中查找出注册的FileObserver对象  
6.         WeakReference weak = m_observers.get(wfd);  
7.         if (weak != null) {  // can happen with lots of events from a dead wfd  
8.             observer = (FileObserver) weak.get();  
9.             if (observer == null) {  
10.                 m_observers.remove(wfd);  
11.             }  
12.         }  
13.     }  
14.     // ...then call out to the observer without the sync lock held  
15.     if (observer != null) {  
16.         try {  
17.             //调用对应的FileObserver对象的onEvent函数来处理事件  
18.             observer.onEvent(mask, path);  
19.         } catch (Throwable throwable) {  
20.             Log.wtf(LOG_TAG, "Unhandled exception in FileObserver " + observer, throwable);  
21.         }  
22.     }  
23. }  

注册监控watch

FileObserver类提供了startWatching()函数来启动文件监控

frameworks\base\core\java\android\os\FileObserver.java

[java]   view plain  copy

1. public void startWatching() {  
2.     if (m_descriptor < 0) {  
3.         m_descriptor = s_observerThread.startWatching(m_path, m_mask, this);  
4.     }  
5. }  

由ObserverThread线程对象启动监控

frameworks\base\core\java\android\os\FileObserver$ObserverThread

[java]   view plain  copy

1. public int startWatching(String path, int mask, FileObserver observer) {  
2.     //在Inotify实例中添加一个watch对象，并得到一个watch对象句柄  
3.     int wfd = startWatching(m_fd, path, mask);  
4.     Integer i = new Integer(wfd);  
5.     if (wfd >= 0) {  
6.         //将watch对象句柄和响应该watch事件的FileObserver以键值对的形式保存在m_observers成员变量中  
7.         synchronized (m_observers) {  
8.             m_observers.put(i, new WeakReference(observer));  
9.         }  
10.     }  
11.     return i;  
12. }  

ObserverThread又调用native方法android_os_fileobserver_startWatching()来添加一个watch

frameworks\base\core\jni\android_util_FileObserver.cpp

[java]   view plain  copy

1. static jint android_os_fileobserver_startWatching(JNIEnv* env, jobject object, jint fd, jstring pathString, jint mask)  
2. {  
3.     int res = -1;  
4. #ifdef HAVE_INOTIFY  
5.     if (fd >= 0)  
6.     {  
7.         const char* path = env->GetStringUTFChars(pathString, NULL);  
8.         //在Inotify实例上添加一个watch对象  
9.         res = inotify_add_watch(fd, path, mask);  
10.         env->ReleaseStringUTFChars(pathString, path);  
11.     }  
12. #endif // HAVE_INOTIFY  
13.     return res;  
14. }  

注销监控watch

FileObserver类提供了使用stopWatching()函数来停止文件监控。
frameworks\base\core\java\android\os\FileObserver$ObserverThread

[java]   view plain  copy

1. public void stopWatching() {  
2.     if (m_descriptor >= 0) {  
3.         s_observerThread.stopWatching(m_descriptor);  
4.         m_descriptor = -1;  
5.     }  
6. }  

frameworks\base\core\java\android\os\FileObserve$ObserverThread

[cpp]   view plain  copy

1. public void stopWatching(int descriptor) {  
2.     stopWatching(m_fd, descriptor);  
3. }  

frameworks\base\core\jni\android_util_FileObserver.cpp

[cpp]   view plain  copy

1. static void android_os_fileobserver_stopWatching(JNIEnv* env, jobject object, jint fd, jint wfd)  
2. {  
3. #ifdef HAVE_INOTIFY  
4.     inotify_rm_watch((int)fd, (uint32_t)wfd);  
5. #endif // HAVE_INOTIFY  
6. }