Android6.0动态权限笔记

2017-04-03 本文已影响120人 NickelFox

参考：

提示用户授予或拒绝权限的系统对话框。

一. 权限说明：

1. 权限种类：

Android中权限分为正常权限（即，不会对用户隐私或设备操作造成很大风险的权限）和危险权限（即，可能影响用户隐私或设备正常操作的权限）：

正常权限涵盖应用需要访问其沙盒外部数据或资源，但对用户隐私或其他应用操作风险很小的区域。例如，设置时区的权限就是正常权限。如果应用声明其需要正常权限，系统会自动向应用授予该权限。如需当前正常权限的完整列表，请参阅正常权限。
危险权限涵盖应用需要涉及用户隐私信息的数据或资源，或者可能对用户存储的数据或其他应用的操作产生影响的区域。例如，能够读取用户的联系人属于危险权限。如果应用声明其需要危险权限，则用户必须明确向应用授予该权限。

危险权限和权限组：

危险权限和权限组

2. 权限的授予：

如果您的应用在其清单中列出正常权限，系统会自动授予这些权限。如果您的应用在其清单中列出危险权限，系统会要求用户明确授予这些权限。Android 发出请求的方式取决于系统版本：

如果设备运行的是 Android 6.0（API 级别 23）或更高版本，并且应用的 targetSdkVersion
是 23 或更高版本，则应用在运行时向用户请求权限。用户可随时调用权限，因此应用在每次运行时均需检查自身是否具备所需的权限。
如果设备运行的是 Android 5.1（API 级别 22）或更低版本，并且应用的 targetSdkVersion
是 22 或更低版本，则系统会在用户安装应用时要求用户授予权限。如果将新权限添加到更新的应用版本，系统会在用户更新应用时要求授予该权限。用户一旦安装应用，他们撤销权限的唯一方式是卸载应用。

二. 动态权限授予的几个重要的方法：

注意：在Activity里调用时Context和Activity参数可以忽略

int ContextCompat.checkSelfPermission (Context context, String permission)参数：(上下文, 需要判断的权限［如：Manifest.permission.READ_CONTACTS］)
该方法用来检测应用是否具有某权限，返回值是PackageManager.PERMISSION_GRANTED（已授权）或PackageManager.PERMISSION_GRANTED（未授权）
void requestPermissions (Activity, permissions, int requestCode)参数：（上下文，需要申请的权限的列表（String数组）[如：new String[]{Manifest.permission.READ_CONTACTS}]，自己定义的requestCode[如：REQUEST_READ_CONTACTS（自定义int值）]（主要是回调的时候用来判断授权种类））
该方法用来请求权限，请求过程会显示一个Dialog（不可自定义），无论用户是否确认授权都会调用回调方法onRequestPermissionsResult()
void onRequestPermissionsResult (int requestCode, String[] permissions, int[] grantResults)参数：（requestPermissions方法传过来的参数，要请求的权限列表，各权限的授权情况（与需要权限的数组对应））
该方法是用户请求权限之后的回调方法，用户可以在这里做判断进行需要的操作。
boolean shouldShowRequestPermissionRationale (Activity activity, String permission)参数：（上下文，需要判断的权限）
该方法判断一个权限是否被拒绝过，Android官方对此方法的解释是用该方法判断是否需要给用户进行为什么需要权限的提示。

三. 动态权限的申请

manifest中注册权限：（如需要访问通讯录权限）

<uses-permission android:name="android.permission.READ_CONTACTS" />

询问是否有该权限：

    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){
    switch (checkSelfPermission(Manifest.permission.READ_CONTACTS)){
            case PackageManager.PERMISSION_GRANTED:
                Log.i(TAG, "onCreate: Granted...");
                break;
            case PackageManager.PERMISSION_DENIED:
                Log.i(TAG, "onCreate: Denied...");
                Log.i(TAG, "onCreate: 是否被拒绝过:"+shouldShowRequestPermissionRationale(Manifest.permission.READ_CONTACTS));
                requestPermissions(new String[]{Manifest.permission.READ_CONTACTS},REQUEST_READ_CONTACTS);//请求权限
                break;
        }
    }

当没有该权限时请求授予权限：

requestPermissions(new String[]{Manifest.permission.READ_CONTACTS},REQUEST_READ_CONTACTS);

重载回调方法：

@Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        /*判断授权种类*/
        if(requestCode == REQUEST_READ_CONTACTS){
            /*授权成功*/
            if(grantResults.length>0 && grantResults[0]==PackageManager.PERMISSION_GRANTED){
                Log.i(TAG, "onRequestPermissionsResult: 权限请求通过");
            }
            /*授权失败*/
            else {
                Log.i(TAG, "onRequestPermissionsResult: 权限请求未通过");
            }
        }
    }

四. 源码：

package cn.foxnickel.androidpermission;

import android.Manifest;
import android.annotation.TargetApi;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

    public static int REQUEST_READ_CONTACTS=100;
    private final String TAG = getClass().getSimpleName();
    @TargetApi(Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        switch (checkSelfPermission(Manifest.permission.READ_CONTACTS)){
            case PackageManager.PERMISSION_GRANTED:
                Log.i(TAG, "onCreate: Granted...");
                break;
            case PackageManager.PERMISSION_DENIED:
                Log.i(TAG, "onCreate: Denied...");
                Log.i(TAG, "onCreate: 是否被拒绝过:"+shouldShowRequestPermissionRationale(Manifest.permission.READ_CONTACTS));
                requestPermissions(new String[]{Manifest.permission.READ_CONTACTS},REQUEST_READ_CONTACTS);
                break;
        }

    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        /*判断授权种类*/
        if(requestCode == REQUEST_READ_CONTACTS){
            /*授权成功*/
            if(grantResults.length>0 && grantResults[0]==PackageManager.PERMISSION_GRANTED){
                Log.i(TAG, "onRequestPermissionsResult: 权限请求通过");
            }
            /*授权失败*/
            else {
                Log.i(TAG, "onRequestPermissionsResult: 权限请求未通过");
            }
        }
    }
}

五. 封装（转自吴小龙博客）

BaseActivity：

public class BaseActivity extends AppCompatActivity {
    public static int REQUEST_PERMISSION = 100;
    public onPermissionCallbackListener onPermissionCallbackListener;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
     
    @TargetApi(M)
    public void requestRuntimePermission(String permission, onPermissionCallbackListener onPermissionCallbackListener) {
        this.onPermissionCallbackListener = onPermissionCallbackListener;
        switch (checkSelfPermission(permission)) {
            case PackageManager.PERMISSION_GRANTED:
                // 已有授权
                Log.i("wxl", "已有授权");
                if (this.onPermissionCallbackListener != null)
                    onPermissionCallbackListener.onGranted();
                break;
            case PackageManager.PERMISSION_DENIED:
                // 1、没有权限：尚未请求过权限；
                // 2、或者请求授权被拒绝，用shouldShowRequestPermissionRationale判断用户是否拒绝过，如果返回true，表示用户拒绝过，
                // 再次请求权限，将会出现“不再询问”，勾上“不再询问”，只能选择拒绝，再次进入，shouldShowRequestPermissionRationale始终false
                // 3、或者曾经授权过，但用户在设置中禁用权限
                Log.i("wxl", "是否拒绝过=" + shouldShowRequestPermissionRationale(permission));
                requestPermissions(new String[]{permission}, REQUEST_PERMISSION);
                break;
            default:
                break;
        }
    }
  
    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {        
        if (requestCode == REQUEST_PERMISSION) {
            if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // 授权请求被通过，读取通讯录
                Log.i("wxl", "onRequestPermissionsResult=授权请求被通过");
                if (onPermissionCallbackListener != null)
                    onPermissionCallbackListener.onGranted();
            } else {
                Log.i("wxl", "onRequestPermissionsResult=授权请求不被通过");
                if (onPermissionCallbackListener != null)
                    onPermissionCallbackListener.onDenied();
            }
        }
    }
}

/*这里新建了接口onPermissionCallbackListener，为了回调方便：*/
public interface onPermissionCallbackListener {
    void onGranted();
    void onDenied();
}

在需要使用到权限之前调用requestRuntimePermission方法，如通讯录权限：

requestRuntimePermission(READ_CONTACTS, new onPermissionCallbackListener() {
    @Override
    public void onGranted() {
        Log.i("wxl", "授权请求通过");
    }
    @Override
    public void onDenied() {
        Log.i("wxl", "授权请求拒绝");
    }
});

六. 总结

先询问是否已经得到授权，若已经授权，则直接进行操作，若未授权，则请求权限，然后在授权回调中进行操作。
可以在MainActivity中进行授权管理，也可以封装授权管理到BaseActivity
多个权限可以直接在String数组中加入（坏处：公用一个requestCode，不方便回调的判断），也可以重新询问是否授权。

七.补充

申请多个权限时可以先判断有没有该权限，如果没有就加到List中去，然后将List转换为数组，然后调用

ActivityCompat.requestPermissions(Context,String []permissions,PERMISSIONS_REQ);

申请全部权限。
代码：

List<String> permissionList = new ArrayList<>();//申请权限的List
        /*判断*/
        if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.M){
            if(checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION)!=PackageManager.PERMISSION_GRANTED){
                Log.i(TAG, "onCreate: finelocation denied");
                permissionList.add(Manifest.permission.ACCESS_FINE_LOCATION);
            }
            if(checkSelfPermission(Manifest.permission.READ_PHONE_STATE)!=PackageManager.PERMISSION_GRANTED){
                Log.i(TAG, "onCreate: phonestate denied");
                permissionList.add(Manifest.permission.READ_PHONE_STATE);
            }
            if(checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)!=PackageManager.PERMISSION_GRANTED){
                Log.i(TAG, "onCreate: write storage denied");
                permissionList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
            }
            if(checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION)!=PackageManager.PERMISSION_GRANTED){
                Log.i(TAG, "onCreate: coarse location denied");
                permissionList.add(Manifest.permission.ACCESS_COARSE_LOCATION);
            }
        /*申请*/
            if(!permissionList.isEmpty()){
                String permissions[] = permissionList.toArray(new String[permissionList.size()]);
                ActivityCompat.requestPermissions(this,permissions,PERMISSIONS_REQ);
            }else {
                requestLocation();
            }
        }else {
            requestLocation();
        }

另一种申请多个权限的写法（自己定义申请权限的函数）
- 调用requestPermission方法申请权限

/*判断SDK版本，6.0以上就申请权限，将要申请的权限传给requestPermission方法*/
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        requestPermission(Manifest.permission.SEND_SMS, Manifest.permission.READ_PHONE_STATE, Manifest.permission.CALL_PHONE, Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.ACCESS_COARSE_LOCATION);
}

requestPermission方法

@TargetApi(Build.VERSION_CODES.M)
    private void requestPermission(String... permissions) {
        List<String> permissionList = new ArrayList<>();//要申请的权限列表
        /**
         * 判断权限是否已经拥有，若未拥有则添加到List中
         */
        for (String permission : permissions) {
            switch (checkSelfPermission(permission)) {
                case PackageManager.PERMISSION_GRANTED:
                    Log.i(TAG, "onCreate: Granted...");
                    break;
                case PackageManager.PERMISSION_DENIED:
                    Log.i(TAG, "onCreate: Denied...");
                    permissionList.add(permission);
                    break;
            }
        }
        //申请未拥有的权限
        if (!permissionList.isEmpty()) {
            requestPermissions(permissionList.toArray(new String[permissionList.size()]),REQUEST_PERMISSIONS);
        }
    }