FileProvider

基础

官网链接

为了安全地共享本 app 的文件,您需要配置您的应用程序,以 Content URI 形式为文件提供安全的句柄。 FileProvider 会根据你在 XML 中提供的规范生成文件的 Content URI 。

  1. FileProvider 继承于 ContentProvider ,它只是内容提供者的一个特殊子类。

  2. 也可以不使用 FileProvider ,而自己定义一个 ContentProvider 。

几个方法的返回路径

方法名 返回路径
getExternalCacheDir() sd 卡中 Android/data/包名/cache 目录
getExternalFilesDir(String) sd 卡中 Android/data/包名/files/xx 目录,xx为方法参数
getCacheDir() 内部存储目录下的 cache 目录
getDir() 内部存储目录下的 app_xx 目录 ,其中 xx 为方法参数
getFilesDir() 内部存储目录下 files 目录

Manifest 配置

在清单文件中进行如下配置:

   
        
            
        
        ...
    

中 resource 属性指定了 xml 文件名,该文件位于 res/xml 文件夹下。
authorities 指定了 FileProvider 生成 URI 的authorities。

xml

在 res/xml 文件夹下建立以 resource 属性值为名的 xml 文件,在该文件中指定本 app 可以共享的文件目录,所有可以共享的目录只能在该 xml 中指定,无法通过代码动态完成

可以参考如下示例:


    

  1. path 属性指定了共享的子目录, name 属性指定了共享目录在 content URI 中的别名。子目录与别名是一一对应关系

  2. 中可以有多个子标签。

  3. 父目录名通过子标签名指定。如上面的 files-path 指定的父目录就是 getFilesDir() 返回的目录。

  4. 在上面例子中,如果共享的是 images 目录下的 default_image.jpg ,其对应的 content URI 如下:

content://com.example.myapp.fileprovider/url_name/default_image.jpg

其文件的真实路径

Context.getFilesDir() +"/images/default_image.jpg"

可以发现,转成 URI 后,images 目录下的路径会全部真实地保留。保留的部分叫剩余路径(为后期分析源码方便,自己取的名字)

子标签名

官网链接

标签名 对应的目录
files-path Context#getFilesDir()
cache-path Context#getCacheDir()
external-path Environment.getExternalStorageDirectory()
external-files-path Context#getExternalFilesDir
external-cache-path Context#getExternalCacheDir()

源码分析

因为是 ContentProvider ,所以先看其 attachInfo 方法。

attachInfo()

public void attachInfo(Context context, ProviderInfo info) {
        super.attachInfo(context, info);
        //对 exported 与 grantUriPermissions 属性值进行判断,其要求两者值必须分别为 false 与 true,否则就会扔异常。
        ……
        // authority 的值就是 authorities 属性的值
        mStrategy = getPathStrategy(context, info.authority);
    }

 private static PathStrategy getPathStrategy(Context context, String authority) {
        PathStrategy strat;
        synchronized (sCache) {
           //以 authority 值为 key 对 PathStrategy 对象进行缓存
            strat = sCache.get(authority);
            if (strat == null) {
                try {
                    strat = parsePathStrategy(context, authority);
                } 
                // 省略异常处理代码
                sCache.put(authority, strat);
            }
        }
        return strat;
    }

对 strat 进行初始化时,会调用 parsePathStrategy 方法,其主要就是解析在清单文件中指定的 xml 文件。

private static PathStrategy parsePathStrategy(Context context, String authority)
            throws IOException, XmlPullParserException {
        final SimplePathStrategy strat = new SimplePathStrategy(authority);
        //读取清单文件中配置的 xml 文件
        final ProviderInfo info = context.getPackageManager()
                .resolveContentProvider(authority, PackageManager.GET_META_DATA);
        final XmlResourceParser in = info.loadXmlMetaData(
                context.getPackageManager(), META_DATA_FILE_PROVIDER_PATHS);
        //对 in 进行非空判断 ,忽略。下面是对 in 进行 xml 解析
        int type;
        while ((type = in.next()) != END_DOCUMENT) {
            if (type == START_TAG) {
                final String tag = in.getName();
                //分别获取 name 属性与 path 属性
                final String name = in.getAttributeValue(null, ATTR_NAME);
                String path = in.getAttributeValue(null, ATTR_PATH);

                File target = null;
                if (TAG_ROOT_PATH.equals(tag)) {
                    target = DEVICE_ROOT;
                } else if (TAG_FILES_PATH.equals(tag)) {// 标签名为 files-path
                    target = context.getFilesDir();
                } else if (TAG_CACHE_PATH.equals(tag)) {// 标签名为 cache-path
                    target = context.getCacheDir();
                } else if (TAG_EXTERNAL.equals(tag)) {// 标签名为 external-path
                    target = Environment.getExternalStorageDirectory();
                } else if (TAG_EXTERNAL_FILES.equals(tag)) {// 标签名为 external-files-path
                    //这段代码的作用就是将 target 赋值为 getExternalFilesDir() 的返回值
                } else if (TAG_EXTERNAL_CACHE.equals(tag)) {// 标签名为 external-cache-path
                    //这段代码的作用就是将 target 赋值为 getExternalCacheDir() 的返回值
                }

                if (target != null) {
                    // buildPath 会在 target 目录下建立一个以 path 值为名的目录
                    strat.addRoot(name, buildPath(target, path));
                }
            }
        }

        return strat;
    }

    private static File buildPath(File base, String... segments) {
        File cur = base;
        for (String segment : segments) {
            if (segment != null) {
                cur = new File(cur, segment);
            }
        }
        return cur;
    }

其余方法

其他几个方法的实现,基本上都是通过 PathStrategy 完成的。如

    public static Uri getUriForFile(Context context, String authority, File file) {
        final PathStrategy strategy = getPathStrategy(context, authority);
        return strategy.getUriForFile(file);
    }

PathStrategy 与 SimplePathStrategy

PathStrategy 的唯一子类是 SimplePathStrategy。它会在 parsePathStrategy() 中被创建。

  static class SimplePathStrategy implements PathStrategy {
        private final String mAuthority;
        //以 name 属性值为 key ,以标签名与 path 值联合指定的目录 File 为 value
        private final HashMap mRoots = new HashMap();

        public SimplePathStrategy(String authority) {
            mAuthority = authority;
        }

        // name 是 xml 中定义 name 属性值,而 root 是根据 xml 中标签名与 path 属性值联合指定的一个本地文件目录,name 与 root 是一一对应关系
        public void addRoot(String name, File root) {
            ……
            mRoots.put(name, root);
        }

        @Override
        public Uri getUriForFile(File file) {
            String path;// path 指代 file 的路径。
            
            Map.Entry mostSpecific = null;
            for (Map.Entry root : mRoots.entrySet()) {
                final String rootPath = root.getValue().getPath();

               // 查找最接近 file 路径的 Map.Entry 对象。

                if (path.startsWith(rootPath) && (mostSpecific == null
                        || rootPath.length() > mostSpecific.getValue().getPath().length())) {
                    mostSpecific = root;
                }
            }

            // mostSpecific  非空判断,略
            
            // 以下对 path 进行处理,并最终转成 content://authority/name 形式的 URI
            // 通过该种方式处理,最终会将指定的文件根据清单文件中的 authority 以及 xml 中指定的 name 转换成 URI

            final String rootPath = mostSpecific.getValue().getPath();
            // 截取指定 file 的除 标签名及 path 属性指定的剩余部分
            if (rootPath.endsWith("/")) {
                path = path.substring(rootPath.length());
            } else {
                path = path.substring(rootPath.length() + 1);
            }
            // 将 path 转换成  name/剩余路径  形式
            path = Uri.encode(mostSpecific.getKey()) + '/' + Uri.encode(path, "/");
            return new Uri.Builder().scheme("content")
                    .authority(mAuthority).encodedPath(path).build();
        }

        @Override
        public File getFileForUri(Uri uri) {
            // 获取到的内容形式为:/name/剩余路径
            String path = uri.getEncodedPath();

            final int splitIndex = path.indexOf('/', 1);
            // xml 中指定的 name 属性值
            final String tag = Uri.decode(path.substring(1, splitIndex));
            // 文件的剩余路径
            path = Uri.decode(path.substring(splitIndex + 1));
            // 获取文件的根路径
            final File root = mRoots.get(tag);
            if (root == null) {
                throw new IllegalArgumentException("Unable to find configured root for " + uri);
            }

            File file = new File(root, path);
            try {
                file = file.getCanonicalFile();
            } catch (IOException e) {
                throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
            }

            if (!file.getPath().startsWith(root.getPath())) {
                throw new SecurityException("Resolved path jumped beyond configured root");
            }

            return file;
        }
    }

总结

  1. 指定 path 后,该目录下的所有文件都可以共享,无论是文件还是文件夹

你可能感兴趣的:(FileProvider)