1. Overview:
The FileObserver class under the package is a listener for listening for file access, creation, modification, deletion, movement and other operations. It is based on INotify of Linux. FileObserver is an abstract class and must be inherited to use it. Each FileObserver object listens for a separate file or folder. If it is monitoring a folder, then all changes to files and cascaded subdirectories in the folder will trigger the listening event.
The FileObserver class under the FileObserver introduction package is a listener for listening to file access, creation, modification, deletion, and movement operations. It is based on INotify of Linux.
FileObserver is an abstract class and must be inherited to use it. Each FileObserver object listens for a separate file or folder. If it is monitoring a folder, then all changes to files and cascaded subdirectories in the folder will trigger the listening event.
2. Listening event type:
ACCESS, that is, the file is accessed
MODIFY, the file is modified
ATTRIB, file attributes are modified, such as chmod, chown, touch, etc.
CLOSE_WRITE, the writable file is closed
CLOSE_NOWRITE, the unwritable file is closed
OPEN, the file is opened
MOVED_FROM, the file is removed, such as mv
MOVED_TO, the file is moved, such as mv, cp
CREATE, create a new file
DELETE, the file is deleted, such as rm
DELETE_SELF, self-delete, that is, an executable file deletes itself when executing
MOVE_SELF, self-move, that is, an executable file moves itself when executing
CLOSE, the file is closed, equivalent to (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
ALL_EVENTS, including all events above
3. Examples
import ;
import ;
import ;
import ;
import ;
import ;
public class AndroidFileListenerActivity extends Activity {
private FileObserver mFileObserver;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
(savedInstanceState);
setContentView(.activity_main);
if(null == mFileObserver) {
mFileObserver = new SDCardFileObserver(().getPath());
(); //Start monitoring }
}
public void onDestory() {
if(null != mFileObserver) (); //Stop monitoring }
static class SDCardFileObserver extends FileObserver {
//mask: Specify the event type to listen to, the default is FileObserver.ALL_EVENTS public SDCardFileObserver(String path, int mask) {
super(path, mask);
}
public SDCardFileObserver(String path) {
super(path);
}
@Override
public void onEvent(int event, String path) {
final int action = event & FileObserver.ALL_EVENTS;
switch (action) {
case :
("event: The file or directory is accessed, path: " + path);
break;
case :
("event: The file or directory is deleted, path: " + path);
break;
case :
("event: The file or directory is opened, path: " + path);
break;
case :
("event: The file or directory is modified, path: " + path);
break;
case :
("event: The file or directory is created, path: " + path);
break;
}
}
}
}
onEvent is a callback. This event will be triggered after the system listens to an event. The parameter event is the event type mentioned above. The parameter path is the directory that triggers the event. The authentication is only for this layer directory, and other levels are invalid.
Most of us need to listen to the operations related to all file objects in the path directory, so what should we do? One of the solutions to the problem is to re-implement the FileObserver class.
The following is the rewrite implementation process of FileObserver class
import ;
import ;
import ;
import ;
import ;
import ;
@SuppressWarnings(value = { "rawtypes", "unchecked" })
public class MultiFileObserver extends FileObserver {
/** Only modification events */
public static int CHANGES_ONLY = CREATE | MODIFY |DELETE | CLOSE_WRITE
| DELETE_SELF | MOVE_SELF | MOVED_FROM | MOVED_TO;
private List<SingleFileObserver> mObservers;
private String mPath;
private int mMask;
public MuityFileObserver(String path) {
this(path, ALL_EVENTS);
}
public MuityFileObserver(String path, int mask) {
super(path, mask);
mPath = path;
mMask = mask;
}
@Override
public void startWatching() {
if (mObservers != null)
return;
mObservers = new ArrayList<SingleFileObserver>();
Stack<String> stack = new Stack<String>();
(mPath);
while (!()) {
String parent = ();
(new SingleFileObserver(parent, mMask));
File path = new File(parent);
File[] files = ();
if (null == files)
continue;
for (File f : files) {
if (() && !().equals(".")
&& !().equals("..")) {
(());
}
}
}
for (int i = 0; i < (); i++) {
SingleFileObserver sfo = (i);
();
}
};
@Override
public void stopWatching() {
if (mObservers == null)
return;
for (int i = 0; i < (); i++) {
SingleFileObserver sfo = (i);
();
}
();
mObservers = null;
};
@Override
public void onEvent(int event, String path) {
switch (event) {
case :
("RecursiveFileObserver", "ACCESS: " + path);
break;
case :
("RecursiveFileObserver", "ATTRIB: " + path);
break;
case FileObserver.CLOSE_NOWRITE:
("RecursiveFileObserver", "CLOSE_NOWRITE: " + path);
break;
case FileObserver.CLOSE_WRITE:
("RecursiveFileObserver", "CLOSE_WRITE: " + path);
break;
case :
("RecursiveFileObserver", "CREATE: " + path);
break;
case :
("RecursiveFileObserver", "DELETE: " + path);
break;
case FileObserver.DELETE_SELF:
("RecursiveFileObserver", "DELETE_SELF: " + path);
break;
case :
("RecursiveFileObserver", "MODIFY: " + path);
break;
case FileObserver.MOVE_SELF:
("RecursiveFileObserver", "MOVE_SELF: " + path);
break;
case FileObserver.MOVED_FROM:
("RecursiveFileObserver", "MOVED_FROM: " + path);
break;
case FileObserver.MOVED_TO:
("RecursiveFileObserver", "MOVED_TO: " + path);
break;
case :
("RecursiveFileObserver", "OPEN: " + path);
break;
default:
("RecursiveFileObserver", "DEFAULT(" + event + " : " + path);
break;
}
}
/**
* Monitor single directory and dispatch all events to its parent, with full
* path.
*/
class SingleFileObserver extends FileObserver {
String mPath;
public SingleFileObserver(String path) {
this(path, ALL_EVENTS);
mPath = path;
}
public SingleFileObserver(String path, int mask) {
super(path, mask);
mPath = path;
}
@Override
public void onEvent(int event, String path) {
String newPath = mPath + "/" + path;
MultiFileObserver .(event, newPath);
}
}
}
Summarize
This is the end of this article about how Android monitors folder content changes. For more related contents of Android monitoring folders, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!