android SD卡文件监听

 

Java代码  

1. android 监听文件和目录的创建删除移动等事件 博客分类： Android  
2. AndroidOSLinuxAccessBlog.  
3. android.os下的FileObserver类是一个用于监听文件访问、创建、修改、删除、移动等操作的监听器，基于linux的inotify。 FileObserver 是个抽象类，必须继承它才能使用。每个FileObserver对象监听一个单独的文件或者文件夹，如果监视的是一个文件夹，那么文件夹下所有的文件和级联子目录的改变都会触发监听的事件。  
4.     所能监听的事件类型如下：  
5.     ACCESS，即文件被访问  
6.     MODIFY，文件被 修改  
7.     ATTRIB，文件属性被修改，如 chmod、chown、touch 等  
8.     CLOSE_WRITE，可写文件被 close  
9.     CLOSE_NOWRITE，不可写文件被 close  
10.     OPEN，文件被 open  
11.     MOVED_FROM，文件被移走,如 mv  
12.     MOVED_TO，文件被移来，如 mv、cp  
13.     CREATE，创建新文件  
14.     DELETE，文件被删除，如 rm  
15.     DELETE_SELF，自删除，即一个可执行文件在执行时删除自己  
16.     MOVE_SELF，自移动，即一个可执行文件在执行时移动自己  
17.     CLOSE，文件被关闭，等同于(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)  
18.     ALL_EVENTS，包括上面的所有事件  
19.       这些都是FileObserver的静态共有属性。  
20.       下面举个例子说明一下其用法。  
21.       比如，我要监听sd卡的目录创建事件，新建一个类SDCardListener继承FileObserver：  
22.   
23. Java代码    
24. 1.import android.os.FileObserver;     
25. 2.import android.util.Log;      
26. 3.    
27. 4./**   
28. 5. * sd卡上的目录创建监听器   
29. 6. * @author chroya   
30. 7. *   
31. 8. */    
32. 9.public class SDCardListener extends FileObserver {      
33. 10.    
34. 11.    public SDCardListener(String path) {      
35. 12.        /*   
36. 13.         * 这种构造方法是默认监听所有事件的,如果使用super(String,int)这种构造方法，   
37. 14.         * 则int参数是要监听的事件类型.   
38. 15.         */    
39. 16.        super(path);      
40. 17.    }     
41. 18.    
42. 19.    @Override     
43. 20.    public void onEvent(int event, String path) {             
44. 21.        switch(event) {      
45. 22.        case FileObserver.ALL_EVENTS:      
46. 23.            Log.d("all", "path:"+ path);      
47. 24.            break;      
48. 25.        case FileObserver.CREATE:      
49. 26.            Log.d("Create", "path:"+ path);      
50. 27.            break;      
51. 28.        }     
52. 29.    }     
53. 30.}    
54. Java代码    
55. 1.import android.os.FileObserver;     
56. 2.import android.util.Log;     
57. 3.    
58. 4./**   
59. 5. * sd卡上的目录创建监听器   
60. 6. * @author chroya   
61. 7. *   
62. 8. */    
63. 9.public class SDCardListener extends FileObserver {     
64. 10.    
65. 11.    public SDCardListener(String path) {     
66. 12.        /*   
67. 13.         * 这种构造方法是默认监听所有事件的,如果使用super(String,int)这种构造方法，   
68. 14.         * 则int参数是要监听的事件类型.   
69. 15.         */    
70. 16.        super(path);     
71. 17.    }     
72. 18.    
73. 19.    @Override    
74. 20.    public void onEvent(int event, String path) {            
75. 21.        switch(event) {     
76. 22.        case FileObserver.ALL_EVENTS:     
77. 23.            Log.d("all", "path:"+ path);     
78. 24.            break;     
79. 25.        case FileObserver.CREATE:     
80. 26.            Log.d("Create", "path:"+ path);     
81. 27.            break;     
82. 28.        }     
83. 29.    }     
84. 30.}    
85. import android.os.FileObserver;  
86. import android.util.Log;  
87.   
88. /** 
89.  * sd卡上的目录创建监听器 
90.  * @author chroya 
91.  * 
92.  */  
93. public class SDCardListener extends FileObserver {  
94.   
95.     public SDCardListener(String path) {  
96.         /* 
97.          * 这种构造方法是默认监听所有事件的,如果使用super(String,int)这种构造方法， 
98.          * 则int参数是要监听的事件类型. 
99.          */  
100.         super(path);  
101.     }  
102.   
103.     @Override  
104.     public void onEvent(int event, String path) {         
105.         switch(event) {  
106.         case FileObserver.ALL_EVENTS:  
107.             Log.d("all", "path:"+ path);  
108.             break;  
109.         case FileObserver.CREATE:  
110.             Log.d("Create", "path:"+ path);  
111.             break;  
112.         }  
113.     }  
114. }       onEvent是回调，系统监听到事件后会触发此事件，参数event就是上面所说的事件类型，根据类型，我们可以做相应的处理，参数path就是触发事件的目录。   
115.   
116.       然后使用它：   
117.   
118. Java代码    
119. 1.SDCardListener listener = new SDCardListener("/sdcard");     
120. 2.//开始监听      
121. 3.listener.startWatching();     
122. 4./*   
123. 5.* 在这里做一些操作，比如创建目录什么的   
124. 6.*/    
125. 7.//最后停止监听      
126. 8.listener.stopWatching();    
127. Java代码    
128. 1.SDCardListener listener = new SDCardListener("/sdcard");     
129. 2.//开始监听     
130. 3.listener.startWatching();     
131. 4./*   
132. 5.* 在这里做一些操作，比如创建目录什么的   
133. 6.*/    
134. 7.//最后停止监听     
135. 8.listener.stopWatching();    
136. SDCardListener listener = new SDCardListener("/sdcard");  
137. //开始监听  
138. listener.startWatching();  
139. /* 
140. * 在这里做一些操作，比如创建目录什么的 
141. */  
142. //最后停止监听  
143. listener.stopWatching();   
144.   
145.       如果要在onEvent中做较多操作，最好用线程去做 ，以免因为阻塞接收不到后面的事件。  
146.   
147.       最后补充一点，比较重要 ：  
148.       FileObserver对象必须保持一个引用，确保不被垃圾收集器回收掉，否则就不会触发事件了。