Android 6.0 运行时权限处理

最新推荐文章于 2022-07-27 21:28:00 发布

huaxun66

最新推荐文章于 2022-07-27 21:28:00 发布

阅读量970

点赞数

分类专栏：技术关注

本文链接：https://blog.csdn.net/huaxun66/article/details/76249719

版权

技术关注专栏收录该内容

9 篇文章 0 订阅

订阅专栏

6.0之前的权限模型

在AndroidManifest中声明可能用到的所有权限
用户在安装时,系统展示所有权限,用户安装即授予所有权限,取消则拒绝安装

6.0新的运行时权限

将权限分为一般权限（Normal Permissions）和危险权限（Dangerous Permission）两种,一般权限跟以前一样在AndroidManifest声明，危险权限需要开发者在代码中手动的动态申请
动态申请权限,系统弹出对话框,用户可点击确定或拒绝,系统提供用户的选择回调,从而开发者处理相应的逻辑
用户可以选择拒绝并不再提醒

运行时权限分类

危险权限即需要动态申请的权限,一共9组,取得一组中某一个权限的授权,则自动拥有该组的所有授权

日历
摄像头
通讯录
地理位置
麦克风
电话
身体传感器
短信
存储空间

这里写图片描述

暂时不做运行时权限适配的方案(不推荐)

如果暂时还不想适配6.0运行时权限,但是又想要app可以在6.0及以上机型运行,那我们可以将目标版本改为23以下,如:targetSdkVersion 22,这样做的效果:

不管是6.0以下还是以上的机型都可以运行,跟之前一样权限在安装时一次性授予
由于6.0机型在设置中可以进行权限管理,用户可以取消该应用的某个权限,但是app并不知道该权限被取消,此时app可能会崩溃(合理的try可以避免)

权限适配相关API

（1）在AndroidManifest文件中添加需要申请的权限。

（2）检查权限

if (ContextCompat.checkSelfPermission(thisActivity,Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
   ...
}else{
   ...
}

ContextCompat.checkSelfPermission，主要用于检测某个权限是否已经被授予，方法返回值为PackageManager.PERMISSION_DENIED或者PackageManager.PERMISSION_GRANTED。当返回DENIED就需要进行申请授权了。

（3）申请授权

ActivityCompat.requestPermissions(thisActivity,
                new String[]{Manifest.permission.READ_CONTACTS},
                MY_PERMISSIONS_REQUEST_READ_CONTACTS);

该方法是异步的，第一个参数是Context；第二个参数是需要申请的权限的字符串数组；第三个参数为requestCode，主要用于回调的时候检测。可以从方法名requestPermissions以及第二个参数看出，是支持一次性申请多个权限的，系统会通过对话框逐一询问用户是否授权。

（4）处理权限申请回调

@Override
public void onRequestPermissionsResult(int requestCode,String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_PERMISSIONS_REQUEST_READ_CONTACTS: {
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // permission was granted.
            } else {
                // permission denied.
            }
            return;
        }
    }
}

对于权限的申请结果，首先验证requestCode定位到你的申请，然后验证grantResults对应于申请的结果，这里的数组对应于申请时的第二个权限字符串数组。如果你同时申请两个权限，那么grantResults的length就为2，分别记录你两个权限的申请结果。如果申请成功，就可以做你的事情了。

至此我们的权限申请步骤结束。不过还有个API值得提一下：

/** Should we show an explanation?*/
if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
        Manifest.permission.READ_CONTACTS)) 
    // Show an expanation to the user *asynchronously* -- don't block
    // this thread waiting for the user's response! After the user
    // sees the explanation, try again to request the permission.
}

主要用于给用户一个申请权限的解释，该方法只有在用户上一次已经拒绝过你的这个权限申请。也就是说，用户已经拒绝一次了，你又弹个授权框，你需要给用户一个解释，为什么要授权，则使用该方法。
这里写图片描述

譬如我自定义了上图的AlertDialog，当点击确认会重新申请权限，点击取消则放弃申请权限。

那么将上述几个步骤结合到一起就是：

if (ContextCompat.checkSelfPermission(thisActivity, Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {

    // Should we show an explanation?
    if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
            Manifest.permission.READ_CONTACTS)) {

        // Show an expanation.

    } else {

        // No explanation needed, we can request the permission.

        ActivityCompat.requestPermissions(thisActivity,
                new String[]{Manifest.permission.READ_CONTACTS},
                MY_PERMISSIONS_REQUEST_READ_CONTACTS);

        // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
        // app-defined int constant. The callback method gets the
        // result of the request.
    }
}

实例分析

public class MainActivity extends AppCompatActivity {
    public Button button;
    public final int PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE = 1;
    public AlertDialog mAlertDialog;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        button = (Button) findViewById(R.id.button);
        initAlertDialog();

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                        != PackageManager.PERMISSION_GRANTED) {
                    // Should we show an explanation?
                    if (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                            Manifest.permission.WRITE_EXTERNAL_STORAGE)) {

                        // Show an expanation.
                        mAlertDialog.show();

                    } else {
                        // No explanation needed, we can request the permission.
                        ActivityCompat.requestPermissions(MainActivity.this,
                                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                                PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
                    }
                } else {
                    createFolder();
                }
            }
        });
    }


    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE) {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                createFolder();
            } else {
                Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
            }
            return;
        }
    }

    private void initAlertDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("警告");
        builder.setMessage("创建文件夹需要取得访问SD卡的权限哦");
        builder.setPositiveButton("确认",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        ActivityCompat.requestPermissions(MainActivity.this,
                                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                                PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
                    }
                });
        builder.setNegativeButton("取消",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int whichButton) {
                        Toast.makeText(MainActivity.this, "权限拒绝", Toast.LENGTH_SHORT).show();
                    }
                });
        mAlertDialog = builder.create();
    }


    public final String PATH_SD = Environment.getExternalStorageDirectory().getAbsolutePath();
    public final String PATH_ROOT = PATH_SD + "/Permission_test/";
    public void createFolder() {
        File path_root = new File(PATH_ROOT);
        if (!path_root.exists()) {
            Boolean success = path_root.mkdir();
            if (success) {
                Toast.makeText(this, "创建成功", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "创建失败", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

PermissionsDispatcher

虽然权限处理并不复杂，但是需要编写很多重复的代码，所以目前也有很多库对用法进行了封装，这里我着重分析一个开源库—-PermissionsDispatcher。

（1）添加依赖
project.gradle

buildscript {
    dependencies {
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

app.gradle

apply plugin: 'android-apt'

dependencies {
    compile 'com.github.hotchemi:permissionsdispatcher:${latest.version}'
    apt 'com.github.hotchemi:permissionsdispatcher-processor:${latest.version}'
}

注：${latest.version} is 2.4.0

（2）在AndroidManifest文件中添加需要申请的权限。

（3）在需要运行时权限的Activity或Fragment中动态申请权限
提供以下几种注解:

@RuntimePermissions 标记需要运行时判断的类(用于动态生成代理类)           
@NeedsPermission 标记需要检查权限的方法 //createFolder()--->createFolderWithCheck(context)
@OnShowRationale 授权提示回调
@OnPermissionDenied 授权被拒绝回调
@OnNeverAskAgain 授权被拒绝并不再提醒回调

//NOTE: Annotated methods must not be private.

具体代码如下,关键代码都写了注释

@RuntimePermissions
public class SecondActivity extends AppCompatActivity {
    public Button button;

    public final String PATH_SD = Environment.getExternalStorageDirectory().getAbsolutePath();
    public final String PATH_ROOT = PATH_SD + "/Permission_test/";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        button = (Button) findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //@NeedsPermission方法+WithCheck
                SecondActivityPermissionsDispatcher.createFolderWithCheck(SecondActivity.this);
            }
        });
    }


    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        SecondActivityPermissionsDispatcher.onRequestPermissionsResult(this, requestCode, grantResults);//将回调交给代理类处理
    }

    @NeedsPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)//权限申请成功
    void createFolder() {
        File path_root = new File(PATH_ROOT);
        if (!path_root.exists()) {
            Boolean success = path_root.mkdir();
            if (success) {
                Toast.makeText(this, "创建成功", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(this, "创建失败", Toast.LENGTH_SHORT).show();
            }
        }
    }

    @OnShowRationale(Manifest.permission.WRITE_EXTERNAL_STORAGE)//申请前告知用户为什么需要该权限
    void showRationaleForCreateFolder(PermissionRequest request) {
        showRationaleDialog("创建文件夹需要取得访问SD卡的权限哦", request);
    }

    @OnPermissionDenied(Manifest.permission.WRITE_EXTERNAL_STORAGE)//被拒绝
    void onCreateFolderDenied() {
        Toast.makeText(this, "你拒绝了权限，该功能不可用", Toast.LENGTH_SHORT).show();
    }

    @OnNeverAskAgain(Manifest.permission.WRITE_EXTERNAL_STORAGE)//被拒绝并且勾选了不再提醒
    void onCreateFolderNeverAskAgain() {
        AskForPermission();
    }

    /**
     * 告知用户具体需要权限的原因
     * @param messageResId
     * @param request
     */
    private void showRationaleDialog(String messageResId, final PermissionRequest request) {
        new AlertDialog.Builder(this)
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(@NonNull DialogInterface dialog, int which) {
                        request.proceed();//请求权限
                    }
                })
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(@NonNull DialogInterface dialog, int which) {
                        request.cancel();//取消请求权限
                    }
                })
                .setCancelable(false)
                .setMessage(messageResId)
                .show();
    }

    /**
     * 被拒绝并且不再提醒,提示用户去设置界面重新打开权限
     */
    private void AskForPermission() {
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setTitle("当前应用缺少SD卡访问权限,请去设置界面打开");
        builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {

            }
        });
        builder.setPositiveButton("设置", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                intent.setData(Uri.parse("package:" + getPackageName())); // 根据包名打开对应的设置界面
                startActivity(intent);
            }
        });
        builder.create().show();
    }
}

这里写图片描述

原理：
PermissionsDispatcher使用的是Annotation Processor的方式，即编译时注解，编译时注解好处是不会在运行时影响执行效率。
PermissionsDispatcher会在编译时根据@RuntimePermissions 标记的类生成代理类（标记类类名+PermissionsDispatcher），把权限判断及请求过程的代码封装在代理类，代理类很简单，代码如下：

final class SecondActivityPermissionsDispatcher {
  private static final int REQUEST_CREATEFOLDER = 0;

  private static final String[] PERMISSION_CREATEFOLDER = new String[] {"android.permission.WRITE_EXTERNAL_STORAGE"};

  private SecondActivityPermissionsDispatcher() {
  }

  static void createFolderWithCheck(SecondActivity target) {
    if (PermissionUtils.hasSelfPermissions(target, PERMISSION_CREATEFOLDER)) {
      target.createFolder();
    } else {
      if (PermissionUtils.shouldShowRequestPermissionRationale(target, PERMISSION_CREATEFOLDER)) {
        target.showRationaleForCreateFolder(new CreateFolderPermissionRequest(target));
      } else {
        ActivityCompat.requestPermissions(target, PERMISSION_CREATEFOLDER, REQUEST_CREATEFOLDER);
      }
    }
  }

  static void onRequestPermissionsResult(SecondActivity target, int requestCode, int[] grantResults) {
    switch (requestCode) {
      case REQUEST_CREATEFOLDER:
      if (PermissionUtils.verifyPermissions(grantResults)) {
        target.createFolder();
      } else {
        if (!PermissionUtils.shouldShowRequestPermissionRationale(target, PERMISSION_CREATEFOLDER)) {
          target.onCreateFolderNeverAskAgain();
        } else {
          target.onCreateFolderDenied();
        }
      }
      break;
      default:
      break;
    }
  }

  private static final class CreateFolderPermissionRequest implements PermissionRequest {
    private final WeakReference<SecondActivity> weakTarget;

    private CreateFolderPermissionRequest(SecondActivity target) {
      this.weakTarget = new WeakReference<SecondActivity>(target);
    }

    @Override
    public void proceed() {
      SecondActivity target = weakTarget.get();
      if (target == null) return;
      ActivityCompat.requestPermissions(target, PERMISSION_CREATEFOLDER, REQUEST_CREATEFOLDER);
    }

    @Override
    public void cancel() {
      SecondActivity target = weakTarget.get();
      if (target == null) return;
      target.onCreateFolderDenied();
    }
  }
}

Demo下载地址

huaxun66

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android 6.0 运行时权限处理

6.0之前的权限模型在AndroidManifest中声明可能用到的所有权限用户在安装时,系统展示所有权限,用户安装即授予所有权限,取消则拒绝安装6.0新的运行时权限将权限分为一般权限（Normal Permissions）和危险权限（Dangerous Permission）两种,一般权限跟以前一样在AndroidManifest声明，危险权限需要开发者在代码中手动的动态申请动态申请权限
复制链接

扫一扫