Android文件的监控主要是FileObserver封装linux底层的inotify机制实现

FileObserver( frameworks/base/core/java/android/os/FileObserver.java )

FileObserver是一个抽象类

主要方法：

Start watching for events，回调到FileObserver静态内部类ObserverThread的具体方法startWatching

public void startWatching() {
        if (m_descriptor < 0) {
            m_descriptor = s_observerThread.startWatching(m_path, m_mask, this);
        }
    }

Stop watching for events，同理

public void stopWatching() {
        if (m_descriptor >= 0) {
            s_observerThread.stopWatching(m_descriptor);
            m_descriptor = -1;
        }
    }

实现类需要具体实现该方法，方法用于处理索监听文件（夹）的变化

public abstract void onEvent(int event, @Nullable String path);

静态代码段，启动监察线程

static {
        s_observerThread = new ObserverThread();
        s_observerThread.start();
    }

ObserverThread 是FileObserver的静态内部类，它继承于Thread，

主要作用：调用native层的inotity机制，进行具体的注册和监听,

耗时的observer操作放在了run()放发中实现

ObserverThread

private static class ObserverThread extends Thread {
    private HashMap<Integer, WeakReference> m_observers = new HashMap<Integer, WeakReference>();
    private int m_fd;

    public ObserverThread() {
    super("FileObserver");
    m_fd = init();
    }

    public void run() {
    observe(m_fd);
    }

    public int startWatching(String path, int mask, FileObserver observer) {
    int wfd = startWatching(m_fd, path, mask);

    Integer i = new Integer(wfd);
    if (wfd >= 0) {
        synchronized (m_observers) {
            m_observers.put(i, new WeakReference(observer));
        }
    }

    return i;
    }

    public void stopWatching(int descriptor) {
    stopWatching(m_fd, descriptor);
    }

    public void onEvent(int wfd, int mask, String path) {
    // look up our observer, fixing up the map if necessary...
    FileObserver observer = null;

    synchronized (m_observers) {
        WeakReference weak = m_observers.get(wfd);
        if (weak != null) {  // can happen with lots of events from a dead wfd
            observer = (FileObserver) weak.get();
            if (observer == null) {
                m_observers.remove(wfd);
            }
        }
    }

    // ...then call out to the observer without the sync lock held
    if (observer != null) {
        try {
            observer.onEvent(mask, path);
        } catch (Throwable throwable) {
            Log.wtf(LOG_TAG, "Unhandled exception in FileObserver " + observer, throwable);
        }
    }
    }

    private native int init();
    private native void observe(int fd);
    private native int startWatching(int fd, String path, int mask);
    private native void stopWatching(int fd, int wfd);
}

natvie层实现：/frameworks/base/core/jni/android_util_FileObserver.cpp

在android_os_fileobserver_observe方法中进行监控逻辑的处理

static void android_os_fileobserver_observe(JNIEnv* env, jobject object, jint fd)
{
     //当read到满足监控类型的变化时，会回调到FileObserver的ObserverTrehad的onEvent方法
     // 又会回调到FileObserver的onEvent方法 
     env->CallVoidMethod(object, method_onEvent, event->wd, event->mask, path);  
     ... 
}

一些具体的使用参考：

http://www.cnblogs.com/lanrenxinxin/p/5536969.html

https://www.ibm.com/developerworks/cn/linux/l-inotifynew/

https://github.com/HayDar-Android/FileScanner