轻量级Android6.0动态权限解决方案

最新推荐文章于 2024-04-27 13:43:14 发布

旅行者40

最新推荐文章于 2024-04-27 13:43:14 发布

阅读量993

点赞数

分类专栏： Android应用开发文章标签： android

本文链接：https://blog.csdn.net/zephyr_g/article/details/75529215

版权

Android应用开发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在手机系统中，权限是一个非常重要的机制，它赋予了一个应用的权限范围，比如打电话的应用必须有电话权限，拍照的应用比较有拍照的权限。在Android6.0之前，Android采用的是静态权限机制，也就是我们将需要的权限(可能并不需要）全都写在manifest中，然后Android应用在安装的时候就必须授予这些权限。这种机制就产生了一个问题，一个打电话的应用可能也申请了拍照的权限，一个拍照的应用申请了读取短信内容的权限。这种现象对用户是非常不利的，一方面用户并不清楚应用到底需要什么权限，没有直观上的感觉；另一方面，这种一包揽的机制，导致应用申请了很多不需要的权限，其中一部分涉及到了用户的隐私，造成了用户隐私的泄漏。比如我们使用一款相机APP拍照的时候，刚打开相机，自己的短信内容就被上传到服务器了。。。
后来，Google意识到了这个问题，引入了动态权限机制。动态权限机制将权限分成了两部分，一部分是一般权限(Normal Permissons)，一般不涉及用户的隐私，比如ACCESS_NETWORK_STATE，ACCESS_WIFI_STATE等；一部分是危险权限(Dangerous Permissons)，这些权限涉及到了用户的隐私或其它比较重要的信息，比如WRITE_CONTACTS， CAMERA等。在处理权限时，首先我们还要像以前一样将需要的权限都写到manifest中；另一方面，针对危险权限我们应该在需要这些权限之前申请它们，系统在收到申请后，会提示用户是什么权限，请求用户授予或者拒绝。需要注意的是，Android6.0引入的权限组(permission group)的概念，对于在同一个权限组的权限，我们只要申请其中一个，就会将这个组的所有权限都授予给我们。

权限列表

Normal Permissions

ACCESS_LOCATION_EXTRA_COMMANDS
ACCESS_NETWORK_STATE
ACCESS_NOTIFICATION_POLICY
ACCESS_WIFI_STATE
BLUETOOTH
BLUETOOTH_ADMIN
BROADCAST_STICKY
CHANGE_NETWORK_STATE
CHANGE_WIFI_MULTICAST_STATE
CHANGE_WIFI_STATE
DISABLE_KEYGUARD
EXPAND_STATUS_BAR
GET_PACKAGE_SIZE
INSTALL_SHORTCUT
INTERNET
KILL_BACKGROUND_PROCESSES
MODIFY_AUDIO_SETTINGS
NFC
READ_SYNC_SETTINGS
READ_SYNC_STATS
RECEIVE_BOOT_COMPLETED
REORDER_TASKS
REQUEST_INSTALL_PACKAGES
SET_ALARM
SET_TIME_ZONE
SET_WALLPAPER
SET_WALLPAPER_HINTS
TRANSMIT_IR
UNINSTALL_SHORTCUT
USE_FINGERPRINT
VIBRATE
WAKE_LOCK
WRITE_SYNC_SETTINGS

Dangerous Permissions:

group:android.permission-group.CONTACTS
  permission:android.permission.WRITE_CONTACTS
  permission:android.permission.GET_ACCOUNTS
  permission:android.permission.READ_CONTACTS

group:android.permission-group.PHONE
  permission:android.permission.READ_CALL_LOG
  permission:android.permission.READ_PHONE_STATE
  permission:android.permission.CALL_PHONE
  permission:android.permission.WRITE_CALL_LOG
  permission:android.permission.USE_SIP
  permission:android.permission.PROCESS_OUTGOING_CALLS
  permission:com.android.voicemail.permission.ADD_VOICEMAIL

group:android.permission-group.CALENDAR
  permission:android.permission.READ_CALENDAR
  permission:android.permission.WRITE_CALENDAR

group:android.permission-group.CAMERA
  permission:android.permission.CAMERA

group:android.permission-group.SENSORS
  permission:android.permission.BODY_SENSORS

group:android.permission-group.LOCATION
  permission:android.permission.ACCESS_FINE_LOCATION
  permission:android.permission.ACCESS_COARSE_LOCATION

group:android.permission-group.STORAGE
  permission:android.permission.READ_EXTERNAL_STORAGE
  permission:android.permission.WRITE_EXTERNAL_STORAGE

group:android.permission-group.MICROPHONE
  permission:android.permission.RECORD_AUDIO

group:android.permission-group.SMS
  permission:android.permission.READ_SMS
  permission:android.permission.RECEIVE_WAP_PUSH
  permission:android.permission.RECEIVE_MMS
  permission:android.permission.RECEIVE_SMS
  permission:android.permission.SEND_SMS
  permission:android.permission.READ_CELL_BROADCASTS

动态权限申请过程

由于动态权限机制是在Android6.0引入的，所有为了适配系统，Google给我们提供了ActivityCompat和ContextCompat，在这两个类的权限相关的方法中都为我们做了系统版本适配，所以就不需要我们自己适配了。

动态权限的申请一般分成两种情况，
第一种情况是没有点击”不在显示”按钮，这个时候申请流程是这样的：
检查权限(checkSelfPermission)，检查通过则执行相关业务代码，检查不通过则申请权限(requestPermissions)，系统收到申请后提示用户授予权限，然后回调请求权限结果方法(onRequestPermissionsResult)，在这个回调中如果用户授予了申请的权限，则执行相关业务代码，拒绝了则提示用户手动设置权限，否则应用无法正常运行。
第二种情况是在系统在提示用户授予权限的时候，点击了“不在显示”按钮，这个情况下，用户只能选择拒绝,并且以后启动应用的时候系统会直接调用onRequestPermissionsResult方法，并且传递权限申请结果为拒绝(PackageManager.PERMISSION_DENIED)，这个时候我们应该提醒用户手动设置权限，否则应用无法正常运行。实际上，在国内很多系统已经将“不在显示”按钮去掉了(比如小米系统)，这个时候如果我们拒绝了权限，当我们下次打开应用的时候，系统也是会直接执行onRequestPermissionsResult，并且回调结果为拒绝(PackageManager.PERMISSION_DENIED),所以说这个时候应该等同于点击了“不在显示”按钮了，需要我们提示用户手动授予权限。

动态权限申请代码实现

动态权限的申请虽然代码量不大，也没什么难度，但是由于代码比较分散，而且套路都是一样的，有比较多的重复代码，所以我对权限申请进行了简单的封装。
代码量很少，只有两个类IRequestPermissionCallback和ZPermissionHelper。
其中IRequestPermissionCallback是一个回调接口，需要申请权限的activity需要实现这个接口，并在相应的接口中实现自己的业务操作。代码如下；

public interface IRequestPermissionCallback { // 权限授予失败的回调默认为调起系统权限设置activity

    /**
     * 检查权限时，已经授予了所有权限
     */
    void onPermissionGranted();

    /**
     * 权限授予成功回调
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    void onAfterPermissionGranted(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults);


    /**
     * 权限被拒绝后调起(如果选择不再显示，则不会被调用)
     * @param activity
     * @param permission
     */
    void onShouldShowRequestPermissionRationale(@NonNull Activity activity, @NonNull String permission);
}

在这个接口中，我设计了三个方法，
onPermissionGranted：当我们最开始的时候检测权限的时候，如果通过了，我们就可以执行自己的业务代码了，所以把这个抽象出来，就可以有不同的代码实现了。
onAfterPermissionGranted：当我们申请权限，并被成功授予权限后的回调。
本来还有一个方法是当我们申请权限，被拒绝后的回调，但是我后来直接把它写成跳转到权限设置界面了。
onShouldShowRequestPermissionRationale：当权限申请第一次被拒绝以后，再次申请的时候onShouldShowRequestPermissionRationale就会返回ture，这个时候我们可以加一个Toast，提醒用户权限的重要性。

以上是回调接口设计，ZPermissionHelper则封装了权限申请的主要代码，也很简单，代码如下;

public class ZPermissionHelper {

    private Activity mContext;

    final IRequestPermissionCallback mCallback;

    public static final int ACTION_APPLICATION_DETAILS_SETTINGS = 0X101;

    public static final String PACKAGE_URL_SCHEME = "package:";//权限方案

    private int PERMISSION_GRANTED = PackageManager.PERMISSION_GRANTED;

    private int PERMISSION_DENIED = PackageManager.PERMISSION_DENIED;

    private String[] REQUEST_PERMISSIONS;

    private int REQUEST_PERMISSIONS_TAG;

    public ZPermissionHelper(Activity mContext, String[] REQUEST_PERMISSIONS, int requestPermissionTag,
                             IRequestPermissionCallback callback) {
        this.mContext = mContext;
        this.REQUEST_PERMISSIONS = REQUEST_PERMISSIONS;
        REQUEST_PERMISSIONS_TAG = requestPermissionTag;
        mCallback = callback;
    }

    /**
     * 检查权限
     */
    public void checkPermissions() {
//        if (!isCheckPermission) return;
        if (checkSelfPermisson()) {
            // 权限被授予
            mCallback.onPermissionGranted();
        }
    }

    private boolean checkSelfPermisson() {
        for (int i = 0; i < REQUEST_PERMISSIONS.length; i++) {
            String permission = REQUEST_PERMISSIONS[i];
            if (isLeakPermission(permission)) {
                ActivityCompat.requestPermissions(mContext, REQUEST_PERMISSIONS, REQUEST_PERMISSIONS_TAG);
                return false;
            }
        }

        return true;
    }

    /**
     * 检查具体权限缺失
     * @param permission
     * @return
     */
    private boolean isLeakPermission(String permission) {
        int selfPermission = ActivityCompat.checkSelfPermission(mContext, permission);
        if (selfPermission == PERMISSION_DENIED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(mContext, permission)) {
                // 显示这个权限的重要性，给用户提示
                mCallback.onShouldShowRequestPermissionRationale( mContext, permission);
            }
            return true;
        }
        return false;
    }

    /**
     * 权限请求结果回调
     * @param requestCode
     * @param permissions
     * @param grantResults
     */
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == REQUEST_PERMISSIONS_TAG) {
            if (permissions.length > 0 && hasAllPermissionGranted(grantResults)) {
                // 授予权限成功
                mCallback.onAfterPermissionGranted(requestCode, permissions, grantResults);
            } else {
                showMissingPermissionDialog();
                // 授予权限失败
            }
        }
    }

    /**
     * 申请的权限是否全部授予
     * @param grantResults
     * @return
     */
    public boolean hasAllPermissionGranted(int[] grantResults) {
        for (int grantResult : grantResults) {
            if (grantResult == PERMISSION_DENIED) {
                return false;
            }
        }
        return true;
    }

    /**
     * 显示提示对话框
     */
    public void showMissingPermissionDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        builder.setTitle("帮助");//提示帮助
        builder.setMessage("当前应用缺少必要权限。\n请点击\"设置\"-\"权限\"-打开所需权限。\n最后点击两次后退按钮，即可返回。");
        builder.setPositiveButton("设置", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                startPermissionGrantActivity();
            }
        });
        builder.setNegativeButton("退出", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                // 退出应用
                mContext.finish();
            }
        });
        builder.setCancelable(false);
        builder.show();
    }

    /**
     * 调起系统权限控制界面
     */
    private void startPermissionGrantActivity() {
        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        intent.setData(Uri.parse(PACKAGE_URL_SCHEME + mContext.getPackageName()));
//        mContext.startActivity(intent);
        mContext.startActivityForResult(intent, ACTION_APPLICATION_DETAILS_SETTINGS);
    }

}

首先是构造函数；

public ZPermissionHelper(Activity mContext, String[] REQUEST_PERMISSIONS, int requestPermissionTag,
                             IRequestPermissionCallback callback) {
        this.mContext = mContext;
        this.REQUEST_PERMISSIONS = REQUEST_PERMISSIONS;
        REQUEST_PERMISSIONS_TAG = requestPermissionTag;
        mCallback = callback;
    }

构造函数中接收activity的实例，REQUEST_PERMISSIONS是需要申请权限的String数组，requestPermissionTag是申请权限时用到的requestCode，用于在onRequestPermissionsResult中接收回调结果。
然后是检查权限；

 /**
     * 检查权限
     */
    public void checkPermissions() {
//        if (!isCheckPermission) return;
        if (checkSelfPermisson()) {
            // 权限被授予
            mCallback.onPermissionGranted();
        }
    }

    private boolean checkSelfPermisson() {
        for (int i = 0; i < REQUEST_PERMISSIONS.length; i++) {
            String permission = REQUEST_PERMISSIONS[i];
            if (isLeakPermission(permission)) {
                ActivityCompat.requestPermissions(mContext, REQUEST_PERMISSIONS, REQUEST_PERMISSIONS_TAG);
                return false;
            }
        }

        return true;
    }
/**
     * 检查具体权限缺失
     * @param permission
     * @return
     */
    private boolean isLeakPermission(String permission) {
        int selfPermission = ActivityCompat.checkSelfPermission(mContext, permission);
        if (selfPermission == PERMISSION_DENIED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(mContext, permission)) {
                // 显示这个权限的重要性，给用户提示
                mCallback.onShouldShowRequestPermissionRationale( mContext, permission);
            }
            return true;
        }
        return false;
    }

遍历权限数组，检查每个权限是否被授予，如果权限检查通过了，就直接回调onPermissionGranted方法，实现业务逻辑；只要有一个权限没有被授予就立马停止遍历，然后申请权限。
最后处理申请回调方法：

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == REQUEST_PERMISSIONS_TAG) {
            if (permissions.length > 0 && hasAllPermissionGranted(grantResults)) {
                // 授予权限成功
                mCallback.onAfterPermissionGranted(requestCode, permissions, grantResults);
            } else {
                showMissingPermissionDialog();
                // 授予权限失败
            }
        }
    }

这个方法是我们自己的onRequestPermissionsResult，在activity的onRequestPermissionsResult中调用，将处理代码封装到我们的ZPermissionHelper中。
在这里首先判断requestCode, hasAllPermissionGranted(grantResults)判断申请的权限是否被全部授予，

  public boolean hasAllPermissionGranted(int[] grantResults) {
        for (int grantResult : grantResults) {
            if (grantResult == PERMISSION_DENIED) {
                return false;
            }
        }
        return true;
    }

如果成功授予，则回调onAfterPermissionGranted方法，否则就直接显示对话框，提醒用户手动设置权限。
以上就是ZPermissionHelper的代码，非常简单，非常轻量。
以下是调用ZPermissionHelper的Activity的代码

public class MainActivity extends AppCompatActivity implements IRequestPermissionCallback {

    private static final int PERMISSION_REQUEST = 0x101;

    private String[] REQUEST_PERMISSIONS = new String[]{
            Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.CAMERA
    };

    private ZPermissionHelper mPermissionHelper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mPermissionHelper = new ZPermissionHelper(this, REQUEST_PERMISSIONS, PERMISSION_REQUEST, this);
        mPermissionHelper.checkPermissions();
    }

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

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == ZPermissionHelper.ACTION_APPLICATION_DETAILS_SETTINGS) {
            mPermissionHelper.checkPermissions();
        }
    }

    @Override
    public void onPermissionGranted() {
        showToast("onPermissionGranted");
    }

    @Override
    public void onAfterPermissionGranted(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        showToast("onAfterPermissionGranted");
    }

    @Override
    public void onShouldShowRequestPermissionRationale(@NonNull Activity activity, @NonNull String permission) {
        showToast("onShouldShowRequestPermissionRationale");
    }

    public void showToast(String content) {
        Toast.makeText(this, content, Toast.LENGTH_SHORT).show();
    }
}

Activity实现IRequestPermissionCallback接口，并实现其方法
在onCreate方法中实例化ZPermissionHelper，并开启权限检查
在onRequestPermissionsResult回调中，将处理转移到ZPermissionHelper
基本就是以上步骤，另外需要注意一点，如果我们拒绝了权限，我们应该通过startActivityForResult的方式打开权限设置界面，这样当从权限设置界面返回的时候，我们就可以立马开始权限检查，判断用户是不是已经将所需要的权限都开启了。

以上就是本篇的全部内容，在这个方案中，主要对权限检测和处理的代码进行了简单的封装，还有很多需要改进的地方，比如activity必须实现回调接口，并且看上去在activity中增加的代码也不少，希望大家提示宝贵的意见。

最后，建议将权限检测的代码放到BaseActivity中，这样就可以进一步的减少代码量了。：github地址

旅行者40

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
轻量级Android6.0动态权限解决方案

在手机系统中，权限是一个非常重要的机制，它赋予了一个应用的权限范围，比如打电话的应用必须有电话权限，拍照的应用比较有拍照的权限。在Android6.0之前，Android采用的是静态权限机制，也就是我们将需要的权限(可能并不需要）全都写在manifest中，然后Android应用在安装的时候就必须授予这些权限。这种机制就产生了一个问题，一个打电话的应用可能也申请了拍照的权限，一个拍照的应用申请了读取
复制链接

扫一扫