Android 智能文件观察者 FileObserver

实现监听目录下面的所有文件，包括子目录。
新创建的目录也可以自动加入监听。
 
  
删除移动文件夹，自动删除和添加对应的监听器！
 
  
 
  
 
  
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import android.os.FileObserver;
import android.util.Log;

/**
 * 实现监听目录下面的所有文件，包括子目录。
 * 新创建的目录也可以自动加入监听。
 * 
 * @author  gege
 * @version  [版本号, 2014-7-30]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class SmartFileObserver
{
    private static final String TAG = SmartFileObserver.class.getSimpleName();
    
    private void log(Object o)
    {
        Log.d(TAG, "" + o);
    }
    
    private List mObservers;
    
    private String mPath;
    
    public SmartFileObserver(String path)
    {
        mPath = path;
    }
    
    public void startWatching()
    {
        if (mObservers != null)
            return;
        
        mObservers = new ArrayList();
        Stack stack = new Stack();
        stack.push(mPath);
        
        while (!stack.isEmpty())
        {
            String parent = stack.pop();
            mObservers.add(new SingleFileObserver(parent));
            File path = new File(parent);
            File[] files = path.listFiles();
            if (null == files)
                continue;
            for (File f : files)
            {
                if (f.isDirectory() && !f.getName().equals(".")
                        && !f.getName().equals(".."))
                {
                    stack.push(f.getPath());
                }
            }
        }
        
        for (SingleFileObserver sfo : mObservers)
        {
            sfo.startWatching();
        }
    }
    
    public synchronized void onEvent(int event, String newPath)
    {
        log("event=" + evt2str(event) + ", newPath = " + newPath);
        processEvent(event, newPath);
    }
    
    public void stopWatching()
    {
        if (mObservers == null)
            return;
        
        for (SingleFileObserver sfo : mObservers)
        {
            sfo.stopWatching();
        }
        mObservers.clear();
        mObservers = null;
    }
    
    public void listObservers()
    {
        if (mObservers == null)
        {
            return;
        }
        for (SingleFileObserver sfo : mObservers)
        {
            log("sfo = " + sfo.getPath());
        }
    }
    
    private void addObserver(String path)
    {
        if (mObservers == null)
        {
            return;
        }
        File f = new File(path);
        if (f.isDirectory())
        {
            SingleFileObserver sfo = new SingleFileObserver(path);
            mObservers.add(sfo);
            sfo.startWatching();
            log("addObserver sfo = " + sfo.getPath());
        }
    }
    
    private void deleteObserver(String path)
    {
        if (mObservers == null)
        {
            return;
        }
        for (SingleFileObserver sfo : mObservers)
        {
            if (sfo.getPath().equals(path))
            {
                sfo.stopWatching();
                mObservers.remove(sfo);
                log("deleteObserver sfo = " + sfo.getPath());
            }
        }
    }
    
    private void processEvent(int event, String newPath)
    {
        switch (event)
        {
            case FileObserver.CREATE:
                addObserver(newPath);
                break;
            case FileObserver.DELETE:
                deleteObserver(newPath);
                break;
            case FileObserver.MOVED_FROM:
                deleteObserver(newPath);
                break;
            case FileObserver.MOVED_TO:
                addObserver(newPath);
                break;
            default:
                break;
        }
    }
    
    private String evt2str(int event)
    {
        String str = "";
        
        switch (event)
        {
            case FileObserver.ACCESS:
                str = "ACCESS";
                break;
            case FileObserver.ALL_EVENTS:
                str = "ALL_EVENTS";
                break;
            case FileObserver.ATTRIB:
                str = "ATTRIB";
                break;
            case FileObserver.CLOSE_NOWRITE:
                str = "CLOSE_NOWRITE";
                break;
            case FileObserver.CLOSE_WRITE:
                str = "CLOSE_WRITE";
                break;
            case FileObserver.CREATE:
                str = "CREATE";
                break;
            case FileObserver.DELETE:
                str = "DELETE";
                break;
            case FileObserver.DELETE_SELF:
                str = "DELETE_SELF";
                break;
            case FileObserver.MODIFY:
                str = "MODIFY";
                break;
            case FileObserver.MOVE_SELF:
                str = "MOVE_SELF";
                break;
            case FileObserver.MOVED_FROM:
                str = "MOVED_FROM";
                break;
            case FileObserver.MOVED_TO:
                str = "MOVED_TO";
                break;
            case FileObserver.OPEN:
                str = "OPEN";
                break;
            default:
                str = Integer.toString(event);
        }
        return str;
    }
    
    class SingleFileObserver extends FileObserver
    {
        private String mPath;
        
        public SingleFileObserver(String path)
        {
            super(path);
            mPath = path;
        }
        
        public String getPath()
        {
            return mPath;
        }
        
        @Override
        public void onEvent(int event, String path)
        {
            event = event & 0x00ffffff;
            String newPath = mPath;
            if (path != null)
            {
                newPath = mPath + "/" + path;
            }
            SmartFileObserver.this.onEvent(event, newPath);
        }
    }
}