devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

FileProvider详解

作者：盐析白兔 | 2024-03-04 23:20:23

赞

踩

fileprovider

作者：嘉伟咯 链接：https://www.jianshu.com/p/bf61f559f331

高版本的android对文件权限的管控抓的很严格,理论上两个应用之间的文件传递现在都应该是用FileProvider去实现,这篇博客来一起了解下它的实现原理。

首先我们要明确一点,FileProvider就是一个ContentProvider,所以需要在AndroidManifest.xml里面对它进行声明:

  1. <provider
  2.     android:name="androidx.core.content.FileProvider"
  3.     android:authorities="me.linjw.demo.fileprovider.provider"
  4.     android:exported="false"
  5.     android:grantUriPermissions="true">
  6.     <meta-data
  7.         android:name="android.support.FILE_PROVIDER_PATHS"
  8.         android:resource="@xml/file_path" />
  9. </provider>

和普通的ContentProvider不一样的是他多了一个android.support.FILE_PROVIDER_PATHS的meta-data指定了一个xml资源:

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <paths xmlns:android="http://schemas.android.com/apk/res/android">
  3.     <root-path name="root" path="" />
  4.     <files-path name="files" path="images/" />
  5.     <cache-path name="cache" path="" />
  6.     <external-path name="external" path="" />
  7.     <external-files-path  name="external-files" path="" />
  8.     <external-cache-path name="external-cache" path="" />
  9.     <external-media-path name="external-media" path="" />
  10. </paths>

文件URI

这个xml的作用在于为文件生成URI,root-path、files-path、cache-path这些标签代表父路径:

  1. root-path : File("/")
  2. files-path : Context.getFilesDir()
  3. cache-path : context.getCacheDir()
  4. external-path : Environment.getExternalStorageDirectory()
  5. external-files-path : ContextCompat.getExternalFilesDirs(context, null)[0]
  6. external-cache-path :  ContextCompat.getExternalCacheDirs(context)[0]
  7. external-media-path :  context.getExternalMediaDirs()[0]

path属性代表子路径,name代表为"父路径/子路径"起的名字,

<files-path name="files" path="images/" />

例如上面配置代表的就是我们为 new File(context.getFilesDir(), "images/") 这个路径起了个名字叫做files

  1. val filesDir = File(context.getFilesDir(), "images/")
  2. val uri = FileProvider.getUriForFile(this, "me.linjw.demo.fileprovider.provider", File(filesDir, "test.jpg"))
  3. // uri就是把filesDir的路径转换"files",然后加上content://me.linjw.demo.fileprovider.provider
  4. // 即 "content://me.linjw.demo.fileprovider.provider/files/test.jpg"
从FileProvider的源码里面就能看到这部分的转换逻辑:
  1. private static final String TAG_ROOT_PATH = "root-path";
  2. private static final String TAG_FILES_PATH = "files-path";
  3. private static final String TAG_CACHE_PATH = "cache-path";
  4. private static final String TAG_EXTERNAL = "external-path";
  5. private static final String TAG_EXTERNAL_FILES = "external-files-path";
  6. private static final String TAG_EXTERNAL_CACHE = "external-cache-path";
  7. private static final String TAG_EXTERNAL_MEDIA = "external-media-path";
  8.  
  9.  
  10. ...
  11.  
  12.  
  13. int type;
  14. while ((type = in.next()) != END_DOCUMENT) {
  15.     if (type == START_TAG) {
  16.         final String tag = in.getName();
  17.  
  18.  
  19.         final String name = in.getAttributeValue(null, ATTR_NAME);
  20.         String path = in.getAttributeValue(null, ATTR_PATH);
  21.  
  22.  
  23.         File target = null;
  24.         if (TAG_ROOT_PATH.equals(tag)) {
  25.             target = DEVICE_ROOT;
  26.         } else if (TAG_FILES_PATH.equals(tag)) {
  27.             target = context.getFilesDir();
  28.         } else if (TAG_CACHE_PATH.equals(tag)) {
  29.             target = context.getCacheDir();
  30.         } else if (TAG_EXTERNAL.equals(tag)) {
  31.             target = Environment.getExternalStorageDirectory();
  32.         } else if (TAG_EXTERNAL_FILES.equals(tag)) {
  33.             File[] externalFilesDirs = ContextCompat.getExternalFilesDirs(context, null);
  34.             if (externalFilesDirs.length > 0) {
  35.                 target = externalFilesDirs[0];
  36.             }
  37.         } else if (TAG_EXTERNAL_CACHE.equals(tag)) {
  38.             File[] externalCacheDirs = ContextCompat.getExternalCacheDirs(context);
  39.             if (externalCacheDirs.length > 0) {
  40.                 target = externalCacheDirs[0];
  41.             }
  42.         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
  43.                 && TAG_EXTERNAL_MEDIA.equals(tag)) {
  44.             File[] externalMediaDirs = context.getExternalMediaDirs();
  45.             if (externalMediaDirs.length > 0) {
  46.                 target = externalMediaDirs[0];
  47.             }
  48.         }
  49.  
  50.  
  51.         if (target != null) {
  52.             strat.addRoot(name, buildPath(target, path));
  53.         }
  54.     }
  55. }
  56.  
  57.  
  58. ...
  59.  
  60.  
  61. private static File buildPath(File base, String... segments) {
  62.     File cur = base;
  63.     for (String segment : segments) {
  64.         if (segment != null) {
  65.             cur = new File(cur, segment);
  66.         }
  67.     }
  68.     return cur;
  69. }

查询的时候就只需要从strat里面找到文件路径最匹配的name即可。

打开文件

有了这个uri之后我们就能通过Intent将它传给其他应用,并配置Intent.FLAG_GRANT_READ_URI_PERMISSION或者Intent.FLAG_GRANT_WRITE_URI_PERMISSION为其他应用设置读写权限:

  1. val uri = FileProvider.getUriForFile(this, "me.linjw.demo.fileprovider.provider", file)
  2. val intent = Intent()
  3. intent.data = uri
  4. intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
  5. intent.setClassName("me.linjw.demo.fileprovider.recv", "me.linjw.demo.fileprovider.recv.MainActivity")
  6. startActivity(intent)

其他应用拿到这个uri就可以通过ContentResolver.openInputStream打开文件流:

val inputStream = intent.data?.let { contentResolver.openInputStream(it) }
或者有时候我们希望通过String传递uri的时候可以提前使用Context.grantUriPermission为指定的包名申请权限,然后接收端Uri.parse去解析出Uri来操作文件:
  1. // 发送端
  2. val uri = FileProvider.getUriForFile(this, "me.linjw.demo.fileprovider.provider", file)
  3. grantUriPermission("me.linjw.demo.fileprovider.recv", uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
  4.  
  5.  
  6. val intent = Intent()
  7. intent.putExtra("uri", uri.toString())
  8. intent.setClassName("me.linjw.demo.fileprovider.recv", "me.linjw.demo.fileprovider.recv.MainActivity")
  9. startActivity(intent)
  10.  
  11.  
  12. // 接收端
  13. val uri = Uri.parse(intent.getStringExtra("uri"))
  14. val inputStream = contentResolver.openInputStream(uri)

Uri操作文件的原理实际上就是通过请求我们之前声明的me.linjw.demo.fileprovider.provider这个ContentProvider,让它给我们去打开文件:

  1. // FileProvider.java
  2. public ParcelFileDescriptor openFile(@NonNull Uri uri, @NonNull String mode)
  3.         throws FileNotFoundException {
  4.     // ContentProvider has already checked granted permissions
  5.     final File file = mStrategy.getFileForUri(uri);
  6.     final int fileMode = modeToMode(mode);
  7.     return ParcelFileDescriptor.open(file, fileMode);
  8. }

也就是说文件权限的校验实际上只发生在打开的阶段.其他应用虽然没有权限打开我们的文件,但是我们可以在ContentProvider里面帮它打开然后返回文件描述符,给其他应用去读写。

f7c358294ac7814f60ac3b7a898d83c7.jpeg

系统应用使用FileProvider的坑

项目中有个系统应用需要向其他应用传的文件,于是把FileProvider加上,然后发现其他应用还是没有权限。从日志里面看是说这个FileProvider并没有从UID 1000里暴露出来:

  1. 02-13 06:52:28.921  4292  4292 E AndroidRuntime: Caused by: java.lang.SecurityException: 
  2. Permission Denial: opening provider androidx.core.content.FileProvider from ProcessRecord{806d30d 4292:me.linjw.demo.fileprovider.recv/u0a53} (pid=4292, uid=10053) that is not exported from UID 1000
由于这个UID 1000太显眼，所以尝试将系统签名去掉发现权限就正常了,实锤是系统签名的原因。

查看出现异常的时候的日志,发现了下面的打印:

02-13 06:52:28.486   863  1393 W UriGrantsManagerService: For security reasons, the system cannot issue a Uri permission grant to content://me.linjw.demo.fileprovider.provider/root/data/user/0/me.linjw.demo.fileprovider/files/test.txt [user 0]; use startActivityAsCaller() instead
在代码里面搜索关键字,发现系统应用需要在源码里面配置FileProvider的authorities:
  1. // https://cs.android.com/android/platform/superproject/+/android-13.0.0_r29:frameworks/base/services/core/java/com/android/server/uri/UriGrantsManagerService.java
  2.  
  3.  
  4. // Bail early if system is trying to hand out permissions directly; it
  5. // must always grant permissions on behalf of someone explicit.
  6. final int callingAppId = UserHandle.getAppId(callingUid);
  7. if ((callingAppId == SYSTEM_UID) || (callingAppId == ROOT_UID)) {
  8.     if ("com.android.settings.files".equals(grantUri.uri.getAuthority())
  9.             || "com.android.settings.module_licenses".equals(grantUri.uri.getAuthority())) {
  10.         // Exempted authority for
  11.         // 1. cropping user photos and sharing a generated license html
  12.         //    file in Settings app
  13.         // 2. sharing a generated license html file in TvSettings app
  14.         // 3. Sharing module license files from Settings app
  15.     } else {
  16.         Slog.w(TAG, "For security reasons, the system cannot issue a Uri permission"
  17.                 + " grant to " + grantUri + "; use startActivityAsCaller() instead");
  18.         return -1;
  19.     }
  20. }

直接传递ParcelFileDescriptor

从原理上看FileProvider实际就是打开文件的ParcelFileDescriptor传给其他应用使用,那我们能不能直接打开文件然后将ParcelFileDescriptor直接通过Intent传给其他应用呢?

  1. val intent = Intent()
  2. intent.putExtra("fd" , ParcelFileDescriptor.open(file, MODE_READ_ONLY))
  3. intent.setClassName("me.linjw.demo.fileprovider.recv", "me.linjw.demo.fileprovider.recv.MainActivity")
  4. startActivity(intent)

答案是不行:

  1. 02-15 20:27:24.200 16968 16968 E AndroidRuntime: Process: me.linjw.demo.fileprovider, PID: 16968
  2. 02-15 20:27:24.200 16968 16968 E AndroidRuntime: java.lang.RuntimeException: Not allowed to write file descriptors here                        
  3. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Parcel.nativeWriteFileDescriptor(Native Method)
  4. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Parcel.writeFileDescriptor(Parcel.java:922)
  5. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.ParcelFileDescriptor.writeToParcel(ParcelFileDescriptor.java:1110)
  6. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Parcel.writeParcelable(Parcel.java:1953)
  7. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Parcel.writeValue(Parcel.java:1859)
  8. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Parcel.writeArrayMapInternal(Parcel.java:1024)
  9. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.BaseBundle.writeToParcelInner(BaseBundle.java:1620)
  10. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Bundle.writeToParcel(Bundle.java:1304)
  11. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.os.Parcel.writeBundle(Parcel.java:1093)
  12. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.content.Intent.writeToParcel(Intent.java:11123)
  13. 02-15 20:27:24.200 16968 16968 E AndroidRuntime:        at android.app.IActivityTaskManager$Stub$Proxy.startActivity(IActivityTaskManager.java:
  14. 2298)

原因在于Instrumentation的execStartActivity启动Activity前会调用Intent.prepareToLeaveProcess最终调用到Bundle.setAllowFds(false)不允许传递ParcelFileDescriptor:

  1. // https://cs.android.com/android/platform/superproject/+/android-13.0.0_r29:frameworks/base/core/java/android/app/Instrumentation.java
  2. public ActivityResult execStartActivity(
  3.         Context who, IBinder contextThread, IBinder token, Activity target,
  4.         Intent intent, int requestCode, Bundle options) {
  5.     ...
  6.     intent.prepareToLeaveProcess(who);
  7.     ...
  8. }
  9.  
  10.  
  11.  
  12.  
  13. // https://cs.android.com/android/platform/superproject/+/android-13.0.0_r29:frameworks/base/core/java/android/content/Intent.java
  14. public void prepareToLeaveProcess(Context context) {
  15.     final boolean leavingPackage;
  16.     if (mComponent != null) {
  17.         leavingPackage = !Objects.equals(mComponent.getPackageName(), context.getPackageName());
  18.     } else if (mPackage != null) {
  19.         leavingPackage = !Objects.equals(mPackage, context.getPackageName());
  20.     } else {
  21.         leavingPackage = true;
  22.     }
  23.     prepareToLeaveProcess(leavingPackage);
  24. }
  25.  
  26.  
  27. /**
  28.  * Prepare this {@link Intent} to leave an app process.
  29.  *
  30.  * @hide
  31.  */
  32. public void prepareToLeaveProcess(boolean leavingPackage) {
  33.     setAllowFds(false);
  34.     ...
  35. }
  36.  
  37.  
  38. public void setAllowFds(boolean allowFds) {
  39.     if (mExtras != null) {
  40.         mExtras.setAllowFds(allowFds);
  41.     }
  42. }

一开始我想通过反射去强行调用setAllowFds(true),但是发现这个方法被限制了,需要系统权限才能调用:

Accessing hidden method Landroid/os/Bundle;->setAllowFds(Z)Z (max-target-o, reflection, denied)
只能另谋出路,由于ParcelFileDescriptor实现了Parcelable,所以我们可以通过传递Binder的方式迂回的去传递:
  1. // aidl
  2. interface IFileDescriptorsProvider {
  3.     ParcelFileDescriptor get();
  4. }
  5.  
  6.  
  7. // 发送端
  8. val fileProvider = object : IFileDescriptorsProvider.Stub() {
  9.     override fun get(): ParcelFileDescriptor {
  10.         return ParcelFileDescriptor.open(file, MODE_READ_ONLY)
  11.     }
  12. }
  13. val intent = Intent()
  14. val bundle = Bundle().apply { putBinder("fileProvider", fileProvider) }
  15. intent.putExtras(bundle)
  16. intent.setClassName("me.linjw.demo.fileprovider.recv", "me.linjw.demo.fileprovider.recv.MainActivity")
  17. startActivity(intent)
  18.  
  19.  
  20. // 接收端
  21. val text = intent.extras?.getBinder("fileProvider")?.let { it ->
  22.     val fd = IFileDescriptorsProvider.Stub.asInterface(it).get()
  23.     AssetFileDescriptor(fd, 0, -1)
  24.         .createInputStream()
  25.         .use { it.bufferedReader().readLine() }
  26. }

关注我获取更多知识或者投稿

334567de2e4a2d3dff6414d17f00894e.jpeg

6417de8b474ca780be8411212267aaec.jpeg



来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/188983
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号