Java FileObserver.CLOSE_WRITE属性代码示例

private void startWatching() {
    final String pathToWatch = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM).getAbsolutePath();

    observer = new RecursiveFileObserver(pathToWatch, FileObserver.CLOSE_WRITE| FileObserver.MOVED_TO) { // set up a file observer to watch this directory on sd card
        @Override
        public void onEvent(int event, final String mediaPath) {
            if (mediaPath != null && (!mediaPath.equals(".probe"))) { // check that it's not equal to .probe because thats created every time camera is launched

                new Handler(Looper.getMainLooper()).post(new Runnable() {
                    @Override
                    public void run() {

                        if (mediaPath.endsWith(".mp4"))
                            handleNewVideo(mediaPath);
                    }
                });
            }
        }
    };
    observer.startWatching();


}
 

@Override
public void onEvent(int event, String path) {
    // this will automatically update the directory when an action like this
    // will be performed
    switch (event & FileObserver.ALL_EVENTS) {
        case FileObserver.CREATE:
        case FileObserver.CLOSE_WRITE:
        case FileObserver.MOVE_SELF:
        case FileObserver.MOVED_TO:
        case FileObserver.MOVED_FROM:
        case FileObserver.ATTRIB:
        case FileObserver.DELETE:
        case FileObserver.DELETE_SELF:
            sHandler.removeCallbacks(mLastRunnable);
            sHandler.post(mLastRunnable =
                    new NavigateRunnable((MyBrowserActivity) getActivity(), path));
            break;
    }
}
 

@Override
public void onCreate() {
    super.onCreate();

    copyConfigFromAssets(GOOGLE_CONFIG_FILE);
    copyConfigFromAssets(AMAZON_CONFIG_FILE);
    copyConfigFromAssets(ONEPF_CONFIG_FILE);

    if (createDbFromConfig()) {
        _configObserver = new FileObserver(getConfigDir()) {
            @Override
            public void onEvent(int event, String file) {
                switch (event) {
                    case FileObserver.CLOSE_WRITE:
                        createDbFromConfig();
                        break;
                }
            }
        };
        _configObserver.startWatching();
    }
}
 

public LockPasswordUtils(Context context) {
	mSharedPreferences = context.getSharedPreferences(
			LOCK_PASSWORD_SALT_FILE, Context.MODE_PRIVATE);
	mEditor = mSharedPreferences.edit();
	if (sLockPasswordFilename == null) {
		String dataSystemDirectory = context.getCacheDir()
				.getAbsolutePath();
		sLockPasswordFilename = new File(dataSystemDirectory,
				LOCK_PASSWORD_FILE);
		sHaveNonZeroPasswordFile.set(sLockPasswordFilename.length() > 0);
		int fileObserverMask = FileObserver.CLOSE_WRITE
				| FileObserver.DELETE | FileObserver.MOVED_TO
				| FileObserver.CREATE;
		sPasswordObserver = new PasswordFileObserver(dataSystemDirectory,
				fileObserverMask);
		sPasswordObserver.startWatching();
	}
}
 

@Override
public void onEvent(int event, String path) {
	if(event == FileObserver.CLOSE_WRITE) {
		WakeLock.acquire(context);
		int blnTimeout = getBlnTimeout();
		if(blnTimeout > 0) {
			// recalculate timeout from seconds to miliseconds
			blnTimeout = blnTimeout * 1000;
			SysCommand sc = SysCommand.getInstance();
			int n = sc.readSysfs("/sys/class/misc/backlightnotification/notification_led");
			if(n > 0 && sc.getLastResult(0).equals("1")) { // BLN on
				Log.d(LOG_TAG, "set alarm to shutdown BLN in " + blnTimeout + " ms");
				// get alarm manager
				AlarmManager alarmManager = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
				
				// set alarm to turn off BLN
				PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 1, new Intent("mobi.cyann.deviltools.SHUTDOWN_BLN"), PendingIntent.FLAG_CANCEL_CURRENT);
				alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + blnTimeout, pendingIntent);
			}
		}
		WakeLock.release();
	}
}
 

@Override
public void onEvent(int event, String path) {
    // this will automatically update the directory when an action like this
    // will be performed
    switch (event & FileObserver.ALL_EVENTS) {
        case FileObserver.CREATE:
        case FileObserver.CLOSE_WRITE:
        case FileObserver.MOVE_SELF:
        case FileObserver.MOVED_TO:
        case FileObserver.MOVED_FROM:
        case FileObserver.ATTRIB:
        case FileObserver.DELETE:
        case FileObserver.DELETE_SELF:
            sHandler.removeCallbacks(mLastRunnable);
            sHandler.post(mLastRunnable =
                    new NavigateRunnable((AbstractBrowserActivity) getActivity(), path));
            break;
    }
}
 

private void registerFileObserver() {
    mFileObserver = new FileObserver(context.getDataDir() + "/shared_prefs",
            FileObserver.ATTRIB | FileObserver.CLOSE_WRITE) {
        @Override
        public void onEvent(int event, String path) {
            for (FileObserverListener l : mFileObserverListeners) {
                if ((event & FileObserver.ATTRIB) != 0)
                    l.onFileAttributesChanged(path);
                if ((event & FileObserver.CLOSE_WRITE) != 0)
                    l.onFileUpdated(path);
            }
        }
    };
    mFileObserver.startWatching();
}
 

/**
 * 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);
    }
    
}
 

private boolean startFileObserver() {
	if (mFileObserver == null) {
		mFileObserver = new TraceFileObserver(mObserverPath, FileObserver.CLOSE_WRITE);
	}
	mFileObserver.setHandler(mTHandler);
	try {
		mFileObserver.startWatching();
		return true;
	} catch(Exception e) {
		return false;
	}
}
 

@Override
public void onEvent(int event, String path) {
    Debug.Log(tag, String.format("onEvent(%d, %s)", event, path));

    if (path != null) {
        if ((FileObserver.CREATE & event)!=0) {
            listener.onFileCreated(path);
        }

        if ((FileObserver.CLOSE_WRITE & event)!=0) {
            listener.onFileClosed(path);
        }
    }

}
 

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);
    }
}
 

public LockPatternUtils(Context context) {
	if (sLockPatternFilename == null) {
		String dataSystemDirectory = context.getFilesDir()
				.getAbsolutePath();
		sLockPatternFilename = new File(dataSystemDirectory
				, LOCK_PATTERN_FILE);
		sHaveNonZeroPatternFile.set(sLockPatternFilename.length() > 0);
		int fileObserverMask = FileObserver.CLOSE_WRITE
				| FileObserver.DELETE | FileObserver.MOVED_TO
				| FileObserver.CREATE;
		sPasswordObserver = new LockPatternFileObserver(
				dataSystemDirectory, fileObserverMask);
		sPasswordObserver.startWatching();
	}
}
 

@Override
public void onEvent(int event, String path) {
    Log.i(TAG, "Event:" + event + "\t" + path);

    if (path == null || event != FileObserver.CLOSE_WRITE)
        Log.i(TAG, "Not important");
    else if (mLastTakenPath != null && path.equalsIgnoreCase(mLastTakenPath))
        Log.i(TAG, "This event has been observed before.");
    else {
        mLastTakenPath = path;
        File file = new File(PATH + path);

        if (deleteScreenshot) {
            if (file != null)
                file.delete();

            /*
            * A null uri is returned to listener once screenshot
            * has been deleted.
            * */
            if (mListener != null)
                mListener.onScreenshotTaken(null);

        } else {

            if (mListener != null)
                mListener.onScreenshotTaken(Uri.fromFile(file));
        }
    }
}
 

public LockPatternUtils(Context context) {
	if (sLockPatternFilename == null) {
		String dataSystemDirectory = context.getFilesDir()
				.getAbsolutePath();
		sLockPatternFilename = new File(dataSystemDirectory,
				LOCK_PATTERN_FILE);
		sHaveNonZeroPatternFile.set(sLockPatternFilename.length() > 0);
		int fileObserverMask = FileObserver.CLOSE_WRITE
				| FileObserver.DELETE | FileObserver.MOVED_TO
				| FileObserver.CREATE;
		sPasswordObserver = new LockPatternFileObserver(
				dataSystemDirectory, fileObserverMask);
		sPasswordObserver.startWatching();
	}
}
 

@Override
public void onEvent( int event, String file ) {
	final int mask = FileObserver.CLOSE_NOWRITE | FileObserver.CLOSE_WRITE;
	if( ( event & mask ) != 0 ) {
		sendBroadcast( Action.SYSTEM_NET_CHANGE.intent() );
	}
}