Java FileObserver.MODIFY屬性代碼示例

PFileObserver(AppRunner appRunner, String path) {
    fileObserver = new FileObserver(appRunner.getProject().getFullPathForFile(path), FileObserver.CREATE | FileObserver.MODIFY | FileObserver.DELETE) {

        @Override
        public void onEvent(int event, String file) {
            ReturnObject ret = new ReturnObject();
            if ((FileObserver.CREATE & event) != 0) {
                ret.put("action", "created");
            } else if ((FileObserver.DELETE & event) != 0) {
                ret.put("action", "deleted");
            } else if ((FileObserver.MODIFY & event) != 0) {
                ret.put("action", "modified");
            }
            ret.put("file", file);
            if (callback != null) callback.event(ret);
        }

    };
    fileObserver.startWatching();
    getAppRunner().whatIsRunning.add(this);
}
 

@Override
public synchronized void onEvent(int event, String path) {
    if (path.equals(tabuPath)) {
        return;
    }

    long delay = 0;
    switch (event) {
        case FileObserver.MODIFY:
            delay = Math.max(0,
                    lastUpdateTime + MODIFICATION_INTERVAL - SystemClock.elapsedRealtime());
            modified.add(path);
            break;
        case FileObserver.CREATE:
        case FileObserver.MOVED_TO:
            added.add(path);
            break;
        case FileObserver.DELETE:
        case FileObserver.MOVED_FROM:
            deleted.add(path);
            break;
    }

    schedule(delay);
}
 

/**
 * This method is invoked when a registered event occur.
 *
 * @param event The type of event which happened
 * @param path  The path, relative to the main monitored file or directory,
 *              of the file or directory which triggered the event
 */
@Override
public void onEvent(int event, String path) {
	switch (event & FileObserver.ALL_EVENTS) {
		case FileObserver.CREATE:
			checkAutoRenameTask(path);
			break;
		case FileObserver.DELETE:
		case FileObserver.DELETE_SELF:
		case FileObserver.MODIFY:
		case FileObserver.MOVED_FROM:
		case FileObserver.MOVED_TO:
		case FileObserver.MOVE_SELF:
			checkForFolder(path);
			break;
	}
}
 

@Override
public void onEvent(int event, String path) {
	if (DebugLog.DEBUG) Log.d(TAG, "FileAccessService.AccessObserver.onEvent - access triggered");
	switch (event) {
		case FileObserver.ACCESS:
			values[READS] = Long.valueOf(values[READS].longValue() + 1);
			break;
		case FileObserver.MODIFY:
			values[WRITES] = Long.valueOf(values[WRITES].longValue() + 1);
			break;
		case FileObserver.CREATE:
			values[CREATES] = Long.valueOf(values[CREATES].longValue() + 1);
			break;
		case FileObserver.DELETE:
			values[DELETES] = Long.valueOf(values[DELETES].longValue() + 1);
			break;
		default:
			return;
	}
	updateMetric = new UpdateMetric();	// is this needed (nothing static)?
	metricHandler.post(updateMetric);
}
 

@Override
protected void performUpdates() {
	long nextUpdate = updateValueNodes();
	if (nextUpdate < 0) {
		if (accessObserver != null) {
			accessObserver.stopWatching();
			accessObserver = null;
		}
	}
	else {
		if (accessObserver == null) {
			accessObserver = new AccessObserver(Environment.getExternalStorageDirectory().getPath(), 
					FileObserver.ACCESS | FileObserver.MODIFY | FileObserver.CREATE | FileObserver.DELETE);
			accessObserver.startWatching();
		}
	}
	updateObservable();
}
 

/**
 * Receives and processes events about updates of the monitor folder and its children files.
 * 
 * @param event     Kind of event occurred.
 * @param path      Relative path of the file referred by the event.
 */
@Override
public void onEvent(int event, String path) {
    Log_OC.d(TAG, "Got event " + event + " on FOLDER " + mPath + " about "
            + ((path != null) ? path : ""));
    
    boolean shouldSynchronize = false;
    synchronized(mObservedChildren) {
        if (path != null && path.length() > 0 && mObservedChildren.containsKey(path)) {
            
            if (    ((event & FileObserver.MODIFY) != 0) ||
                    ((event & FileObserver.ATTRIB) != 0) ||
                    ((event & FileObserver.MOVED_TO) != 0) ) {
                
                if (!mObservedChildren.get(path)) {
                    mObservedChildren.put(path, Boolean.valueOf(true));
                }
            }
            
            if ((event & FileObserver.CLOSE_WRITE) != 0 && mObservedChildren.get(path)) {
                mObservedChildren.put(path, Boolean.valueOf(false));
                shouldSynchronize = true;
            }
        }
    }
    if (shouldSynchronize) {
        startSyncOperation(path);
    }
    
    if ((event & IN_IGNORE) != 0 &&
            (path == null || path.length() == 0)) {
        Log_OC.d(TAG, "Stopping the observance on " + mPath);
    }
    
}
 

public static String toString(final int event) {
    switch (event) {
        case FileObserver.ACCESS:
            return "ACCESS";
        case FileObserver.MODIFY:
            return "MODIFY";
        case FileObserver.ATTRIB:
            return "ATTRIB";
        case FileObserver.CLOSE_WRITE:
            return "CLOSE_WRITE";
        case FileObserver.CLOSE_NOWRITE:
            return "CLOSE_NOWRITE";
        case FileObserver.OPEN:
            return "OPEN";
        case FileObserver.MOVED_FROM:
            return "MOVED_FROM";
        case FileObserver.MOVED_TO:
            return "MOVED_TO";
        case FileObserver.CREATE:
            return "CREATE";
        case FileObserver.DELETE:
            return "DELETE";
        case FileObserver.DELETE_SELF:
            return "DELETE_SELF";
        case FileObserver.MOVE_SELF:
            return "MOVE_SELF";
        default:
            return "0x" + Integer.toHexString(event);
    }
}
 

@Override
public void onEvent(int event, String path) {
	if(event == FileObserver.CREATE || event == FileObserver.MODIFY) {
		final File createdFile = new File(directoryPath, path);
		addContractFromFile(createdFile);
	}
}
 

public FileLogReader(Context context, Handler handler, File file,
		int spreadLimit) throws IOException, FileNotFoundException {
	mReader = new ScrollingFileReader(file, spreadLimit);
	mContext = context;
	mHandler = handler;
	mObserver = new MyFileObserver(file.getAbsolutePath(), FileObserver.MODIFY);
}
 

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    try{
        //Make this service a foreground service (take directly from SDK docs)
        Notification notification = new Notification(R.drawable.ic_launcher, getText(R.string.notification_short), System.currentTimeMillis());
        notification.flags|=Notification.FLAG_NO_CLEAR;
        Intent notificationIntent = new Intent(this, FileMonitorActivity.class);
        notificationIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP|Intent.FLAG_ACTIVITY_SINGLE_TOP);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
        notification.setLatestEventInfo(this, getText(R.string.notification_short),getText(R.string.notification_long), pendingIntent);
        startForeground(mNotifyId, notification);

        //Instantiate the log & the observer tree
        mLog = new ArrayList<String[]>();
        mTreeNodes = new ArrayList<FileObserverNode>();

        //Pluck the data from the intent
        Bundle b = intent.getExtras();
        mSaveExt = b != null ? b.getBoolean(FileMonitorActivity.mExtraExtern) : false;
        mWatchDir = b != null ? b.getString(FileMonitorActivity.mExtraWatch) : "/";

        //Attach & activate monitors
        int observerFlags = FileObserver.OPEN | FileObserver.MODIFY; //These flags define what activities we are looking for
        attachNode(mWatchDir, observerFlags, mLog);
        startWatchingTree();
    }catch(Exception e){
        Toast.makeText(this, getText(R.string.toast_service_error_starting) + e.getMessage(), Toast.LENGTH_SHORT).show();
    }

    Toast.makeText(this, getText(R.string.toast_service_started) + String.valueOf(mTreeNodes.size()), Toast.LENGTH_SHORT).show();
    return super.onStartCommand(intent, flags, startId);
}
 

@Override
public void onEvent(int event, final String path) {
	if (path == null) {
		return;
	}
	
	switch (event & FileObserver.ALL_EVENTS) {
	case FileObserver.CLOSE_WRITE:
		// Download complete, or paused when wifi is disconnected. Possibly reported more than once in a row.
		// Useful for noticing when a download has been paused. For completions, register a receiver for 
		// DownloadManager.ACTION_DOWNLOAD_COMPLETE.
		break;
	case FileObserver.OPEN:
		// Called for both read and write modes.
		// Useful for noticing a download has been started or resumed.
		break;
	case FileObserver.DELETE:
	case FileObserver.MOVED_FROM:
		// This video is lost never to return. Remove it.
		handler.post(new Runnable() {
			@Override
			public void run() {
				DatabaseHelper helper = dataService.getHelper();
				helper.removeDownloadFromDownloadManager(helper.getVideoForFilename(path));
			}
		});
		break;
	case FileObserver.MODIFY:
		// Called very frequently while a download is ongoing (~1 per ms).
		// This could be used to trigger a progress update, but that should probably be done less often than this.
		shouldPoll = true;
		break;
	}
}
 

@Override
public void onEvent(final int event, final String path) {
    Intent localIntent = new Intent(INTENT_EBOOK_MODIFIED);
    localIntent.putExtra(INTENT_EBOOK_MODIFIED_PATH, path);
    switch (event) {
        case FileObserver.ACCESS:
            BookLibApplication.d(LOG_TAG + "onEvent() ACCESS: " + path);
            break;
        case FileObserver.ATTRIB:
            BookLibApplication.d(LOG_TAG + "onEvent() ATTRIB: " + path);
            break;
        case FileObserver.CLOSE_NOWRITE:
            BookLibApplication.d(LOG_TAG + "onEvent() CLOSE_NOWRITE: " + path);
            break;
        case FileObserver.CLOSE_WRITE:
            BookLibApplication.d(LOG_TAG + "onEvent() CLOSE_WRITE: " + path);
            break;
        case FileObserver.CREATE:
            BookLibApplication.d(LOG_TAG + "onEvent() CREATE: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.DELETE:
            BookLibApplication.d(LOG_TAG + "onEvent() DELETE: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.DELETE_SELF:
            BookLibApplication.d(LOG_TAG + "onEvent() DELETE_SELF: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.MODIFY:
            BookLibApplication.d(LOG_TAG + "onEvent() MODIFY: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.MOVE_SELF:
            BookLibApplication.d(LOG_TAG + "onEvent() MOVE_SELF: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.MOVED_FROM:
            BookLibApplication.d(LOG_TAG + "onEvent() MOVED_FROM: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.MOVED_TO:
            BookLibApplication.d(LOG_TAG + "onEvent() MOVED_TO: " + path);
            BookLibApplication.getInstance().sendBroadcast(localIntent);
            break;
        case FileObserver.OPEN:
            BookLibApplication.d(LOG_TAG + "onEvent() OPEN: " + path);
            break;
        default:
            //BookLibApplication.d(LOG_TAG + "onEvent() DEFAULT(" + event + "): " + path);
            break;
    }
}
 

public RecordsObserver(String path) {
    super(path, FileObserver.MODIFY | FileObserver.CREATE | FileObserver.MOVED_TO |
            FileObserver.DELETE | FileObserver.MOVED_FROM);
    lastUpdateTime = SystemClock.elapsedRealtime() - MODIFICATION_INTERVAL;
}
 

private void onEvent(int i, String s) {
    if (i != FileObserver.MODIFY) {
        return;
    }
    write();
}
 

@Override
public void onEvent(int event, String path) {
    switch (event) {
        case FileObserver.ACCESS:
            Log.i(TAG, "ACCESS");
            break;
        case FileObserver.ATTRIB:
            Log.i(TAG, "ATTRIB");
            break;
        case FileObserver.CLOSE_NOWRITE:
            Log.i(TAG, "CLOSE_NOWRITE");
            break;
        case FileObserver.CLOSE_WRITE:
            Log.i(TAG, "CLOSE_WRITE");
            break;
        case FileObserver.CREATE:
            Log.i(TAG, "CREATE");
            break;
        case FileObserver.DELETE:
            Log.i(TAG, "DELETE");
            break;
        case FileObserver.DELETE_SELF:
            Log.i(TAG, "DELETE_SELF");
            break;
        case FileObserver.MODIFY:
            Log.i(TAG, "MODIFY");
            break;
        case FileObserver.MOVE_SELF:
            Log.i(TAG, "MOVE_SELF");
            break;
        case FileObserver.MOVED_FROM:
            Log.i(TAG, "MOVED_FROM");
            break;
        case FileObserver.MOVED_TO:
            Log.i(TAG, "MOVED_TO");
            break;
        case FileObserver.OPEN:
            Log.i(TAG, "OPEN");
            break;
        case FileObserver.ALL_EVENTS:
            Log.i(TAG, "ALL_EVENTS");
            break;
        default:
            Log.i(TAG, "default, event=" + event + ", path=" + path);
            break;
    }

}