老司机带你一文读懂Android运行时权限|环信开发者进阶之路

运行时权限从Android 6.0版本开始的，如果你的项目中 targetSdkVersion/compileSdkVersion 大于等于23，那么你就必须要考虑动态权限了。

摄图网_500609322_wx.jpg

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

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大前端
环信稿酬计划详情http://www.imgeek.org/article/825308713

产品

案例

文档

IM即时通讯云

即时推送

MQTT消息云

客服云

客服机器人

部署方式

产品方案

核心优势

行业应用

开发文档

下载中心

生态伙伴

老司机带你一文读懂Android运行时权限|环信开发者进阶之路

申请单个权限

一次申请多个权限

相关推荐

周排行

申请试用

提交后工作人员会尽快与您联系进行功能演示

技术咨询已转移到管理后台，请先登录

注册享福利、赢好礼