老司机带你一文读懂Android运行时权限

 
老司机发车了,未到终点请勿下车. 嘟嘟嘟~~~
 运行时权限从Android 6.0版本开始的，如果你的项目中 targetSdkVersion/compileSdkVersion 大于等于23，那么你就必须要考虑动态权限了。

权限又分为普通权限和危险权限。
普通权限如下：

android.permission.ACCESS LOCATIONEXTRA_COMMANDS 

android.permission.ACCESS NETWORKSTATE 

android.permission.ACCESS NOTIFICATIONPOLICY 

android.permission.ACCESS WIFISTATE 

android.permission.ACCESS WIMAXSTATE 

android.permission.BLUETOOTH 

android.permission.BLUETOOTH_ADMIN 

android.permission.BROADCAST_STICKY 

android.permission.CHANGE NETWORKSTATE 

android.permission.CHANGE WIFIMULTICAST_STATE 

android.permission.CHANGE WIFISTATE 

android.permission.CHANGE WIMAXSTATE 

android.permission.DISABLE_KEYGUARD 

android.permission.EXPAND STATUSBAR 

android.permission.FLASHLIGHT 

android.permission.GET_ACCOUNTS 

android.permission.GET PACKAGESIZE 

android.permission.INTERNET 

android.permission.KILL BACKGROUNDPROCESSES 

android.permission.MODIFY AUDIOSETTINGS 

android.permission.NFC 

android.permission.READ SYNCSETTINGS 

android.permission.READ SYNCSTATS 

android.permission.RECEIVE BOOTCOMPLETED 

android.permission.REORDER_TASKS 

android.permission.REQUEST INSTALLPACKAGES 

android.permission.SET TIMEZONE 

android.permission.SET_WALLPAPER 

android.permission.SET WALLPAPERHINTS 

android.permission.SUBSCRIBED FEEDSREAD 

android.permission.TRANSMIT_IR 

android.permission.USE_FINGERPRINT 

android.permission.VIBRATE 

android.permission.WAKE_LOCK 

android.permission.WRITE SYNCSETTINGS 

com.android.alarm.permission.SET_ALARM 

com.android.launcher.permission.INSTALL_SHORTCUT 

com.android.launcher.permission.UNINSTALL_SHORTCUT

普通权限是当需要用到时，只需要在清单文件中声明就可。危险权限除了需要在清单文件中声明外，还需在代码中动态进行判断申请。

危险权限如下：

android.permission-group.CALENDAR   

android.permission.READ_CALENDAR

android.permission.WRITE_CALENDAR


android.permission-group.CAMERA 

android.permission.CAMERA


android.permission-group.CONTACTS   

android.permission.READ_CONTACTS

android.permission.WRITE_CONTACTS

android.permission.GET_ACCOUNTS


android.permission-group.LOCATION   

android.permission.ACCESS_FINE_LOCATION

android.permission.ACCESS_COARSE_LOCATION


android.permission-group.MICROPHONE 

android.permission.RECORD_AUDIO


android.permission-group.PHONE  

android.permission.READ_PHONE_STATE

android.permission.CALL_PHONE

android.permission.READ_CALL_LOG

android.permission.WRITE_CALL_LOG

com.android.voicemail.permission.ADD_VOICEMAIL

android.permission.USE_SIP

android.permission.PROCESS_OUTGOING_CALLS


android.permission-group.SENSORS    

android.permission.BODY_SENSORS


android.permission-group.SMS    

android.permission.SEND_SMS

android.permission.RECEIVE_SMS

android.permission.READ_SMS

android.permission.RECEIVE_WAP_PUSH

android.permission.RECEIVE_MMS

android.permission.READ_CELL_BROADCASTS


android.permission-group.STORAGE    

android.permission.READ_EXTERNAL_STORAGE

android.permission.WRITE_EXTERNAL_STORAGE

危险权限是按组划分的，每一组中当某一个权限被允许或者拒绝后，同一组的其他权限也相应的自动允许或者拒绝。

当targetSdkVersion/compileSdkVersion大于等于23时，我们用到危险权限时，应按照这样的逻辑去处理。先判断当前应用是否具有权限，如果没有就去申请，当用户允许或者拒绝后，会回调相应的方法，我们在回调中处理自己的逻辑。


申请单个权限

在Activity/Fragment中，判断是否具有权限的方法是 checkSelfPermission()，申请权限的方法是requestPermissions(),然后用户允许或者拒绝后会回调方法onRequestPermissionsResult()。
虽然Activity/Fragment提供了这些方法，如果我们用这些的话，要判断安卓版本是否大于等于23，代码如下： 

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){

       //动态请求权限


   }else{

       //直接去调用代码

   }

 
谷歌工程师当然考虑到了这些，于是给开发者提供了兼容包，在Activity/Fragment中用ContextCompat.checkSelfPermission()判断是否具有权限；
在Activity中用 ActivityCompat.requestPermissions()请求权限；
在Fragment中直接用 requestPermissions()请求权限，不要在前面加上ActivityCompat，否则会回调Fragment所在Activity的回调方法；
在Activity/Fragment中用户允许或者拒绝权限后会回调onRequestPermissionsResult()方法。

下面看一个平常的调用系统相机拍照功能的代码：

private void takePhoto() {

    Intent photoIn = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

    startActivityForResult(photoIn, TAKE_PHOTO_REQUEST);

}

 
如果我们项目targetSdkVersion/compileSdkVersion大于等于23,那么就需要动态申请权限了：

if (ContextCompat.checkSelfPermission(MySetupActivity.this,  Manifest.permission.CAMERA)!=  PackageManager.PERMISSION_GRANTED) {

    ActivityCompat.requestPermissions(MySetupActivity.this,new String[]{Manifest.permission.CAMERA}, 100);

} else {

    takePhoto();

}

 
先判断是否具有权限，如果有直接去执行相关代码，没有则去申请权限。
当用户点击允许或者拒绝权限时，会回调onRequestPermissionsResult方法，我们在此方法中进行处理：

@Override

public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {


    if (requestCode == 100) {//相机

        if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

            takePhoto();

        } else {

            // Permission Denied

            AlertDialog mDialog = new AlertDialog.Builder(MySetupActivity.this)

                    .setTitle("友好提醒")

                    .setMessage("您已拒绝权限,请开启权限！")

                    .setPositiveButton("开启", new DialogInterface.OnClickListener() {

                        @Override

                        public void onClick(DialogInterface dialog, int which) {

                            dialog.cancel();

                            ShowAppSetDetails.showInstalledAppDetails(MySetupActivity.this, "user.zhuku.com");

                            LogPrint.logILsj(TAG, "开启权限设置");

                        }

                    })

                    .setCancelable(true)

                    .create();

            mDialog.show();

        }

    }

    super.onRequestPermissionsResult(requestCode, permissions, grantResults);

}

当用户允许权限后我们直接执行相关代码，若拒绝则提示用户，弹窗提示是否需要开启权限。其中的

ShowAppSetDetails.showInstalledAppDetails(MySetupActivity.this, "user.zhuku.com");

是开启当前app信息设置界面的代码。

具体代码如下：

import android.content.Context;

import android.content.Intent;

import android.net.Uri;

import android.os.Build;

import android.provider.Settings;

public class ShowAppSetDetails {

    private static final String SCHEME = "package";

    /**

     * 调用系统InstalledAppDetails界面所需的Extra名称(用于Android 2.1及之前版本)

     */

    private static final String APP_PKG_NAME_21 = "com.android.settings.ApplicationPkgName";

    /**

     * 调用系统InstalledAppDetails界面所需的Extra名称(用于Android 2.2)

     */

    private static final String APP_PKG_NAME_22 = "pkg";

    /**

     * InstalledAppDetails所在包名

     */

    private static final String APP_DETAILS_PACKAGE_NAME = "com.android.settings";

    /**

     * InstalledAppDetails类名

     */

    private static final String APP_DETAILS_CLASS_NAME = "com.android.settings.InstalledAppDetails";


    /**

     * 调用系统InstalledAppDetails界面显示已安装应用程序的详细信息。 对于Android 2.3（Api Level

     * 9）以上，使用SDK提供的接口； 2.3以下，使用非公开的接口（查看InstalledAppDetails源码）。

     *

     * @param context

     * @param packageName 应用程序的包名

     */

    public static void showInstalledAppDetails(Context context, String packageName) {

        Intent intent = new Intent();

        final int apiLevel = Build.VERSION.SDK_INT;

        if (apiLevel >= 9) { // 2.3（ApiLevel 9）以上，使用SDK提供的接口

            intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);

            Uri uri = Uri.fromParts(SCHEME, packageName, null);

            intent.setData(uri);

        } else { // 2.3以下，使用非公开的接口（查看InstalledAppDetails源码）

            // 2.2和2.1中，InstalledAppDetails使用的APP_PKG_NAME不同。

            final String appPkgName = (apiLevel == 8 ? APP_PKG_NAME_22

                    : APP_PKG_NAME_21);

            intent.setAction(Intent.ACTION_VIEW);

            intent.setClassName(APP_DETAILS_PACKAGE_NAME,

                    APP_DETAILS_CLASS_NAME);

            intent.putExtra(appPkgName, packageName);

        }

        context.startActivity(intent);

    }

}

当app申请权限时，如果用户点击了“不再提醒”，则会直接回调拒绝权限，为此谷歌工程师提供了shouldShowRequestPermissionRationale()方法。兼容包中方法是ActivityCompat.shouldShowRequestPermissionRationale()，如果是在Fragment中使用请直接用shouldShowRequestPermissionRationale()。

ActivityCompat.shouldShowRequestPermissionRationale()方法返回值是boolean类型，当第一次申请权限时，此方法会返回false，如果用户点击“不再提醒”，则此方法会返回true。
 
详细代码如下：

if (ContextCompat.checkSelfPermission(MySetupActivity.this, Manifest.permission.CAMERA)

                            != PackageManager.PERMISSION_GRANTED) {

                        if (ActivityCompat.shouldShowRequestPermissionRationale(MySetupActivity.this, Manifest.permission.CAMERA)) {

                            //已经禁止提示了

                            mDialog = new AlertDialog.Builder(MySetupActivity.this)

                                    .setTitle("友好提醒")

                                    .setMessage("您已拒绝相机权限,此功能需要开启,是否开启?")

                                    .setPositiveButton("是", new DialogInterface.OnClickListener() {

                                        @Override

                                        public void onClick(DialogInterface dialog, int which) {

                                            dialog.cancel();

                                            ActivityCompat.requestPermissions(MySetupActivity.this,

                                                    new String[]{Manifest.permission.CAMERA},

                                                    100);

                                        }

                                    })

                                    .setNegativeButton("否", new DialogInterface.OnClickListener() {

                                        @Override

                                        public void onClick(DialogInterface dialog, int which) {

                                            dialog.cancel();

                                        }

                                    })

                                    .setCancelable(true)

                                    .create();

                            mDialog.show();

                        } else {

                            ActivityCompat.requestPermissions(MySetupActivity.this,

                                    new String[]{Manifest.permission.CAMERA},

                                    100);

                        }


                    } else {

                        takePhoto();

                    }

 
如果是在Fragment中，则代码如下：

if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.CAMERA)

                        != PackageManager.PERMISSION_GRANTED) {

                    if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {

                        //已经禁止提示了

                        mDialog = new AlertDialog.Builder(getContext())

                                .setTitle("友好提醒")

                                .setMessage("您已拒绝相机权限,此功能需要开启,是否开启?")

                                .setPositiveButton("是", new DialogInterface.OnClickListener() {

                                    @Override

                                    public void onClick(DialogInterface dialog, int which) {

                                        dialog.cancel();

                                        requestPermissions(new String[]{Manifest.permission.CAMERA},

                                                PERMISSIONS_CAMERA);

                                    }

                                })

                                .setNegativeButton("否", new DialogInterface.OnClickListener() {

                                    @Override

                                    public void onClick(DialogInterface dialog, int which) {

                                        dialog.cancel();

                                    }

                                })

                                .setCancelable(true)

                                .create();

                        mDialog.show();

                    } else {

                        requestPermissions(new String[]{Manifest.permission.CAMERA},

                                PERMISSIONS_CAMERA);

                    }


                } else {

                    selectPicFromCamera();

                }

特别要注意的是，如果在Fragment中请求权限，若在Activity中也重写了onRequestPermissionsResult(),则onRequestPermissionsResult()方法中一定要写

  super.onRequestPermissionsResult(requestCode, permissions, grantResults);

这句代码，若不写，则Activity不会分发执行Fragment中的权限回调方法。

因为Fragment中requestPermissions()源码如下：

public final void requestPermissions(@NonNull String[] permissions, int requestCode) {

    if (mHost == null) {

        throw new IllegalStateException("Fragment " + this + " not attached to Activity");

    }

    mHost.onRequestPermissionsFromFragment(this, permissions, requestCode);

}

其实在Fragment请求权限也是在它Activity中请求，只是把回调结果传递给了Fragment。


一次申请多个权限

例如需要申请的权限如下：

    /**

     * 需要进行检测的权限数组

     */

protected String[] permissionList = {

        Manifest.permission.ACCESS_FINE_LOCATION,

        Manifest.permission.ACCESS_COARSE_LOCATION,

        Manifest.permission.ACCESS_LOCATION_EXTRA_COMMANDS,

        Manifest.permission.READ_PHONE_STATE,

        Manifest.permission.CAMERA,

        Manifest.permission.WRITE_EXTERNAL_STORAGE,

        Manifest.permission.READ_EXTERNAL_STORAGE

};

 
我们要先判断每一个权限是否已经允许或者拒绝，当有某一个权限未被允许时，则申请未被允许的权限。

protected void onStart() {

    super.onStart();


    if (PermissionUtils.checkSelfPermission(SplashActivity.this, permissionList)) {

        PermissionUtils.checkPermissions(this, 0, permissionList);

    } else {

        //处理业务逻辑

    }


}

其中PermissionUtils类的代码如下：

import android.app.Activity;

import android.content.Context;

import android.content.pm.PackageManager;

import android.support.v4.app.ActivityCompat;

import android.support.v4.content.ContextCompat;


import java.util.ArrayList;

import java.util.List;


public class PermissionUtils {

    /**

     * 检查权限

     */

    public static void checkPermissions(Activity activity, int permissRequestCode, String... permissions) {

        List<String> needRequestPermissonList = findDeniedPermissions(activity, permissions);

        if (null != needRequestPermissonList

                && needRequestPermissonList.size() > 0) {

            ActivityCompat.requestPermissions(activity,

                    needRequestPermissonList.toArray(

                            new String[needRequestPermissonList.size()]),

                    permissRequestCode);

        }

    }


    /**

     * 获取权限中需要申请权限的列表

     */

    public static List<String> findDeniedPermissions(Activity activity, String[] permissions) {

        List<String> needRequestPermissonList = new ArrayList<String>();

        for (String perm : permissions) {

            if (ContextCompat.checkSelfPermission(activity,

                    perm) != PackageManager.PERMISSION_GRANTED) {

                needRequestPermissonList.add(perm);

            } else {

                if (ActivityCompat.shouldShowRequestPermissionRationale(

                        activity, perm)) {

                    needRequestPermissonList.add(perm);

                }

            }

        }

        return needRequestPermissonList;

    }


    public static boolean checkSelfPermission(Context context, String[] permissions) {

        for (String perm : permissions) {

            if (ContextCompat.checkSelfPermission(context, perm) != PackageManager.PERMISSION_GRANTED) {

                return true;

            }

        }

        return false;

    }


    public static boolean checkSelfResult(int[] grantResults) {

        for (int grantResult : grantResults) {

            if (grantResult != PackageManager.PERMISSION_GRANTED) {

                return false;

            }

        }

        return true;

    }

}

 
onRequestPermissionsResult回调方法中则这样处理：

@Override

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {

    super.onRequestPermissionsResult(requestCode, permissions, grantResults);


    if (requestCode == 0) {

        if (PermissionUtils.checkSelfResult(grantResults)) {

            // Permission Granted

            //处理业务逻辑

        } else {

            // Permission Denied


            if (null == mDialog)

                mDialog = new AlertDialog.Builder(SplashActivity.this)

                        .setTitle("友好提醒")

                        .setMessage("没有权限将不能更好的使用,请开启权限！")

                        .setPositiveButton("开启", new DialogInterface.OnClickListener() {

                            @Override

                            public void onClick(DialogInterface dialog, int which) {

                                dialog.cancel();

                                ShowAppSetDetails.showInstalledAppDetails(SplashActivity.this, "user.zhuku.com");

                                LogPrint.logILsj(TAG, "开启权限设置");

                            }

                        })

                        .setCancelable(false)

                        .create();


            if (!mDialog.isShowing()) {

                mDialog.show();

            }

        }

    }

}

 
如果项目需要在页面可见时进行权限申请，请放在onStart()方法中，不要写在onResume()中。
可以想象一下，如果写在onResume()中，当用户同意了权限，则无碍，若是点击拒绝，则会回调权限拒绝的方法，这时系统申请权限的对话框消失不见，会再次调用onResume()请求权限显示对话框，若是还拒绝，则会再次调用onResume()方法，一直处于死循环。
因为系统请求权限的对话框其实一个开启了一个Activity。部分源码如下：  
 

 public final void requestPermissions(@NonNull String[] permissions, int requestCode) {

    if (mHasCurrentPermissionsRequest) {

        Log.w(TAG, "Can reqeust only one set of permissions at a time");

        // Dispatch the callback with empty arrays which means a cancellation.

        onRequestPermissionsResult(requestCode, new String[0], new int[0]);

        return;

    }

    Intent intent = getPackageManager().buildRequestPermissionsIntent(permissions);

    startActivityForResult(REQUEST_PERMISSIONS_WHO_PREFIX, intent, requestCode, null);

    mHasCurrentPermissionsRequest = true;

}

至此,老司机本次发车已到终点,这一程体验,你还不会封装自己的运行时权限库吗?
 
 



微信公众号：IT大前端
关注可了解更多的大前端领域技术