devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android studio开发——android11版本以上权限动态申请问题，包括文件读写、图片、相机的调用_android.permission.read_media_images

作者：我家自动化 | 2024-04-17 04:09:59

赞

踩

android.permission.read_media_images

用于android手机的升级，现在已经是android13版本了，对于权限问题可能更加敏感了，前段时间开发发现之前的方法已经不再适用于android11以后的版本了

读写权限申请最好是跳转到设置中进行才是最好了，下面我们开始进行

首先是AndroidManifest.xml文件的权限

  1. <!--    android13的图片、音频、视频的权限-->
  2.     <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
  3.     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
  4.     <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
  5.  
  6.     <!--存储权限-->
  7.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
  8.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
  9.     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE"
  10.         tools:ignore="ScopedStorage" />
  11.  
  12. <!--    打开相机权限-->
  13.     <uses-permission android:name="android.permission.CAMERA" />
  14.     <uses-feature android:name="android.hardware.camera" />
  15.     
  16. <!--    网络权限-->
  17.     <uses-permission android:name="android.permission.INTERNET" />

然后这里讲解一下权限申请的情况，有两种情况

第一种情况是直接在Activity中申请权限

第二种情况是在Fragment中申请权限

第一种情况就比较直接，按照android11之前的权限申请如下

  1. //首先定义请求变量  
  2. private static final String[] PERMISSIONS_STORAGE = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE};
  3. //请求状态码，请求码的作用是与回调函数进行匹配的，这样就可以对不同权限操作进行不同的提示
  4. private static final int REQUEST_EXTERNAL_STORAGE = 1;
  5.  
  6. //使用ActivityCompat.requestPermissions进行动态权限申请
  7. ActivityCompat.requestPermissions(MainActivity.this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
  8.  
  9. //然后Activity会有一个回调函数，可以在这个回调函数做一些提示
  10. //如下重写onRequestPermissionsResult方法
  11. @Override
  12. public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { //申请文件读写权限
  13.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  14.         switch (requestCode) {
  15.             case REQUEST_EXTERNAL_STORAGE:
  16.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  17.                     havePermission = true;
  18.                     Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  19.                 } else {
  20.                     havePermission = false;
  21.                     Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
  22.                 }
  23.                 break;
  24.             case REQUEST_PERMISSION_CODE_33:
  25.                 Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  26.                 break;
  27.         }

 完整代码例子如下

  1. public class MainActivity extends AppCompatActivity {
  2.      private static final String[] PERMISSIONS_STORAGE = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE};
  3.     //请求状态码
  4.     private static final int REQUEST_EXTERNAL_STORAGE = 1;
  5.  
  6.     //创建Activity生命周期
  7.     protected void onCreate(Bundle savedInstanceState) {
  8.  
  9.     }
  10.  
  11.     //获取Activity焦点的生命周期
  12.     @Override
  13.     protected void onResume() {
  14.         super.onResume();
  15.         checkPermission();
  16.     }
  17.  
  18.      private AlertDialog dialog;
  19.  
  20.     private void checkPermission() {
  21.         //检查权限（NEED_PERMISSION）是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
  22.             //这里是android7以上就需要动态申请权限
  23.             if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
  24.                 if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  25.                     //申请权限
  26.                     if (dialog != null) {
  27.                         dialog.dismiss();
  28.                         dialog = null;
  29.                     }
  30.                     dialog = new AlertDialog.Builder(this)
  31.                             .setTitle("提示")//设置标题
  32.                             .setMessage("请开启文件访问权限，否则无法正常使用应用！")
  33.                             .setPositiveButton("确定", new DialogInterface.OnClickListener() {
  34.                                 @Override
  35.                                 public void onClick(DialogInterface dialog, int which) {
  36.                                     dialog.dismiss();
  37.                                     ActivityCompat.requestPermissions(MainActivity.this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
  38.                                 }
  39.                             }).create();
  40.                     dialog.show();
  41.                 } else {
  42.                     havePermission = true;
  43.                     
  44.                 }
  45.             } else {
  46.                 //android6以下不需要动态申请权限
  47.                 havePermission = true;
  48.                 
  49.             }
  50.         
  51.     }
  52. }
  53.  
  54. @Override
  55. public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { //申请文件读写权限
  56.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  57.         switch (requestCode) {
  58.             case REQUEST_EXTERNAL_STORAGE:
  59.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  60.                     havePermission = true;
  61.                     Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  62.                 } else {
  63.                     havePermission = false;
  64.                     Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
  65.                 }
  66.                 break;
  67.             case REQUEST_PERMISSION_CODE_33:
  68.                 Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  69.                 break;
  70.         }

 下面是第二种情况在Fragment中动态申请权限，因为Fragment是相当于依附在Activity中的页面，所以Fragment中没有回调函数处理，因此需要用到它所在的Activity的activity对象，例如Fragment的定义如下

  1. public class PersonFragment extends Fragment {
  2.     //定义一个Activity对象，用于给MainActivity赋值
  3.     public static Activity context;
  4.     private static final String[] PERMISSIONS_STORAGE = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.CAMERA};
  5.     //请求状态码
  6.     private static final int REQUEST_EXTERNAL_STORAGE = 1;
  7. }
  8.  
  9.  @Override
  10.  public void onStart() {
  11.      super.onStart();
  12.      
  13.    checkPermission();
  14.     }
  15.  
  16.      private AlertDialog dialog;
  17.  
  18.     private void checkPermission() {
  19.         //检查权限（NEED_PERMISSION）是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
  20.             //这里是android7以上就需要动态申请权限
  21.             if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
  22.                 if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  23.                     //申请权限
  24.                     if (dialog != null) {
  25.                         dialog.dismiss();
  26.                         dialog = null;
  27.                     }
  28.                     dialog = new AlertDialog.Builder(this)
  29.                             .setTitle("提示")//设置标题
  30.                             .setMessage("请开启文件访问权限，否则无法正常使用应用！")
  31.                             .setPositiveButton("确定", new DialogInterface.OnClickListener() {
  32.                                 @Override
  33.                                 public void onClick(DialogInterface dialog, int which) {
  34.                                     dialog.dismiss();
  35.                                     ActivityCompat.requestPermissions(context, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
  36.                                 }
  37.                             }).create();
  38.                     dialog.show();
  39.                 } else {
  40.                     havePermission = true;
  41.                     
  42.                 }
  43.             } else {
  44.                 //android6以下不需要动态申请权限
  45.                 havePermission = true;
  46.                 
  47.             }
  48.         
  49.     }

那么在MainActivity中我们给上面的Fragment赋值activity对象，那么Fragment就可以在申请权限的时候操做MainActivity的回调函数了，MainActivity代码例子如下

  1. public class MainActivity extends AppCompatActivity {
  2.     //这里的请求码要和Fragment的请求码一致
  3.     private static final int REQUEST_EXTERNAL_STORAGE = 1;
  4.  
  5.     //创建Activity生命周期
  6.     protected void onCreate(Bundle savedInstanceState) {
  7.  
  8.         PersonFragment.context = MainActivity.this
  9.  
  10.     }
  11.  
  12.  
  13. @Override
  14. public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { //申请文件读写权限
  15.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  16.         switch (requestCode) {
  17.             case REQUEST_EXTERNAL_STORAGE:
  18.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  19.                     havePermission = true;
  20.                     Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  21.                 } else {
  22.                     havePermission = false;
  23.                     Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
  24.                 }
  25.                 break;
  26.             case REQUEST_PERMISSION_CODE_33:
  27.                 Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  28.                 break;
  29.         }

以上例子是对于一些到懂不懂的朋友讲解权限申请与回调函数的关系使用，下面就是android7以下及android11以下以及android13以下的动态权限申请情况

1.文件读写权限直接上代码了

  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.      //申请的权限放进数组里
  4.      private static final String[] PERMISSIONS_STORAGE = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE};
  5.     //请求状态码
  6.     private static final int REQUEST_EXTERNAL_STORAGE = 1;
  7.  
  8.     //创建Activity生命周期
  9.     protected void onCreate(Bundle savedInstanceState) {
  10.  
  11.     }
  12.  
  13.     //获取Activity焦点的生命周期
  14.    
  15.     @Override
  16.     protected void onResume() {
  17.         super.onResume();
  18.         checkPermission();
  19.     }
  20.  
  21.     private AlertDialog dialog;
  22.  
  23.     private void checkPermission() {
  24.         //检查权限（NEED_PERMISSION）是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
  25.         //这里是android11以上的读写权限申请
  26.         //需要通过Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION跳转到权限设置打开权限
  27.         if (Build.VERSION.SDK_INT >= 30) {
  28.             if (!Environment.isExternalStorageManager()) {
  29.                 if (dialog != null) {
  30.                     dialog.dismiss();
  31.                     dialog = null;
  32.                 }
  33.                 dialog = new AlertDialog.Builder(this)
  34.                         .setTitle("提示")//设置标题
  35.                         .setMessage("请开启文件访问权限，否则无法正常使用本应用！")
  36.                         .setNegativeButton("取消", new DialogInterface.OnClickListener() {
  37.                             @Override
  38.                             public void onClick(DialogInterface dialog, int i) {
  39.                                 dialog.dismiss();
  40.                             }
  41.                         })
  42.                         .setPositiveButton("确定", new DialogInterface.OnClickListener() {
  43.                             @Override
  44.                             public void onClick(DialogInterface dialog, int which) {
  45.                                 dialog.dismiss();
  46.                                 Intent intent = new Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION);
  47.                                 startActivity(intent);
  48.                             }
  49.                         }).create();
  50.                 dialog.show();
  51.             } else {
  52.                 havePermission = true;
  53.                 
  54.             }
  55.         } else {
  56.             //这里就是android7到android11的权限申请
  57.             //直接通过ActivityCompat.requestPermissions就可以
  58.             if (Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
  59.                 if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  60.                     //申请权限
  61.                     if (dialog != null) {
  62.                         dialog.dismiss();
  63.                         dialog = null;
  64.                     }
  65.                     dialog = new AlertDialog.Builder(this)
  66.                             .setTitle("提示")//设置标题
  67.                             .setMessage("请开启文件访问权限，否则无法正常使用应用！")
  68.                             .setPositiveButton("确定", new DialogInterface.OnClickListener() {
  69.                                 @Override
  70.                                 public void onClick(DialogInterface dialog, int which) {
  71.                                     dialog.dismiss();
  72.                                     ActivityCompat.requestPermissions(MainActivity.this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
  73.                                 }
  74.                             }).create();
  75.                     dialog.show();
  76.                 } else {
  77.                     havePermission = true;
  78.                   
  79.                 }
  80.             } else {
  81.                 //android7以下的不需要动态申请权限
  82.                 havePermission = true;
  83.                
  84.             }
  85.         }
  86.     }
  87.  
  88.     //权限申请成功后的回调函数，可以做提示或其他
  89.     @Override
  90.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { //申请文件读写权限
  91.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  92.         switch (requestCode) {
  93.             case REQUEST_EXTERNAL_STORAGE:
  94.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  95.                     havePermission = true;
  96.                     Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  97.                 } else {
  98.                     havePermission = false;
  99.                     Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
  100.                 }
  101.                 break;
  102.             case REQUEST_PERMISSION_CODE_33:
  103.                 Toast.makeText(this, "授权成功！", Toast.LENGTH_SHORT).show();
  104.                 break;
  105.         }
  106.     }

2.相册、相机权限申请情况

这里可能就android13比较特殊，因为android13把相册分成了3个权限，分别是图片申请、视频申请、音频申请

  1. private static final String[] PERMISSIONS_STORAGE = {Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA};
  2. //请求状态码
  3. private static final int REQUEST_EXTERNAL_STORAGE = 1;
  4.  
  5. //android13相册权限申请变量    
  6. private static final String[] PERMISSIONS_STORAGE_33 = {Manifest.permission.READ_MEDIA_IMAGES, Manifest.permission.READ_MEDIA_AUDIO, Manifest.permission.READ_MEDIA_VIDEO, Manifest.permission.CAMERA};
  7. //请求状态码
  8. private static final int REQUEST_PERMISSION_CODE_33 = 2;

那么权限数组可能就不一样了，android13以下的申请读写权限就好了，而android13则可能需要动态申请这3个权限，所以代码如下，这里我用Fragment申请权限

  1. @RequiresApi(api = Build.VERSION_CODES.TIRAMISU)
  2. @SuppressLint("StaticFieldLeak")
  3. public class PersonFragment extends Fragment {
  4.     //MainActivity的activity对象
  5.     public static Activity context;
  6.       @Override
  7.     public void onStart() {
  8.         super.onStart();
  9.         ifHaveAlbumPermission(context)
  10.  
  11.     }    
  12.  
  13.     //打开相册
  14.     private void openFile() {
  15.  
  16.         Intent intentFromGallery = new Intent();
  17.         // 设置文件类型
  18.         intentFromGallery.setType("image/*");//选择图片
  19.         intentFromGallery.setAction(Intent.ACTION_GET_CONTENT);
  20.         
  21.         //你需要使用系统提供的startActivityForResult(Intent intent,int requestCode)方法调用MainActivity的回调函数
  22.         context.startActivityForResult(intentFromGallery, REQUEST_PICTURE_CODE);
  23.  
  24.  
  25.     }
  26.  
  27.     // 判断是否有文件存储权限
  28.     private void ifHaveAlbumPermission(Activity activity) {
  29.  
  30.         if (ActivityCompat.checkSelfPermission(activity, Manifest.permission.READ_MEDIA_IMAGES) != PackageManager.PERMISSION_GRANTED) {
  31.             //android13权限申请
  32.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
  33.  
  34.                 ActivityCompat.requestPermissions(activity, PERMISSIONS_STORAGE_33, REQUEST_PERMISSION_CODE_33);
  35.                 openFile();
  36.             } else {
  37.                 //android13以下的权限申请
  38.                 ActivityCompat.requestPermissions(activity, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);
  39.             }
  40.         } else {
  41.             openFile();
  42.         }
  43.        
  44.     }
  45.  
  46. }

以上就差不多完成了，相机的情况大同小异，可以看其他博主写的

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

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

  

闽ICP备14008679号