android 6.0 Permission权限兼容的封装

android 6.0 Permission权限兼容的封装

思路：

通过PermissionManager封装了检查权限，申请权限等方法，在Activity重写onRequestPermissionsResult(),调用PermissionManager中的方法，将参数传递到PermissionManager中，然后处理结果，通过getGrantedInfo()方法返回最终的结果。具体看代码：

在Activity的重写onRequestPermissionsResult()方法中，调用PermissionManager.getInstance(getApplicationContext()).onRequestPermissionsResult(requestCode, permissions, grantResults);

FirstActivity

public class FirstActivity extends AppCompatActivity {

    private Button record;
    private Button sd;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initPermission();

        initView();

        initListener();
    }

    private void initPermission() {
        //同时申请多个权限
//        PermissionManager.getInstance(getApplicationContext()).execute(this, Manifest.permission.RECORD_AUDIO, Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE);

        //请求单个，显示对话框的方式
        PermissionManager.getInstance(getApplicationContext()).executeDialog(this, Manifest.permission.RECORD_AUDIO,
                PermissionManager.getInstance(getApplicationContext()).new Builder(this)
                        .setMessage("应用需要获取您的录音权限，是否授权？")
                        .setTitle(getString(R.string.app_name))
                        .setIcon(R.mipmap.ic_launcher)
                        .setOk("OK")
                        .setCancel("CANCEL"));
    }

    private void initView() {
        record = (Button) findViewById(R.id.btn_record);
        sd = (Button) findViewById(R.id.btn_SD);
    }

    private void initListener() {
        record.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (PermissionManager.getInstance(getApplicationContext()).getGrantedInfo(Manifest.permission.RECORD_AUDIO) ) {
                    Toast.makeText(FirstActivity.this, "录音权限已经获取", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(FirstActivity.this, "你还没有获取录音权限", Toast.LENGTH_SHORT).show();
                }
            }
        });
        sd.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (PermissionManager.getInstance(getApplicationContext()).getGrantedInfo(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
                    Toast.makeText(FirstActivity.this, "SD权限已经获取", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(FirstActivity.this, "你还没有获取SD权限", Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

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

}

PermissionManager

public class PermissionManager {
    private static final int REQUEST_CODE = 0x0001;
    private HashMap<String, Integer> hashmap;

    private static class Holder {
        public static final PermissionManager MANAGER = new PermissionManager();
    }

    private static Context sContext;

    private PermissionManager() {
    }

    /**
     * 单例获取对象
     */
    public static PermissionManager getInstance(Context context) {
        sContext = context.getApplicationContext();
        return Holder.MANAGER;
    }

    /**
     * 执行请求多个权限
     */
    public void execute(@NonNull Activity activity, String... permissions) {
        List<String> lists = new ArrayList<>();
        for (String permission : permissions) {
            if (!isGranted(permission) && !isRevoked(permission)) {
                lists.add(permission);
            }
        }
        if (lists.size() == 0) return;
        String[] p = new String[lists.size()];
        requestPerissins(activity, lists.toArray(p));
    }

    /**
     * 执行请求一个权限
     */
    public void execute(@NonNull Activity activity, String permission) {
        if (!isGranted(permission) && !isRevoked(permission)) {
            requestPerissins(activity, permission);
        }
    }

    /**
     * 执行请求一个权限，可以带对话框的提示,使用建造者模式解耦
     */
    public void executeDialog(@NonNull Activity activity, String permission, Builder builder) {
        if (!isGranted(permission) && !isRevoked(permission)) {
            if (shouldShowRequestPermissionRationale(activity, permission, builder)) {
                return;
            }
            requestPerissins(activity, permission);
        }
    }

    /**
     * 判断是不是授权
     */
    private boolean isGranted(@NonNull String permission) {
        return isM() && ContextCompat.checkSelfPermission(sContext, permission) == PackageManager.PERMISSION_GRANTED;
    }

    /**
     * 判断是不是在包中申明
     */
    @TargetApi(Build.VERSION_CODES.M)
    private boolean isRevoked(@NonNull String permission) {
        return isM() && sContext.getPackageManager().isPermissionRevokedByPolicy(permission, sContext.getPackageName());
    }

    /**
     * 判断是不是M及以上版本
     */
    private boolean isM() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
    }

    /**
     * 请求的方法
     */
    private void requestPerissins(@NonNull Activity activity, String... permissions) {
        if (isM()) {
            ActivityCompat.requestPermissions(activity, permissions, REQUEST_CODE);
        }
    }

    /**
     * 是不是需要显示权限请求的关系，可以设置对话框。采用内部类Builder的建造者模式，解耦合方式
     * <p>
     * 这个方法可能不适合同时申请多个权限
     */
    public boolean shouldShowRequestPermissionRationale(@NonNull Activity activity, String permission, Builder builder) {
        if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
            builder.showDialog(permission);
            return true;
        }
        return false;
    }

    /**
     * 在activity中的onRequestPermissionsResult（）中调用，用于传递参数做一些逻辑判断
     */
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        if (requestCode == REQUEST_CODE && grantResults != null && grantResults.length > 0) {
            if (hashmap == null) {
                hashmap = new HashMap<>();
            } else {
                hashmap.clear();
            }
            for (int i = 0; i < permissions.length; i++) {
                hashmap.put(permissions[i], grantResults[i]);
            }
        }
    }

    /**
     * 请求权限后，通过返回值判断是不是授权
     */
    public boolean getGrantedInfo(String permission) {
        if (!isM()){
            return true;
        }
        return (hashmap != null && hashmap.get(permission) != null && hashmap.get(permission) == PackageManager.PERMISSION_GRANTED) || isGranted(permission);
    }

    /**
     * 内部类，通过建造者模式传递数据，显示对话框
     */
    public class Builder {
        private String message;
        private String title;
        private int icon;
        private String ok;
        private String cancel;
        private Activity activity;

        public Builder(Activity activity) {
            this.activity = activity;
        }

        public String getMessage() {
            return message;
        }

        public Builder setMessage(String message) {
            this.message = message;
            return this;
        }

        public String getTitle() {
            return title;
        }

        public Builder setTitle(String title) {
            this.title = title;
            return this;
        }

        public int getIcon() {
            return icon;
        }

        public Builder setIcon(int icon) {
            this.icon = icon;
            return this;
        }

        public String getOk() {
            return ok;
        }

        public Builder setOk(String ok) {
            this.ok = ok;
            return this;
        }

        public String getCancel() {
            return cancel;
        }

        public Builder setCancel(String cancel) {
            this.cancel = cancel;
            return this;
        }

        public void showDialog(final String p) {
            AlertDialog.Builder builder = new AlertDialog.Builder(activity);
            builder.setMessage(message)
                    .setIcon(icon)
                    .setTitle(title)
                    .setPositiveButton(ok, new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            requestPerissins(activity, p);
                        }
                    }).setNegativeButton(cancel, null)
                    .create().show();
        }
    }

}

PermissionManager库在Github项目地址