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

爱被打了一巴掌 2022-06-12 11:27 206阅读 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地址][github]

[github]: https://github.com/Zephyr90/ZPermissionHelper