来看看文件监听的FileObserver的底层原理inotify实战demo

文件夹监听器(监听文件夹下所有文件及文件夹) 先介绍一下FileObserver     FileObserver监听事件的类型:     1.CREATE:有新文件创建时触发     2.OPEN:有文件被打开时触发     3.ACCESS:有文件内容被读取时触发,如通过流读取文件内容等     4.MODIFY:文件内容被修改时触发,如粘贴文件等     5.ATTRIB:文件属性被修改,如 chmod、chown、 阅读详情

android FileObserver实战使用案例

首先继承自定义一个DataFileObserver

    class  DataFileObserver extends FileObserver {


        public DataFileObserver(String path) {
            super(path,CLOSE_WRITE | MOVED_TO | DELETE | DELETE_SELF);
        }

        @Override
        public void onEvent(int event, @Nullable String path) {
        //一旦监测文件有啥变化都会调到这里
            Log.i("test","onEvent "+path + " event = " +event);
        }
    }


然后再进行启动观察

DataFileObserver mFileObserver = null;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (mFileObserver == null) {
            mFileObserver = new DataFileObserver("/data/local/tmp/aaa.txt");
            mFileObserver.startWatching();
        }
        //省略其他

上面使用FileObserver监听某个文件非常简单,只需要以下几步既可以:

1、自定义一个DataFileObserver继承FileObserver类,重写onEvent方法,一旦有文件相关变化时候就会回调这个方法

2、构造出自定义的DataFileObserver类,注意参数就是需要监测的文件或者目录

3、调用FileObserver的startWatching方法启动对文件监测

4、当然在不需要监测时候需要调用stopWatching

源码剖析FileObserver原理:

先看看官方注释:
frameworks/base/core/java/android/os/FileObserver.java

android.os public abstract class FileObserver
extends Object
Monitors files (using inotify ) to fire an event after files are accessed or changed by any process on the device (including this one). FileObserver is an abstract class; subclasses must implement the event handler onEvent(int, String).
Each FileObserver instance can monitor multiple files or directories. If a directory is monitored, events will be triggered for all files and subdirectories inside the monitored directory.
An event mask is used to specify which changes or actions to report. Event type constants are used to describe the possible changes in the event mask as well as what actually happened in event callbacks.
Warning: If a FileObserver is garbage collected, it will stop sending events. To ensure you keep receiving events, you must keep a reference to the FileObserver instance from some other live object.

上面信息可以看出,FileObserver其实底层原理是使用的inotify来进行文件监听,监听的文件变化类型有以下:

/** Event type: Data was read from a file */
    public static final int ACCESS = 0x00000001;
    /** Event type: Data was written to a file */
    public static final int MODIFY = 0x00000002;
    /** Event type: Metadata (permissions, owner, timestamp) was changed explicitly */
    public static final int ATTRIB = 0x00000004;
    /** Event type: Someone had a file or directory open for writing, and closed it */
    public static final int CLOSE_WRITE = 0x00000008;
    /** Event type: Someone had a file or directory open read-only, and closed it */
    public static final int CLOSE_NOWRITE = 0x00000010;
    /** Event type: A file or directory was opened */
    public static final int OPEN = 0x00000020;
    /** Event type: A file or subdirectory was moved from the monitored directory */
    public static final int MOVED_FROM = 0x00000040;
    /** Event type: A file or subdirectory was moved to the monitored directory */
    public static final int MOVED_TO = 0x00000080;
    /** Event type: A new file or subdirectory was created under the monitored directory */
    public static final int CREATE = 0x00000100;
    /** Event type: A file was deleted from the monitored directory */
    public static final int DELETE = 0x00000200;
    /** Event type: The monitored file or directory was deleted; monitoring effectively stops */
    public static final int DELETE_SELF = 0x00000400;
    /** Event type: The monitored file or directory was moved; monitoring continues */
    public static final int MOVE_SELF = 0x00000800;

    /** Event mask: All valid event types, combined */
    @NotifyEventType
    public static final int ALL_EVENTS = ACCESS | MODIFY | ATTRIB | CLOSE_WRITE
            | CLOSE_NOWRITE | OPEN | MOVED_FROM | MOVED_TO | DELETE | CREATE
            | DELETE_SELF | MOVE_SELF;

初始化

在我们构造对应的FileObserver最后会调用到下面

   /**
     * Equivalent to FileObserver(path, FileObserver.ALL_EVENTS).
     *
     * @deprecated use {@link #FileObserver(File)} instead.
     */
    @Deprecated
    public FileObserver(String path) {
        this(new File(path));
    }
  /**
     * Version of {@link #FileObserver(File, int)} that allows callers to monitor
     * multiple files or directories.
     *
     * @param files The files or directories to monitor
     * @param mask The event or events (added together) to watch for
     */
    public FileObserver(@NonNull List<File> files, @NotifyEventType int mask) {
        mFiles = files;
        mMask = mask;
    }

再看看调用startWatching方法

/**
 * Start watching for events.  The monitored file or directory must exist at
 * this time, or else no events will be reported (even if it appears later).
 * If monitoring is already started, this call has no effect.
 */
public void startWatching() {
    if (mDescriptors == null) {
        mDescriptors = s_observerThread.startWatching(mFiles, mMask, this);
    }
}

这里可以看到核心其实是调用了s_observerThread的,那么s_observerThread是哪里来的呢?

在FileObserver类中封装有一个static的线程类,并且在静态代码块中直接构造出来。

    private static ObserverThread s_observerThread;

    static {
        s_observerThread = new ObserverThread();
        s_observerThread.start();
    }

也就静态构造的ObserverThread,那么看看ObserverThread类实现

 private static class ObserverThread extends Thread {
        /** Temporarily retained; appears to be missing UnsupportedAppUsage annotation */
        private HashMap<Integer, WeakReference> m_observers = new HashMap<Integer, WeakReference>();
        private SparseArray<WeakReference> mRealObservers = new SparseArray<>();
        private int m_fd;

        public ObserverThread() {
            super("FileObserver");
            m_fd = init();//调用到了native的init方法获取fd
        }

        public void run() {
            observe(m_fd);//调用native的observe同时传递fd
        }

        public int[] startWatching(List<File> files,
                @NotifyEventType int mask, FileObserver observer) {
            final int count = files.size();
            final String[] paths = new String[count];
            for (int i = 0; i < count; ++i) {
                paths[i] = files.get(i).getAbsolutePath();
            }
            final int[] wfds = new int[count];
            Arrays.fill(wfds, -1);

            startWatching(m_fd, paths, mask, wfds);//最后也是调用到了native的startWatching

            final WeakReference<FileObserver> fileObserverWeakReference =
                    new WeakReference<>(observer);
            synchronized (mRealObservers) {
                for (int wfd : wfds) {
                    if (wfd >= 0) {
                        mRealObservers.put(wfd, fileObserverWeakReference);
                    }
                }
            }

            return wfds;
        }

        public void stopWatching(int[] descriptors) {
            stopWatching(m_fd, descriptors);
        }

        @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
        public void onEvent(int wfd, @NotifyEventType int mask, String path) {
            // look up our observer, fixing up the map if necessary...
            FileObserver observer = null;

            synchronized (mRealObservers) {
                WeakReference weak = mRealObservers.get(wfd);
                if (weak != null) {  // can happen with lots of events from a dead wfd
                    observer = (FileObserver) weak.get();
                    if (observer == null) {
                        mRealObservers.remove(wfd);
                    }
                }
            }

            // ...then call out to the observer without the sync lock held
            if (observer != null) {
                try {
                    observer.onEvent(mask, path);//这里就是回调到FileObserve的onEvent
                } catch (Throwable throwable) {
                    Log.wtf(LOG_TAG, "Unhandled exception in FileObserver " + observer, throwable);
                }
            }
        }
	//核心的native方法
        private native int init();
        private native void observe(int fd);
        private native void startWatching(int fd, String[] paths,
                @NotifyEventType int mask, int[] wfds);
        private native void stopWatching(int fd, int[] wfds);
    }

上面原理主要方法也有注释,这里可以看出ObserverThread主要还是一个线程类,主要核心业务方法都是调用到了native层面。
主要针对以下几个native方法:

private native int init();
private native void observe(int fd);
private native void startWatching(int fd, String[] paths,
        @NotifyEventType int mask, int[] wfds);
private native void stopWatching(int fd, int[] wfds);

下面看看native的代码:
init方法

static jint android_os_fileobserver_init(JNIEnv* env, jobject object)
{
#if defined(__linux__)
    return (jint)inotify_init1(IN_CLOEXEC);//可以看出调用实际上是inotify_init1
#else
    return -1;
#endif
}

observe

static void android_os_fileobserver_observe(JNIEnv* env, jobject object, jint fd)
{
#if defined(__linux__)

    char event_buf[512];
    struct inotify_event* event;

    while (1)
    {
    //读取inotify的对应fd的数据,在监测文件有变化时候就可以读取到
        int num_bytes = read(fd, event_buf, sizeof(event_buf));

        while (num_bytes >= (int)sizeof(*event))
        {
  //读取event数据后回调到java层
            env->CallVoidMethod(object, method_onEvent, event->wd, event->mask, path);

        }
    }

#endif
}


startWatching方法

static void android_os_fileobserver_startWatching(JNIEnv* env, jobject object, jint fd,
                                                       jobjectArray pathStrings, jint mask,
                                                       jintArray wfdArray)
{
						//这里核心就是调用了inotify_add_watch方法,监测path和指定对应mask
            wfds[i] = inotify_add_watch(fd, path.c_str(), mask);

}

stopWatching方法


static void android_os_fileobserver_stopWatching(JNIEnv* env, jobject object,
                                                 jint fd, jintArray wfdArray)
{
		//调用是inotify_rm_watch,移除监听
        inotify_rm_watch((int)fd, (uint32_t)wfds[i]);
}

上面可以看出FileObserver本质都是调用的linux相关inotify接口,下面针对linux的inotify监听文件变化采用一个demo实战案例方便大家立即。

linux层面的inotify实战案例:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/inotify.h>
#include <limits.h>
#include <unistd.h>


int main() {

  int inotifyFd, watchDescriptor;
    int length, i = 0;
    char event_buf[1024] __attribute__ ((aligned(8)));
 
    // 初始化 inotify
    inotifyFd = inotify_init();
    if (inotifyFd < 0) {
        perror("inotify_init");
        return 1;
    }
 
    // 添加监控,这里监控当前目录(".")的变化
    watchDescriptor = inotify_add_watch(inotifyFd, "/home/test/disk2/demos/inotify", 
    IN_ACCESS|IN_ATTRIB|IN_CLOSE_WRITE|IN_CLOSE_NOWRITE|IN_MODIFY | IN_CREATE |IN_MOVE_SELF|IN_MOVED_FROM|IN_MOVED_TO| IN_DELETE|IN_OPEN);
    if (watchDescriptor < 0) {
        perror("inotify_add_watch");
        close(inotifyFd);
        return 1;
    }
     struct inotify_event* event;

      
    // 循环读取事件
    while (i < 10) {  // 示例中只处理10个事件,实际应用中可以根据需要调整或使用循环
        i++;
        int event_pos = 0;
	 fflush(stdout);
        int num_bytes = read(inotifyFd, event_buf, sizeof(event_buf));
	 printf("read num_bytes = %d \n", num_bytes);
	 fflush(stdout);
        if (num_bytes < (int)sizeof(*event))
        {
            if (errno == EINTR)
                continue;
        }

        while (num_bytes >= (int)sizeof(*event))
        {
            int event_size;
            event = (struct inotify_event *)(event_buf + event_pos);
	    printf("event name = %s  mask %d \n", event->name,event->mask);
	    fflush(stdout);
            event_size = sizeof(*event) + event->len;
            num_bytes -= event_size;
            event_pos += event_size;
        }

        i = 0;  // 重置计数器以处理所有事件
    }
    // 移除监控
    inotify_rm_watch(inotifyFd, watchDescriptor);
    close(inotifyFd);
    return 0;
}

可以看得出linux的inotify使用也是一样的流程:
在这里插入图片描述

测试结果如下:

编译执行inotify程序

gcc inotify.cpp -o inotify;
./inotify

另一个终端在当前目录创建一个文件

test@test:~/disk2/demos/inotify$ touch 3.txt

再看看./inotify执行终端的打印

read num_bytes = 64 
event name = 3.txt  mask 256 
event name = 3.txt  mask 32 
read num_bytes = 64 
event name = 3.txt  mask 4 
event name = 3.txt  mask 8 


这些mask对应变化是啥,可以用上面java文件FileObserver的来匹配,也可以用通过查linux的函数手册来看看:
man inotify

inotify events
       The  inotify_add_watch(2)  mask  argument and the mask field of the inotify_event structure returned when read(2)ing an inotify file descriptor are both bit masks identifying inotify events.
       The following bits can be specified in mask when calling inotify_add_watch(2) and may be returned in the mask field returned by read(2):

           IN_ACCESS (+)
                  File was accessed (e.g., read(2), execve(2)).

           IN_ATTRIB (*)
                  Metadata changed—for example, permissions (e.g., chmod(2)), timestamps (e.g., utimensat(2)), extended attributes (setxattr(2)), link count (since Linux 2.6.25; e.g., for the  tar‐
                  get of link(2) and for unlink(2)), and user/group ID (e.g., chown(2)).

           IN_CLOSE_WRITE (+)
                  File opened for writing was closed.

           IN_CLOSE_NOWRITE (*)
                  File or directory not opened for writing was closed.

           IN_CREATE (+)
                  File/directory created in watched directory (e.g., open(2) O_CREAT, mkdir(2), link(2), symlink(2), bind(2) on a UNIX domain socket).

           IN_DELETE (+)
                  File/directory deleted from watched directory.

           IN_DELETE_SELF
                  Watched  file/directory was itself deleted.  (This event also occurs if an object is moved to another filesystem, since mv(1) in effect copies the file to the other filesystem and
                  then deletes it from the original filesystem.)  In addition, an IN_IGNORED event will subsequently be generated for the watch descriptor.

           IN_MODIFY (+)
                  File was modified (e.g., write(2), truncate(2)).

           IN_MOVE_SELF
                  Watched file/directory was itself moved.

           IN_MOVED_FROM (+)
                  Generated for the directory containing the old filename when a file is renamed.

更多framework实战开发,关注下面“千里马学框架”

android 7.1 FileObserver 使用demo以及apk签名为系统app的工具 立即下载

相关推荐

Android FileObserver检测文件变化demo

Android FileObserver 检测文件变化demo,Android FileObserver 检测文件其实也是基于linux的inotify实现的,是从linux内核2.6.13开始加进来的,不过FileObserver检测的文件还是有局限的,似乎只能检测到SD卡的文件,其他的系统文件没有权限。欢迎下载!

FileObserver 使用

FileObserver 是一个用来监听文件变化的抽象类,子类必须实现事件处理的方法 onEvent(int, String) 。由于最近做了两个项目都用上就查阅了官方文档,写下这篇文章记录一下。 每一个 FileObserver 实例用来监听一个文件或者文件夹,当文件夹被监听时,任意子文件或文件夹的访问或修改都会触发事件。注意:FileObserver 不能监听到二级子文件夹或文件的变化。 所有常量 (可监听的事件) Constant 描述 ACCESS 文件被读取 ATTRIB 权限 所有者 时间戳被

weixin_46297800的博客 2171

BEV感知技术全景解析:从纯视觉到多传感器融合的实战指南

本文全面解析了自动驾驶中的BEV感知技术,从纯视觉到多传感器融合的实战应用。文章深入探讨了BEV如何提供“上帝视角”,对比了IPM、Lift-Splat-Shoot及Transformer等核心实现范式,并详细阐述了多传感器融合(尤其是中融合)的工程实践与优势,为开发者提供了从理论到原型搭建的完整指南。

win55的博客 1141

FileObserver的使用、实现原理与优化

最近在开发过程中出现了下面的场景:主程序控制着数据文件的更新逻辑,但是文件的更新动作并没有及时通知插件数据文件更新了。在插件中为了兼顾性能,往往会对数据文件在内存中进行缓从而导致数据文件无法实时刷新的情况。为了解决这种情况需要找到一种高效、实时的数据文件刷新解决方案。 FileObserver介绍 inotify机制是从linux kernel 2.6.13开始引入,Android 1.5对应的linux内核已经是2.6.26了。因此完全可以在Android上利用inotify达到反调试的目的。而且An.

oaimgo的博客 3357

iTunes登录协议抓包实战:绕过反检测与TLS解密的完整方案

在软件逆向与网络协议分析中,抓包工具扮演着关键角色。代理型工具如Fiddler通过修改系统代理实现HTTPS解密,而驱动型工具如HTTPDebugger则注入进程钩取网络API,但这些实现机制往往会被具有反检测策略的客户端识别。以iTunes登录协议为例,其内置证书锁定、进程完整性与系统代理检测等防护,导致常规抓包方案失效。从工具原理出发,对比不同抓包方案的暴露面,重点介绍如何利用Fiddler通过中间人代理获取明文流量,以及使用Wireshark进行被动监听规避检测的进阶技巧,并总结常见问题排查经验,为分

weixin_28607671的博客 368

全志V3S开发板实战:从零构建嵌入式Linux系统

本文提供了一份针对全志V3S开发板(如LicheePi Zero)的零基础教程,详细指导如何从零开始构建嵌入式Linux系统。内容涵盖编译环境搭建、交叉工具链配置、U-Boot引导程序编译与烧录、Linux内核定制与编译,以及使用Buildroot构建根文件系统,最终实现系统成功启动,帮助开发者深入理解嵌入式系统构建全流程。

tensor9flow的博客 576

Android 中关于 FileObserver类监听文件状态的实践

Android 中关于 FileObserve r类监听文件状态的实践

小羊子的技术专栏 3493

CMakeTestCCompiler.cmake错误解决

CMakeTestCCompiler.cmake错误解决欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 最近编译项目的时候,遇到一个cmake的错误,具体错误信息如下: /path-to-pr

昨夜星辰的博客 2万+

Android FileObserver 的使用与简要原理

需要注意的是,FileObserver 在底层的实现使用了 Linux 的特定功能,因此只能在 Android 上使用,而不适用于其他操作系统或平台。

简单记录工作和学习 1493

Qt6.10 | Qt Bluetooth 蓝牙

本文介绍了QtBluetooth模块的功能和使用方法,包括蓝牙API概述、构建配置(CMake/qmake)、权限管理、平台支持(Linux/macOS特殊处理)、日志设置及许可信息。重点说明Linux平台的后端选择机制,以及macOS上的依赖限制。最后提及蓝牙聊天示例,展示RFCOMM协议通信的实现。全文提供了蓝牙开发的技术要点和注意事项。

Qt历险记,专注Qt技术,三年医疗设备研发经验,1年机器视觉研发经验,半年柔性传感研发经验。 405

YOLOv8改进 | 主干篇 | 利用MobileNetV1替换Backbone(轻量化网络结构)

本文给大家带来的改进机制是MobileNetV1,其是专为移动和嵌入式视觉应用设计的轻量化网络结构。这些模型基于简化的架构,并利用深度可分离卷积构建轻量级深度神经网络,其引入了两个简单的全局超参数,用于在延迟和准确性之间进行有效的权衡。实验表明,MobileNets在资源和准确性的权衡方面表现出色,并在多种应用(如对象检测、细粒度分类、面部属性识别和大规模地理定位)中展现了其有效性,这个模型非常适合轻量化的读者来使用。适用检测目标:轻量化网络结构适合轻量化的读者。

Snu77的博客 3968

监控android文件数量,Android--文件监控FileObserver

在Android系统中封装了一个FileObserver类,该类是基于Linux的Inotify机制实现的。FileObserver是一个抽象类,必须定义一个子类继承FileObserver,并且实现该类的onEvent抽象方法,当被监控的文件或目录发生变更事件时,将回调FileObserver的onEvent()方法来处理文件或目录的变更事件。事件类型FileObserver类到底定义了监控文件...

weixin_35006181的博客 407

STM32入门教程:智能储物柜控制

在这个例子中,我们将使用一个4x4的储物柜,共有16个储物格。我们了解了硬件准备、储物柜电路设计、STM32的基本配置、储物柜控制代码的编写以及测试和调试等方面的知识。根据我们的电路设计,我们需要将一些引脚配置为输出,并将其他引脚配置为输入。在本教程中,我们将使用STM32微控制器来实现一个基本的智能储物柜控制系统。在主函数中,我们将不断循环读取传感器数据,并根据数据的变化来控制储物柜的开关和显示相关信息。这个函数将读取人体感应传感器、温湿度传感器和光照传感器的数据,并将数据存储到相应的变量中。

m0_75244442的博客 663

android fileobserver 权限,Android FileObserver 实现原理(inotify)

0x0前言之前在分析某个Android平台加固壳子的时候就碰到过inotify,被用来监控/proc 文件系统,防止gdb调试器的附加,以达到反调试的目的。inotify机制是从linux kernel 2.6.13开始引入,Android 1.5对应的linux内核已经是2.6.26了。因此完全可以在Android上利用inotify达到反调试的目的。而且Android将inotify直接封装成...

weixin_34040270的博客 737

【教程4>第1章>第8节】ILA在线调试工具与MATLAB联合应用

Vivado的ILA(Integrated Logic Analyzer)核是一种可定制的集成逻辑分析仪内核,专门用于监控设计的内部信号。ILA内核包含了现代逻辑分析仪的许多高级功能,例如布尔触发方程和边沿转换触发等。此外,由于ILA内核与被监控的设计保持同步,因此应用于设计的所有设计时钟约束也会应用于ILA内核内部的组件。ILA核的主要应用是在硬件设计和验证阶段进行调试。通过监控关键信号,设计师可以了解硬件的实际行为,从而找出并修复设计中的错误。ILA核还可以用于分析设计的性能。

FPGA/MATLAB学习教程/源码/项目合作开发 802

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Android中的文件监听 FileObserver监听无效

笔者遇到一个因 GC 而引发的监听无效的问题。今天遇到个需求:需要监听某个文件的状态。 于是在网上找到答案,原来 Android 默认就提供了一个 android.os.FileObserver 的功能,可以监听文件系统中指定文件或文件夹的各种访问事件。 关于 FileObserver 的使用,笔者主要参考了这两篇博客: https://www.jianshu.com/p/a509ad4311c0 https://blog.youkuaiyun.com/Tony_YY/article/details/89688438

qq_44997843的博客 2028

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

FileObserver使用

ContentObserver可以监听不同程序间指定uri或者cursor内容的变化,如果两个无网络连接的设备通过OTG线相连,并且两设备可以通过U盘路径的方式相互访问存储,那么两设备的不同应用通信可以尝试通过FileObserver或者ContentObserver来进行,本文主要讲解FileObserver。 FileObserver是一个抽象类,可以创建FileObserver一个子类并且...

努力的八戒 1213

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Android 中监听文件变化的方式

在 Android 开发中,监听文件变化(如文件的创建、修改和删除)是一个常见的需求

特立独行的博客 2286

android+文件监控,Android文件监控FileObserver介绍

在前面的Linux文件系统Inotify机制中介绍了Linux对文件变更监控过程。Android系统在此基础上封装了一个FileObserver类来方便使用Inotify机制。FileObserver是一个抽象类,需要定义子类实现该类的onEvent抽象方法,当被监控的文件或者目录发生变更事件时,将回调FileObserver的onEvent()函数来处理文件或目录的变更事件。事件监控过程在F...

weixin_42131890的博客 708

android FileObserver的用法与避坑指南

昨天因为项目需要,需要做一个damo,用到了文件监听的功能,所以就使用了FileObserver(文件观察器)这个类,结果就被坑的不行不行的,昨天下班已经身心俱疲,本着跟bug呲牙必报的精神,这里要将这笔账记下,也希望大家以后不会在这上面浪费时间。FileObserver的功能故名思议,就是监听文件的事件啦,根据官方给出的文档,有以下几种事件的响应,对应不同的事件常量。 常量名 对应事件

Android 御码监 1万+

FileObserver文件监听

FileObserver是一个监听文件的创建、删除、更改,移动等操作的抽象类 监听的事件类型:FileObserver.ACCESS,即文件被访问 FileObserver. MODIFY,文件被 修改 FileObserver.ATTRIB,文件属性被修改, FileObserver.CLOSE_WRITE,可写文件被 close FileObserver.CLOSE_NOWRITE,不可

蔷薇_wendy的博客 5024

FileObserver失效,接收不到event

如何使用FileObserver 1. 申请权限 别忘了在代码中申请动态权限 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> 2.实现FileObserver 实现FileObserver时可以指定一个或多个文件及目

DragonCoding的专栏 1071

Android中关于FileObserver类的监听文件和目录动态

android.os下的FileObserver类是一个用于监听文件访问、创建、修改、删除、移动等操作的监听器,基于linux的inotify。 FileObserver 是个抽象类,必须继承它才能使用。每个FileObserver对象监听一个单独的文件或者文件夹,如果监视的是一个文件夹,那么文件夹下所有的文件和级联子目录的改变都会触发监听的事件。     所能监听的事件类型如下:     A

人生起落,生活苦甜,坚持追求! 1万+
上一篇: android多屏情况如何让壁纸支持多屏异显-学员作业
下一篇: Android.bp中添加条件判断编译方式
千里马学框架
博客等级 码龄6年 1万+粉丝 652原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千里马学框架

帮助你了,就请我喝杯咖啡

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值