android动态权限处理工具类

最新推荐文章于 2024-06-12 14:58:43 发布
最新推荐文章于 2024-06-12 14:58:43 发布
阅读量567 收藏
点赞数 1
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38164867/article/details/80893735
版权

自android6.0起，对一些敏感权限，除了在xml文件中声明，还需要我们动态获取权限。所以在项目开发中有一个处理动态权限的工具类就十分有必要了。

public class PermissionUtils {

    private static final String TAG = PermissionUtils.class.getSimpleName();
    public static final int CODE_RECORD_AUDIO = 0;
    public static final int CODE_GET_ACCOUNTS = 1;
    public static final int CODE_READ_PHONE_STATE = 2;
    public static final int CODE_CALL_PHONE = 3;
    public static final int CODE_CAMERA = 4;
    public static final int CODE_ACCESS_FINE_LOCATION = 5;
    public static final int CODE_ACCESS_COARSE_LOCATION = 6;
    public static final int CODE_READ_EXTERNAL_STORAGE = 7;
    public static final int CODE_WRITE_EXTERNAL_STORAGE = 8;
    public static final int CODE_MULTI_PERMISSION = 100;

    public static final int CODE_UPLOAD_IMG = 101;
    public static final int CODE_BLUTHOOTH_SCAN_CON = 102;

    public static final int CODE_LOAD_FILE = 103;
    public static final int CODE_ALL = 104;

    public static final int CODE_WATCH2_LINK = 105;
    public static final int CODE_BLUETHOOTH_CONNECT = 106;
    public static final int CODE_PHONE = 107;
    public static final int CODE_SHARE = 108;

    public static final String PERMISSION_RECORD_AUDIO = Manifest.permission.RECORD_AUDIO;
    public static final String PERMISSION_GET_ACCOUNTS = Manifest.permission.GET_ACCOUNTS;
    public static final String PERMISSION_READ_PHONE_STATE = Manifest.permission.READ_PHONE_STATE;
    public static final String PERMISSION_CAMERA = Manifest.permission.CAMERA;
    public static final String PERMISSION_ACCESS_FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
    public static final String PERMISSION_ACCESS_COARSE_LOCATION = Manifest.permission.ACCESS_COARSE_LOCATION;
    public static final String PERMISSION_READ_EXTERNAL_STORAGE = Manifest.permission.READ_EXTERNAL_STORAGE;
    public static final String PERMISSION_WRITE_EXTERNAL_STORAGE = Manifest.permission.WRITE_EXTERNAL_STORAGE;
    public static final String PERMISSION_BLUETOOTH_ADMIN = Manifest.permission.BLUETOOTH_ADMIN;
    public static final String PERMISSION_BLUETOOTH = Manifest.permission.BLUETOOTH;
    public static final String PERMISSION_READ_PHONE = Manifest.permission.READ_PHONE_STATE;
    public static final String PERMISSION_CALL_PHONE = Manifest.permission.CALL_PHONE;
    public static final String PERMISSION_PHONE_OUTGOING_CALLS = Manifest.permission.PROCESS_OUTGOING_CALLS;
    public static final String PERMISSION_READ_LOGS = Manifest.permission.READ_LOGS;
    public static final String PERMISSION_SET_DEBUG_APP = Manifest.permission.SET_DEBUG_APP;
    public static final String PERMISSION_SYSTEM_ALERT_WINDOW = Manifest.permission.SYSTEM_ALERT_WINDOW;
    public static final String PERMISSION_WRITE_APN_SETTINGS = Manifest.permission.WRITE_APN_SETTINGS;

    //   String[] mPermissionList = new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.ACCESS_FINE_LOCATION,
// Manifest.permission.CALL_PHONE,Manifest.permission.READ_LOGS,Manifest.permission.READ_PHONE_STATE, Manifest.permission.READ_EXTERNAL_STORAGE,
// Manifest.permission.SET_DEBUG_APP,Manifest.permission.SYSTEM_ALERT_WINDOW,Manifest.permission.GET_ACCOUNTS,Manifest.permission.WRITE_APN_SETTINGS};
    private static final String[] requestPermissions = {
            PERMISSION_RECORD_AUDIO,
            PERMISSION_GET_ACCOUNTS,
            PERMISSION_READ_PHONE_STATE,
            PERMISSION_CALL_PHONE,
            PERMISSION_CAMERA,
            PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_ACCESS_COARSE_LOCATION,
            PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };

    private static final String[] sharePermissions = {
            PERMISSION_WRITE_EXTERNAL_STORAGE,
            PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_CALL_PHONE,
            PERMISSION_READ_LOGS,
            PERMISSION_READ_PHONE_STATE,
            PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_SET_DEBUG_APP,
            PERMISSION_SYSTEM_ALERT_WINDOW,
            PERMISSION_GET_ACCOUNTS,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };

    public static final String[] uploadImgrequestPermissions = {
            PERMISSION_CAMERA,
            PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };

    public static final String[] bluethoothScanConPermissions = {
            PERMISSION_CAMERA,
            PERMISSION_ACCESS_COARSE_LOCATION,
            PERMISSION_READ_PHONE,
            PERMISSION_CALL_PHONE,
            PERMISSION_PHONE_OUTGOING_CALLS
    };


    public static final String[] loadFilePermissions = {
            PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };

    public static final String[] phonePermissions = {
            PERMISSION_READ_PHONE,
            PERMISSION_CALL_PHONE,
            PERMISSION_PHONE_OUTGOING_CALLS,
    };


    public static final String[] watch2LinkPermissions = {
            PERMISSION_ACCESS_COARSE_LOCATION,
            PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE,
            PERMISSION_READ_PHONE,
            PERMISSION_CALL_PHONE,
            PERMISSION_PHONE_OUTGOING_CALLS

    };


    public static final String[] smsPhonePermissions = {

    };


    public interface PermissionGrant {
        void onPermissionGranted(int requestCode);
    }


    /**
     * Requests permission.
     *
     * @param activity
     * @param requestCode request code, e.g. if you need request CAMERA permission,parameters is PermissionUtils.CODE_CAMERA
     */
    public static void requestPermission(final Activity activity, final int requestCode, PermissionGrant permissionGrant) {
        if (activity == null) {
            return;
        }

        Log.i(TAG, "requestPermission requestCode:" + requestCode);
        if (requestCode < 0 || requestCode >= requestPermissions.length) {
//            Log.w(TAG, "requestPermission illegal requestCode:" + requestCode);
            return;
        }

        final String requestPermission = requestPermissions[requestCode];

        //如果是6.0以下的手机，ActivityCompat.checkSelfPermission()会始终等于PERMISSION_GRANTED，
        // 但是，如果用户关闭了你申请的权限，ActivityCompat.checkSelfPermission(),会导致程序崩溃(java.lang.RuntimeException: Unknown exception code: 1 msg null)，
        // 你可以使用try{}catch(){},处理异常，也可以在这个地方，低于23就什么都不做，
        // 个人建议try{}catch(){}单独处理，提示用户开启权限。
//        if (Build.VERSION.SDK_INT < 23) {
//            return;
//        }

        int checkSelfPermission;
        try {
            checkSelfPermission = ActivityCompat.checkSelfPermission(activity, requestPermission);
        } catch (RuntimeException e) {
//            Log.e(TAG, "RuntimeException:" + e.getMessage());
            return;
        }

        if (checkSelfPermission != PackageManager.PERMISSION_GRANTED) {
            Log.i(TAG, "ActivityCompat.checkSelfPermission != PackageManager.PERMISSION_GRANTED");


            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, requestPermission)) {
//                Log.i(TAG, "requestPermission shouldShowRequestPermissionRationale");
                shouldShowRationale(activity, requestCode, requestPermission);

            } else {
//                Log.d(TAG, "requestCameraPermission else");
                ActivityCompat.requestPermissions(activity, new String[]{requestPermission}, requestCode);
            }

        } else {
//            Log.d(TAG, "ActivityCompat.checkSelfPermission ==== PackageManager.PERMISSION_GRANTED");
//            Toast.makeText(activity, "opened:" + requestPermissions[requestCode], Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(requestCode);
        }
    }

    public static void requestMultiResult(Activity activity, String[] permissions, int[] grantResults, PermissionGrant permissionGrant) {

        if (activity == null) {
            return;
        }

        //TODO
        Log.d(TAG, "onRequestPermissionsResult permissions length:" + permissions.length);
        Map<String, Integer> perms = new HashMap<>();

        ArrayList<String> notGranted = new ArrayList<>();
        String hint = "";
        for (int i = 0; i < permissions.length; i++) {
            Log.d(TAG, "permissions: [i]:" + i + ", permissions[i]" + permissions[i] + ",grantResults[i]:" + grantResults[i]);
            if (permissions[i].equals("android.permission.CAMERA")) {
                hint += "拍照、";
            }
            if (permissions[i].equals("android.permission.CALL_PHONE")) {
                hint += "拨打电话";
            }
            if (permissions[i].equals("android.permission.ACCESS_COARSE_LOCATION")) {
                hint += "获取位置";
            }
            if (permissions[i].equals("android.permission.WRITE_EXTERNAL_STORAGE")) {
                hint += "文件存储、读取";
            }

            perms.put(permissions[i], grantResults[i]);
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                notGranted.add(permissions[i]);
            }
        }

        if (notGranted.size() == 0) {
//            Toast.makeText(activity, "all permission success" + notGranted, Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(CODE_MULTI_PERMISSION);
        } else {
            openSettingActivity(activity, "该功能需要打开" + hint + "权限");
        }

    }


    /**
     * 一次申请多个权限
     */
    public static void requestMultiPermissions(final Activity activity, PermissionGrant grant, int code) {

        final List<String> permissionsList = getNoGrantedPermission(activity, false, code);
        final List<String> shouldRationalePermissionsList = getNoGrantedPermission(activity, true, code);

        //TODO checkSelfPermission
        if (permissionsList == null || shouldRationalePermissionsList == null) {
            return;
        }
//        Log.d(TAG, "requestMultiPermissions permissionsList:" + permissionsList.size() + ",shouldRationalePermissionsList:" + shouldRationalePermissionsList.size());

        if (permissionsList.size() > 0) {
            ActivityCompat.requestPermissions(activity, permissionsList.toArray(new String[permissionsList.size()]),
                    CODE_MULTI_PERMISSION);
//            Log.d(TAG, "showMessageOKCancel requestPermissions");

        } else if (shouldRationalePermissionsList.size() > 0) {
            String context = "";
            switch (code) {
                case CODE_ALL:
                    context = "温馨提示:请打开相应权限";
                    break;
                case CODE_UPLOAD_IMG:
                    context = "温馨提示:该功能需要打开拍照和文件读存权限";
                    break;
                case CODE_LOAD_FILE:
                    context = "温馨提示:该功能需要打开文件读存权限";
                    break;
                case CODE_BLUTHOOTH_SCAN_CON:
                    context = "温馨提示:该功能需要打开拍照和蓝牙定位权限";
                    break;
                case CODE_WATCH2_LINK:
                    context = "温馨提示:该功能需要打开文件读存和蓝牙定位权限";
                    break;
                case CODE_PHONE:
                    context = "温馨提示:该功能需要允许拨打电话和管理通话,文件读存权限";
                case CODE_SHARE:
                    context = "温馨提示:请打开分享所需权限";
                    break;
            }
            showMessageOKCancel(activity, context,
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            ActivityCompat.requestPermissions(activity, shouldRationalePermissionsList.toArray(new String[shouldRationalePermissionsList.size()]),
                                    CODE_MULTI_PERMISSION);
//                            Log.d(TAG, "showMessageOKCancel requestPermissions");
                        }
                    });
        } else {
            grant.onPermissionGranted(CODE_MULTI_PERMISSION);
        }

    }


    private static void shouldShowRationale(final Activity activity, final int requestCode, final String requestPermission) {
        //TODO
        String[] permissionsHint = activity.getResources().getStringArray(R.array.permissions);
        showMessageOKCancel(activity, "温馨提示: " + permissionsHint[requestCode], new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                ActivityCompat.requestPermissions(activity,
                        new String[]{requestPermission},
                        requestCode);
            }
        });
    }

    public static void showMessageOKCancel(final Activity context, String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(context)
                .setMessage(message)
                .setPositiveButton("确认", okListener)
                .setNegativeButton("取消", null)
                .create()
                .show();

    }

    /**
     * @param activity
     * @param requestCode  Need consistent with requestPermission
     * @param permissions
     * @param grantResults
     */
    public static void requestPermissionsResult(final Activity activity, final int requestCode, @NonNull String[] permissions,
                                                @NonNull int[] grantResults, PermissionGrant permissionGrant) {

        if (activity == null) {
            return;
        }
//        Log.d(TAG, "requestPermissionsResult requestCode:" + requestCode);

        if (requestCode == CODE_MULTI_PERMISSION) {
            requestMultiResult(activity, permissions, grantResults, permissionGrant);
            return;
        }

        if (requestCode < 0 || requestCode >= requestPermissions.length) {
//            Log.w(TAG, "requestPermissionsResult illegal requestCode:" + requestCode);
            Toast.makeText(activity, "illegal requestCode:" + requestCode, Toast.LENGTH_SHORT).show();
            return;
        }

        Log.i(TAG, "onRequestPermissionsResult requestCode:" + requestCode + ",permissions:" + permissions.toString()
                + ",grantResults:" + grantResults.toString() + ",length:" + grantResults.length);

        if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
//            Log.i(TAG, "onRequestPermissionsResult PERMISSION_GRANTED");
            //TODO success, do something, can use callback
            permissionGrant.onPermissionGranted(requestCode);

        } else {
            //TODO hint user this permission function
//            Log.i(TAG, "onRequestPermissionsResult PERMISSION NOT GRANTED");
            //TODO
            String[] permissionsHint = activity.getResources().getStringArray(R.array.permissions);
            openSettingActivity(activity, permissionsHint[requestCode]);
        }

    }

    private static void openSettingActivity(final Activity activity, String message) {

        showMessageOKCancel(activity, message, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Intent intent = new Intent();
                intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                Log.d(TAG, "getPackageName(): " + activity.getPackageName());
                Uri uri = Uri.fromParts("package", activity.getPackageName(), null);
                intent.setData(uri);
                activity.startActivity(intent);
            }
        });
    }


    /**
     * @param activity
     * @param isShouldRationale true: return no granted and shouldShowRequestPermissionRationale permissions, false:return no granted and !shouldShowRequestPermissionRationale
     * @return
     */
    public static ArrayList<String> getNoGrantedPermission(Activity activity, boolean isShouldRationale, int code) {
        String[] permissionsArray = new String[]{};
        ArrayList<String> permissions = new ArrayList<>();
        switch (code) {
            case CODE_UPLOAD_IMG:
                permissionsArray = uploadImgrequestPermissions;
                break;
            case CODE_BLUTHOOTH_SCAN_CON:
                permissionsArray = bluethoothScanConPermissions;
                break;
            case CODE_LOAD_FILE:
                permissionsArray = loadFilePermissions;
                break;
            case CODE_ALL:
                permissionsArray = requestPermissions;
                break;
            case CODE_WATCH2_LINK:
                permissionsArray = watch2LinkPermissions;
                break;
            case CODE_PHONE:
                permissionsArray = phonePermissions;
                break;
            case CODE_SHARE:
                permissionsArray = sharePermissions;
                break;
            default:
                break;

        }
        for (int i = 0; i < permissionsArray.length; i++) {
            String requestPermission = permissionsArray[i];


            //TODO checkSelfPermission
            int checkSelfPermission = -1;
            try {
                checkSelfPermission = ActivityCompat.checkSelfPermission(activity, requestPermission);
            } catch (RuntimeException e) {
                Toast.makeText(activity, "请打开相应的权限", Toast.LENGTH_SHORT)
                        .show();
//                Log.e(TAG, "RuntimeException:" + e.getMessage());
                return null;
            }

            if (checkSelfPermission != PackageManager.PERMISSION_GRANTED) {
//                Log.i(TAG, "getNoGrantedPermission ActivityCompat.checkSelfPermission != PackageManager.PERMISSION_GRANTED:" + requestPermission);

                if (ActivityCompat.shouldShowRequestPermissionRationale(activity, requestPermission)) {
//                    Log.d(TAG, "shouldShowRequestPermissionRationale if");
                    if (isShouldRationale) {
                        permissions.add(requestPermission);
                    }

                } else {

                    if (!isShouldRationale) {
                        permissions.add(requestPermission);
                    }
//                    Log.d(TAG, "shouldShowRequestPermissionRationale else");
                }

            }
        }
        return permissions;
    }


}

在需要申请权限的地方调用：

1.申请单个权限：

PermissionUtils.requestPermission(this, PermissionUtils.CODE_CALL_PHONE, mPermissionGrant);  //打电话的权

重写activity的onRequestPermissionsResult方法 
 @Override
    public void onRequestPermissionsResult(final int requestCode, String[] permissions,
                                           int[] grantResults) {
        PermissionUtils.requestPermissionsResult(this, requestCode, permissions, grantResults, mPermissionGrant);

    }

mPermissionGrant回权限申请的回调

 private PermissionUtils.PermissionGrant mPermissionGrant = new PermissionUtils.PermissionGrant() {
        @Override
        public void onPermissionGranted(int requestCode) {
            switch (requestCode) {
                case PermissionUtils.CODE_CALL_PHONE:
                    try {
                       //Todo:申请成功后要做的事情
                    } catch (Exception e) {

                    }
                    break;
                default:
                    break;

            }
        }
    };

2.申请多个权限（权限组）

PermissionUtils.requestMultiPermissions(this, mPermissionGrant, PermissionUtils.CODE_UPLOAD_IMG);

其余步骤跟申请单个权限一样

注意：申请权限组时，mPermissionGrant

 private PermissionUtils.PermissionGrant mPermissionGrant = new PermissionUtils.PermissionGrant() {
        @Override
        public void onPermissionGranted(int requestCode) {
            switch (requestCode) {
                case PermissionUtils.CODE_MULTI_PERMISSION:   //多个权限的请求码
                  //Todo:申请成功后要做的事情
                    break;
                default:
                    break;

            }
        }
    };


天下乌鸦不尽黑
关注
专栏目录
Android动态请求权限工具类
06-19
Android 动态权限工具类，使用简单方便，动态权限工具类动态权限工具类动态权限工具类动态权限工具类动态权限工具类动态权限工具类
消息模式Toast.makeText的几种常见用法
u011130648的专栏
03-13 1364
原文转载自：点击打开链接   http://daikainan.iteye.com/blog/1405575 Toast 是一个 View 视图，快速的为用户显示少量的信息。 Toast 在应用程序上浮动显示信息给用户，它永远不会获得焦点，不影响用户的输入等操作，主要用于 一些帮助 / 提示。 Toast 最常见的创建方式是使用静态方法 Toast.makeText 我使用的是
安卓动态权限详解
dev晴天的博客
01-06 4581
随着安卓的不断升级，手机的权限也逐渐被google收回，在6.0时出现了动态权限。 知识图 由来介绍 安卓6.0之前应用的权限在安装时就可以全部授予（清单文件声明的），然而这可能造成店大欺客的情况，用户为了安装app，必须同意所有的权限。在 Android 6.0 或更高版本对权限进行了分类，对某些涉及到用户隐私的权限可在运行时根据用户的需要动态授予。这样就不需要在安装时被强迫同意某些权限...
android开发-动态权限申请
weixin_42498443的博客
02-25 2810
android开发-动态权限申请基础知识权限分类实现方法动态申请权限思路代码总结未用到知识点 android版本6.0后，对于危险权限需要动态申请。本文总结动态申请危险权限的方法。 基础知识 权限分类 1.）普通权限（normal）：不直接威胁到用户的隐私，可直接在manifest清单里注册，系统会默认授权。 2）敏感权限：也是危险权限Dangerous-Permisson，能够获取到用户的隐私。需要在manifest清单里注册，同时动态向系统请求授权，每组只要有一个权限申请成功，默认整组权限都可以使用了。
Android动态权限获取及其工具类的实现与整合
yimelancholy的博客
01-12 1292
Android6.0以上，即API 23以上动态权限获取，这里以录音权限为例，其他权限亦可这样动态获取。
Android-6.0动态申请权限工具类
08-13
为了简化这一过程，我们可以创建一个名为"PermissionsUtil"的工具类来帮助我们更方便、更优雅地处理动态权限申请。以下是对这个工具类的详细解释和实现思路： 1. **了解运行时权限** - 在Android 6.0之前，应用在...
Android6.0权限管理工具类
04-03
针对这一变化，开发出了各种权限管理工具类，以帮助开发者更方便地处理这些动态权限请求。 首先，我们要理解Android 6.0的权限模型。在Android 6.0之前，如果应用在AndroidManifest.xml中声明了所需的危险权限，...
动态权限申请工具类.zip
05-28
"动态权限申请工具类.zip"提供的就是一个这样的解决方案，帮助开发者高效地处理Android 6.0及以上版本的权限申请。 首先，我们来看动态权限申请的重要性。在之前的Android版本中，应用在安装时会一次性获取所有所需...
优化版动态权限申请工具类.zip
05-29
在压缩包中的"Demo"文件，很可能是包含了一个示例项目，演示了如何使用这个优化的动态权限工具类。开发者可以通过查看和运行这个示例来了解如何在实际项目中集成和使用这个工具类。 总结来说，"优化版动态权限申请...
手把手教你搭建android项目框架（五）权限工具封装
flowerdanceX的博客
08-30 258
权限工具类封装。 本篇持续更新，直到完成一个完整项目。
【Android开发】Android权限工具类
最新发布
m0_46426465的博客
06-12 646
本文我们将分析Android开发中动态申请权限的相关内容，包括动态判断权限状态，动态申请权限和分析申请结果的方法，并封装一个通用工具类，为自己的后续的开发中复用，减少编重复代码的场景。本示例测试尝试申请摄像头权限，如果第一次申请或者用户还未点击“拒绝并不再询问”权限的选项可以调用系统的权限允许提示，如果用户选择了拒绝则需要跳转到app详细页设置权限。方法中判断用户用户的操作，可以根据申请权限时的requestCode和系统回调返回的值来判断用户是否同意了我们的申请权限的请求。是要申请的权限名称，
Android之动态申请权限
ChenYiRan123456的博客
04-09 3883
Android6.0（23）以上需要动态申请权限 如果没有将报下面的权限问题的错 打电话的动态申请权限例子 package com.example.androidnetwork; import android.Manifest; import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; import android.net.Uri; import and
安卓权限请求工具类
May-gemini的博客
10-24 1098
功能：通过简单一句代码，实现权限请求，简化代码。 涉及类：权限请求界面，PermissionCheckActivity.java；权限工具类，PermissionCheckUtil.java。 PermissionCheckActivity.java // import ... /** * add by zzh 20180726 * */ public class Permissio...
Android - 运行时权限一个工具类搞定
mythmayor的博客
09-26 525
转载请注明出处：https://blog.csdn.net/mythmayor/article/details/81388482 一、运行时权限简述。 请点击这里了解更多 二、运行时权限工具类。 package com.mythmayor.demo.utils; import android.Manifest; import android.app.Activity; import androi...
Android权限工具
WTQ_DOMIAN的博客
10-12 744
Android权限工具
【Android笔记67】Android之动态申请访问权限（工具类封装）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
01-16 669
作为一个APP应用程序，用户的所有隐私数据都可能保存在自己的APP里面，所以如果安装的其他应用程序要访问用户的一些隐私数据，那么这个时候，就需要申请访问权限，android权限可以分为两部分，即：普通权限、危险权限。对于普通权限来说，我们只需要在【AndroidManifest.xml】清单文件里面申请即可，这个申请权限的过程不需要用户同意；而对于那些访问用户隐私数据的操作，从android 6.0版本开始（API 级别 23），不仅需要在【AndroidManifest.xml】清单文件里面申请权限，
Android动态权限申请工具类
红鼻子小黑的博客
10-31 295
package com.example.gaowen38.utils; import android.Manifest; import android.app.Activity; import android.content.Intent; import android.content.pm.PackageManager; import android.net.Uri; import andr...
Android动态请求权限的工具类（转载、非原创）
小小9575的博客
09-18 529
  Android动态请求权限的工具类 Android 6.0（SDK 23）以上才需要用到动态权限。 之前已经写过好多次关于Android动态权限的文章，但是后期发现每次都要进行复制粘贴，还要修改， 还不如写一个自己的工具类，那就方便多了！ 网上也有很多关于动态权限的工具类，还有一些框架，  但是我发现有些使用还是挺麻烦，我感觉还是自己这个动态权限的工具类是非常好的。 一.我的动态权...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值