android 开发 实现多个动态权限的方法(并且兼容6.0以下的版本权限授权)

android开发权限授权因为版本的不同有不同的授权方式，6.0以下的版本使用的是在注册表中添加权限的静态授权（这种授权权限提示只会出现在app安装的时候），而6.0以上(包含6.0)就需要动态授权的方式。

 

实现思维：

1.就算是动态授权依然需要在AndroidManifest.xml里添加静态权限。

2.动态权限的数组写法与KEY。

3.判断系统版本。

4.判断权限是否获取

5.授权完成后的回调方法执行

 

 

1.在AndroidManifest.xml里添加静态权限。

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.lenovo.mydemoapp">
    <!--此处添加静态权限-->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.CAMERA"/>
    <application
        android:name=".myAppCompatActivity.MyApplication"
        android:allowBackup="true"  以下略....

 

2.动态权限的数组写法与KEY。

//因为本人是写一个头像设置的功能，所以需要在进入相机拍照或者相册选择图像中做区分。所以写了一个KEY来处理不同的Button
    private static final int Permissions_GALLERY_KEY = 1;
    private static final int Permissions_CAMERA_KEY = 2;
    //需要的权限 注意请不要将数组写成 private String mPermissions[] = {"Manifest.permission.WRITE_EXTERNAL_STORAGE"};
    //这样加了引号的是错误的，我犯过这种低级错误
    private String mPermissions[] = {Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.CAMERA};

3.判断系统版本。(在第7行代码，M=23API)

4.判断权限是否获取 (在第九行，判断一个权限是否已经允许授权，如果没有授权就会将单个未授权的权限在第10行中添加到List里面)

public void setPermissions(int mPermissions_KEY){
        /*
        要添加List原因是想判断数组里如果有个别已经授权的权限，就不需要再添加到List中。添加到List中的权限后续将转成数组去申请权限
         */
        List<String> permissionsList = new ArrayList<>();
        //判断系统版本
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            for (int i = 0; i < mPermissions.length; i++) {
                //判断一个权限是否已经允许授权，如果没有授权就会将单个未授权的权限添加到List里面
                if (ContextCompat.checkSelfPermission(this.getApplicationContext(), mPermissions[i]) != PackageManager.PERMISSION_GRANTED) {
                    permissionsList.add(mPermissions[i]);
                }
            }
            //判断List不是空的，如果有内容就运行获取权限
            if (!permissionsList.isEmpty()) {
                String [] permissions = permissionsList.toArray(new String[permissionsList.size()]);
                for (int j=0;j<permissions.length;j++){
                    Log.e(TAG,permissions[j]);
                }
                Log.e(TAG,"需要授权的权限有："+permissions.length+"条");
                //执行授权的代码。此处执行后会弹窗授权
                ActivityCompat.requestPermissions(this, permissions, mPermissions_KEY);
            } else { //如果是空的说明全部权限都已经授权了，就不授权了,直接执行进入相机或者图库
                switch (mPermissions_KEY) {
                    case Permissions_CAMERA_KEY:
                        enterCamera();
                        break;
                    case Permissions_GALLERY_KEY:
                        enterGallery();
                        break;
                    default:
                        break;
                }
            }
        }else {
            Toast.makeText(getBaseContext(), "6.0以下的版本无需授权", Toast.LENGTH_SHORT).show();
            Log.e(TAG,"6.0以下的版本无需授权");
            switch (mPermissions_KEY) {
                case Permissions_CAMERA_KEY:
                    enterCamera();
                    break;
                case Permissions_GALLERY_KEY:
                    enterGallery();
                    break;
                default:
                    break;
            }
        }
    }

以上setPermissions方法只需要添加到你想要添加的Button的点击事件中就行了

5.授权完成后的回调方法执行(此方法是授权类库中自带的方法，请一定要重写这个方法，在第一时间运行授权后你需要运行的内容)

 /*
    授权完成后马上会运行的回调方法，我们在此处写入首次授权完成后，要运行的内容
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == Permissions_CAMERA_KEY) {
            if (grantResults.length > 0) { //安全写法，如果小于0，肯定会出错了
                for (int i = 0; i < grantResults.length; i++) {
                    if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                        Log.e(TAG, "全部权限都成功授权进入相机");
                        enterCamera();
                    } else {
                        finish();
                        Toast.makeText(getBaseContext(), "授权失败", Toast.LENGTH_SHORT).show();
                        Log.e(TAG, "相机授权失败");
                    }
                }
            }
        } else if (requestCode == Permissions_GALLERY_KEY) {
            if (requestCode == Permissions_GALLERY_KEY) {
                if (grantResults.length > 0) {
                    for (int i = 0; i < grantResults.length; i++) {
                        if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                            Log.e(TAG, "全部权限都成功授权进入相册");
                            enterGallery();
                        } else {
                            finish();
                            Toast.makeText(getBaseContext(), "授权失败", Toast.LENGTH_SHORT).show();
                            Log.e(TAG, "相册授权失败");
                        }
                    }
                }
            }
        }
    }

 

 

 

 

 

 

另外附危险权限清单(一般情况下只需要关注下面的危险权限一共9组24个，正常权限系统会自动添加，不需要另外授权)

 

危险权限组和权限：

每个组申请一个权限，这个组的其他权限也一并申请了。

所有危险的 Android 系统权限都属于权限组。如果设备运行的是 Android 6.0（API 级别 23），并且应用的 targetSdkVersion 是 23 或更高版本，则当用户请求危险权限时系统会发生以下行为：

• 如果应用请求其清单中列出的危险权限，而应用目前在权限组中没有任何权限，则系统会向用户显示一个对话框，描述应用要访问的权限组。对话框不描述该组内的具体权限。例如，如果应用请求READ_CONTACTS 权限，系统对话框只说明该应用需要访问设备的联系信息。如果用户批准，系统将向应用授予其请求的权限。
• 如果应用请求其清单中列出的危险权限，而应用在同一权限组中已有另一项危险权限，则系统会立即授予该权限，而无需与用户进行任何交互。例如，如果某应用已经请求并且被授予了 READ_CONTACTS 权限，然后它又请求 WRITE_CONTACTS，系统将立即授予该权限。

任何权限都可属于一个权限组，包括正常权限和应用定义的权限。但权限组仅当权限危险时才影响用户体验。可以忽略正常权限的权限组。

如果设备运行的是 Android 5.1（API 级别 22）或更低版本，并且应用的 targetSdkVersion 是 22 或更低版本，则系统会在安装时要求用户授予权限。再次强调，系统只告诉用户应用需要的权限组，而不告知具体权限。

具体的危险权限组和权限如下：

 

CALENDAR  日历

• READ_CALENDAR  读日历

• WRITE_CALENDAR  写日历

 

 

CAMERA  相机

• CAMERA

 

CONTACTS  通讯录

• READ_CONTACTS  读通讯录
• WRITE_CONTACTS  写通讯录
• GET_ACCOUNTS 得到账号

 

LOCATION  位置

• ACCESS_FINE_LOCATION  访问精准位置
• ACCESS_COARSE_LOCATION  访问大概位置

 

MICROPHONE  麦克风

• RECORD_AUDIO  录制音频

 

PHONE   电话

• READ_PHONE_STATE   读电话状态
• CALL_PHONE  打电话
• READ_CALL_LOG   读通话记录
• WRITE_CALL_LOG   写通话记录
• ADD_VOICEMAIL   添加语音信箱
• USE_SIP  使用SIP服务
• PROCESS_OUTGOING_CALLS  处理传出呼叫

 

SENSORS  传感器

• BODY_SENSORS  物体传感器（一般指距离，光感，重力等等这些感应接收器）

 

SMS  信息

• SEND_SMS  发送信息
• RECEIVE_SMS  接收信息
• READ_SMS  读信息
• RECEIVE_WAP_PUSH  接收WAP推送
• RECEIVE_MMS  接收彩信

 

STORAGE  存储

• READ_EXTERNAL_STORAGE  读外部存储
• WRITE_EXTERNAL_STORAGE   写外部存储

 

知识拓展（自写一个动态权限申请工具class）

工具class：

基本思路：

1.先导入1.context 2.需要授权的数组 3.new接口class的实现。

2.在上面3个数据准备后，在执行授权方法privilege();

package net.yt.yuncare.widgets;

import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.util.Log;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.List;
/*
content:动态权限申请的class
time:2018-7-20 20：57
build:帅哥
用法说明：
1.在需要授权的activity里,重写onRequestPermissionsResult 授权回调,
并且将里面的值添加到DynamicPermissions.I().onRequestPermissionsResult()方法里
 */
public class DynamicPermissions {
    private static DynamicPermissions dynamicPermissions;
    private String TAG = "DynamicPermissions";
    public PermissionsTo mPermissionsTo;
    private int KEY = 101;
    private List<String> mList = new ArrayList<>();
    public Context mContext;
    private String [] mPermissionsGroup;
    private DynamicPermissions(){

    }

    //实现单例模式
    public static DynamicPermissions I(){
        if(dynamicPermissions == null){
            dynamicPermissions = new DynamicPermissions();

        }
        return dynamicPermissions;
    }
    //导入数据
    public void setInitData(Context context,String [] permissionsGroup,PermissionsTo permissionsTo){
        this.mContext = context;
        this.mPermissionsGroup = permissionsGroup;
        this.mPermissionsTo = permissionsTo;
        privilege();
    }

    //授权
    public void privilege(){
        mList.clear();
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){
            for(int i=0;i<mPermissionsGroup.length;i++){
                if (ContextCompat.checkSelfPermission(mContext, mPermissionsGroup[i]) != PackageManager.PERMISSION_GRANTED) {
                    Log.e(TAG, "已经添加权限有："+mPermissionsGroup[i].toString());
                    mList.add(mPermissionsGroup[i]);
                }
            }

            if (!mList.isEmpty()) {
                String[] permissions = mList.toArray(new String[mList.size()]);
                ActivityCompat.requestPermissions((Activity) mContext, permissions, KEY);
                Log.e(TAG, "privilege: 正在授权");
            } else {
                Log.e(TAG, "privilege: 已经授权,不需要授权");
                if(mPermissionsTo!=null){
                    this.mPermissionsTo.hasAuthorizeinit(mContext);
                }

            }

        }else {
            Log.e(TAG, "privilege:6.0以下的版本无需授权");
            if(mPermissionsTo!=null){
                this.mPermissionsTo.noAuthorizeinit(mContext);
            }
        }

    }

    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults){
        if(requestCode == KEY){
            int j = 0;
            if (grantResults.length > 0) {//安全写法，如果小于0，肯定会出错了
                for (int i = 0; i < grantResults.length; i++) {
                    if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                        Log.e(TAG, "onRequestPermissionsResult：授权成功"+permissions[i].toString());
                        j++;
                    } else {
                        Toast.makeText(mContext, "授权失败", Toast.LENGTH_SHORT).show();
                        Log.e(TAG, "onRequestPermissionsResult：授权失败"+permissions[i].toString());
                        ((Activity)mContext).finish();
                    }
                }
            }
            if (j == grantResults.length){
                Log.e(TAG, "onRequestPermissionsResult：全部权限都授权成功");
                if(mPermissionsTo!=null) {
                    this.mPermissionsTo.authorizeinitFinish(mContext);
                }
            }

        }

    }
    //创建回调接口，在1.版本低不需要动态授权 2.已经授权过 3.授权完成后  这3个地方的后续运行逻辑进行统一的接口调出
    public interface PermissionsTo{
        void hasAuthorizeinit(Context context);
        void noAuthorizeinit(Context context);
        void authorizeinitFinish(Context context);

    }
}

 

使用方式：

public void initData() {
String [] mPermission = new String[]{Manifest.permission.ACCESS_COARSE_LOCATION};
DynamicPermissions.I().setInitData(Demo.this, mPermission, new DynamicPermissions.PermissionsTo() {
            @Override
            public void hasAuthorizeinit(Context context) {
                Toast.makeText(context,"已经授权",Toast.LENGTH_SHORT).show();

            }

            @Override
            public void noAuthorizeinit(Context context) {
                Toast.makeText(context,"不需要授权",Toast.LENGTH_SHORT).show();

            }

            @Override
            public void authorizeinitFinish(Context context) {
                Toast.makeText(context,"授权完成",Toast.LENGTH_SHORT).show();

            }
        });
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
     DynamicPermissions.I().onRequestPermissionsResult(requestCode,permissions,grantResults);
    }