Android FileProvider详细解析和踩坑指南

        其实很早之前我的应用就已经兼容到Android7.0了，此次写这个文章就是想详细梳理一下android的文件系统，以及做一下FileProvider的解析。
        Android7.0 （N） 开始，将严格执行 StrictMode 模式，也就是说，将对安全做更严格的校验。而从 Android N 开始，将不允许在 App 间，使用 file:// 的方式，传递一个 File ，否者会抛出 FileUriExposedException 的错误，会直接引发 Crash。
        但是，既然官方对文件的分享做了一个这么强硬的修改（直接抛出异常），实际上也提供了解决方案，那就是 FileProvider，通过 content:// 的模式替换掉 file:// ，同时，需要开发者主动升级 targetSdkVersion 到 24 才会执行此策略。
        FileProvider是android support v4包提供的，是ContentProvider的子类，便于将自己app的数据提供给其他app访问。
        在app开发过程中需要用到FileProvider的主要有

1. 相机拍照以及图片裁剪
2. 调用系统应用安装器安装apk（应用升级）

具体使用的方法
1、配置AndroidManifest文件

  <provider
            android:name="android.support.v4.content.FileProvider"
            android:authorities="${applicationId}.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/provider_paths" />
        </provider>
1
2
3
4
5
6
7
8
9

authorities：一个标识，在当前系统内必须是唯一值，一般用包名。
exported：表示该 FileProvider 是否需要公开出去。
granUriPermissions：是否允许授权文件的临时访问权限。这里需要，所以是 true。

2、在res的建xml目录，放入provider_paths.xml文件

<?xml version="1.0" encoding="utf-8"?>
<paths>
    <external-path
        name="external_storage_root"
        path="." />
    <files-path
        name="files-path"
        path="." />
    <cache-path
        name="cache-path"
        path="." />
    <!--/storage/emulated/0/Android/data/...-->
    <external-files-path
        name="external_file_path"
        path="." />
    <!--代表app 外部存储区域根目录下的文件 Context.getExternalCacheDir目录下的目录-->
    <external-cache-path
        name="external_cache_path"
        path="." />
    <!--配置root-path。这样子可以读取到sd卡和一些应用分身的目录，否则微信分身保存的图片，就会导致 java.lang.IllegalArgumentException: Failed to find configured root that contains /storage/emulated/999/tencent/MicroMsg/WeiXin/export1544062754693.jpg，在小米6的手机上微信分身有这个crash，华为没有
-->
    <root-path
        name="root-path"
        path="" />
/paths>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这个配置的标签参照FileProvider里面的TAG配置。

之后FileProvider的path解析策略如下

    private static FileProvider.PathStrategy parsePathStrategy(Context context, String authority) throws IOException, XmlPullParserException {
        FileProvider.SimplePathStrategy strat = new FileProvider.SimplePathStrategy(authority);
        ProviderInfo info = context.getPackageManager().resolveContentProvider(authority, 128);
        XmlResourceParser in = info.loadXmlMetaData(context.getPackageManager(), "android.support.FILE_PROVIDER_PATHS");
        if (in == null) {
            throw new IllegalArgumentException("Missing android.support.FILE_PROVIDER_PATHS meta-data");
        } else {
            int type;
            while((type = in.next()) != 1) {
                if (type == 2) {
                    String tag = in.getName();
                    String name = in.getAttributeValue((String)null, "name");
                    String path = in.getAttributeValue((String)null, "path");
                    File target = null;
                    if ("root-path".equals(tag)) {
                        target = DEVICE_ROOT;
                    } else if ("files-path".equals(tag)) {
                        target = context.getFilesDir();
                    } else if ("cache-path".equals(tag)) {
                        target = context.getCacheDir();
                    } else if ("external-path".equals(tag)) {
                        target = Environment.getExternalStorageDirectory();
                    } else {
                        File[] externalMediaDirs;
                        if ("external-files-path".equals(tag)) {
                            externalMediaDirs = ContextCompat.getExternalFilesDirs(context, (String)null);
                            if (externalMediaDirs.length > 0) {
                                target = externalMediaDirs[0];
                            }
                        } else if ("external-cache-path".equals(tag)) {
                            externalMediaDirs = ContextCompat.getExternalCacheDirs(context);
                            if (externalMediaDirs.length > 0) {
                                target = externalMediaDirs[0];
                            }
                        } else if (VERSION.SDK_INT >= 21 && "external-media-path".equals(tag)) {
                            externalMediaDirs = context.getExternalMediaDirs();
                            if (externalMediaDirs.length > 0) {
                                target = externalMediaDirs[0];
                            }
                        }
                    }

                    if (target != null) {
                        strat.addRoot(name, buildPath(target, path));
                    }
                }
            }

            return strat;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

root-path 对应DEVICE_ROOT,也就是 File DEVICE_ROOT = new File("/")，即根目录，一般不需要配置。
files-path对应 content.getFileDir() 获取到的目录。
cache-path对应 content.getCacheDir() 获取到的目录
external-path对应 Environment.getExternalStorageDirectory() 指向的目录。
external-files-path对应 ContextCompat.getExternalFilesDirs() 获取到的目录。
external-cache-path对应 ContextCompat.getExternalCacheDirs() 获取到的目录。

  	        Intent intent = new Intent(Intent.ACTION_VIEW);
            intent.addCategory(Intent.CATEGORY_DEFAULT);
            Uri uri;
            File file = new File(saveFolder, updateSaveName);
            if (Build.VERSION.SDK_INT >= 24) {//android 7.0以上
                uri = FileProvider.getUriForFile(activity, BuildConfig.APPLICATION_ID.concat(".provider"), file);
            } else {
                uri = Uri.fromFile(file);
            }
            String type = "application/vnd.android.package-archive";
            intent.setDataAndType(uri, type);
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            if (Build.VERSION.SDK_INT >= 24) {
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            }
            activity.startActivityForResult(intent, 10);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意点
        经过大量用户使用，后期反馈，在小米6，开启微信分身之后，分身微信保存的图片，使用FileProvider将一张图片的path转成Uri的过程中crash了。这张图片路径如下

/storage/emulated/999/tencent/MicroMsg/WeiXin/mmexport1544062754693.jpg
1

你一定觉得很奇怪，正常路径是/storage/emulate/0，怎么会有/storage/emulate/999的路径，查找原因是应用分身导致的。之后会抛

 java.lang.IllegalArgumentException: Failed to find configured root that contains /storage/emulated/999/tencent/MicroMsg/WeiXin/mmexport1544062754693.jpg
1

那个时候，我的代码的xml的path里面是没有配置root-path节点的。debug时，fileProvide的mRoots是5个元素

后面我添加了root-path节点之后，mRoots变成了6个

之后就完美实现了将path转成Uri。
        部分手机可以插外置sdcard，比如红米手机，之后就导致找不到sdcard的root，这时候也是需要配置root-path。
        下面在聊一聊Android的文件系统
外部存储的公共目录
DIRECTORY_MUSIC：音乐类型 /storage/emulate/0/music
DIRECTORY_PICTURES：图片类型
DIRECTORY_MOVIES：电影类型
DIRECTORY_DCIM：照片类型,相机拍摄的照片视频都在这个目录（digital camera in memory） /storage/emulate/0/DCIM
DIRECTORY_DOWNLOADS：下载文件类型 /storage/emulate/0/downloads
DIRECTORY_DOCUMENTS：文档类型
DIRECTORY_RINGTONES：铃声类型
DIRECTORY_ALARMS：闹钟提示音类型
DIRECTORY_NOTIFICATIONS：通知提示音类型
DIRECTORY_PODCASTS：播客音频类型

这些可以通过Environment的getExternalStoragePublicDirectory()来获取

public static File getExternalStoragePublicDirectory(String type);
1

ContentProvider是跨进程的，可以通过数据库方式向外提供数据，提供数据库读写，那么能否提供一些非持久化的数据，比如运行时的内存数据呢，其实也是可以的。ContentProvider提供了call方法，但此方法比较危险，最好配置好访问权限，避免滥用。

你可以重写此方法提供一些内存数据，一些状态值，供其他应用获取，例如

    @Nullable
    @Override
    public Bundle call(@NonNull String method, @Nullable String arg, @Nullable Bundle extras) {
        if (TextUtils.isEmpty(method)) {
            return super.call(method, arg, extras);
        }
        try {
            // 获取A的状态值
            if ("getAState".equals(method)) {
                if (TextUtils.isEmpty(arg)) {
                    return super.call(method, arg, extras);
                }
                Bundle bundle = new Bundle();
                // 获取状态值
                bundle.putString(KEY_A, aState);
                return bundle;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return super.call(method, arg, extras);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用此方法共享数据的时候，需要注意，获取的状态的时候需要做判空处理。因为如果当前进程死掉，那么这时候获取是获取不到此ContentProvider。
获取方法如下：

     ContentResolver contentResolver = mContext.getContentResolver();
     ContentProviderClient providerClient = contentResolver.acquireUnstableContentProviderClient(ADataProvider.sUri);
     String aState= "0";
     if (providerClient != null) {
        Bundle queryAState = contentResolver.call(ADataProvider.sUri, "getAState", null, null);
        aState= queryPlanetBack.getString(KEY_A);
     }
1
2
3
4
5
6
7

不判空，就会导致依赖这个ContentProvider进程重启，抛异常
depends on provider com.test.demo2/.provider.ADataProvider in dying proc com.test.demo2 (adj 0)
详情可看此博主的文章
ContentProvider导致App闪退问题分析
找了两篇还不错的文章，贴一下，偷个懒
Android文件系统详解
彻底理解android中的内部存储与外部存储
Android文件系统的结构及目录用途、操作方法 整理
后面那位大兄弟，写的很详细，很不错哦！

---

致敬前辈，砥砺前行！

欢迎关注，留言，一起交流技术！
感谢支持！