android动态权限处理工具类

最新推荐文章于 2021-10-18 16:16:36 发布
最新推荐文章于 2021-10-18 16:16:36 发布
阅读量542 收藏
点赞数 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;

            }
        }
    };


天下乌鸦不尽黑
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
消息模式Toast.makeText的几种常见用法
u011130648的专栏
03-13 1313
原文转载自：点击打开链接   http://daikainan.iteye.com/blog/1405575 Toast 是一个 View 视图，快速的为用户显示少量的信息。 Toast 在应用程序上浮动显示信息给用户，它永远不会获得焦点，不影响用户的输入等操作，主要用于 一些帮助 / 提示。 Toast 最常见的创建方式是使用静态方法 Toast.makeText 我使用的是
android权限工具类封装,Android组件化架构 - 6. 权限管理
weixin_35338620的博客
05-25 151
权限的目的权限设立的目的是保护安全权限机制系统权限分三种:Android所有者权限,即Android Rom开发权限;Android Root权限,Linux系统中的最高用户权限;Android 应用程序权限,应用开发者在项目的AndroidManifest中声明,然后由用户授权获取(Android 应用程序权限分为两种,普通权限(不涉及用户隐私,系统自动授权)和敏感权限(涉及用户隐私,需要用户手...
Android动态请求权限的工具类（可请求多个，并且功能完善）
热门推荐
wenzhi的博客
06-07 1万+
Android动态请求权限的工具类 Android 6.0（SDK 23）以上才需要用到动态权限。 之前已经写过好多次关于Android动态权限的文章，但是后期发现每次都要进行复制粘贴，还要修改， 还不如写一个自己的工具类，那就方便多了！ 网上也有很多关于动态权限的工具类，还有一些框架， 但是我发现有些使用还是挺麻烦，我感觉还是自己这个动态权限的工具类是非常好的。 一.我的动态权限工具...
Android-Android一个权限申请工具类直接复制到项目中即可使用
08-13
【Android】一个权限申请工具类，直接复制到项目中即可使用
Android 6.0动态权限申请工具类(授权成功、失败回调)
baipenggui_bo
10-18 522
工具类 ：PermissionsUtils public class PermissionsUtils { private final int mRequestCode = 100;//权限请求码 public static boolean showSystemSetting = true; private PermissionsUtils() { } private static PermissionsUtils permissionsUtils;
Android动态请求权限工具类
06-19
Android 动态权限工具类，使用简单方便，动态权限工具类动态权限工具类动态权限工具类动态权限工具类动态权限工具类动态权限工具类
Android-6.0动态申请权限工具类
08-13
动态申请权限工具类 android 6.0 以上需要动态申请权限, 而动态申请权限一般比较繁琐, 所以该工具类应运而生
Android6.0权限管理工具类
04-03
Android6.0权限管理工具类，包括动态申请权限类和跳转到应用详细页面类
优化版动态权限申请工具类.zip
05-29
优化后的动态适配权限工具类
动态权限申请工具类.zip
12-27
该类是动态申请权限的工具类，适用于Android 6.0以上需要动态申请的任何权限。方便在项目中统一调用
Android运行时权限工具类
04-01
Android运行时权限工具类，一个类，调用时一句代码搞定
android动态添加权限工具包，方便快捷，
12-08
android动态添加权限工具包，方便快捷，只需要简单的配置就可以用。博文链接： android动态添加权限6.0+--权限操作jar简化添加权限步骤。http://blog.csdn.net/u012115730/article/details/78752449
关于Android动态权限处理更友好的方式（Kotlin）
xiaoyantan的博客
08-21 4120
用户拒绝权限（如图片选择拒绝存储权限后显示空页）后，完全不知道该干什么。这是我们应该指导用户去开启权限（因为很多时候手比脑子更快的就点击了拒绝）。如下图： 首先定义一个权限处理的工具类：class PermissionUtils(private val context: Activity) { private var mHasPermissionRunnable: Runnable? = n
终于等到你--权限工具类
wolfking0608的博客
01-18 761
Foreword之前总是有小伙伴问 AndroidUtilCode 中有没有权限工具类，但都被我怼回去了，让先用着其他第三方的，不过，到了如今的 1.11.0 版本的 AndroidUtilCode，这个一直拖欠着的权限工具类总算要问世了，以后小伙伴们如果用 AndroidUtilCode 需要动态授权的话，就不用再多依赖一个第三方库了，下面来介绍下其功能。Functions兼容安卓各版本，包括
Android动态权限详解
360技术
04-28 4979
1什么是动态权限去年底，上级主管部门为加强国内Android应用隐私管理，出台了一系列规定，我们的App也做了相应的修改。主要一条修改为，隐私提示与权限获取顺序。修改测试过程中，发觉部分...
Android权限工具类封装
weixin_33898876的博客
04-10 501
1.完整的封装类： public class PermissionsUtils { private final int mRequestCode = 100;//权限请求码 public static boolean showSystemSetting = true; private PermissionsUtils() { } private static Permissions...
Android动态申请权限工具类
初级菜鸟
07-04 392
/** * Created by Administrator on 2017/5/23. * Android 6.0以上共有9组权限需要申请，组内一个权限申请成功代表其他也申请成功 */ public class PermissionUtils { private static final String TAG = PermissionUtils.class.getSimpleNa
android 6.0动态权限申请工具类,【需求解决系列之五】一行代码实现Android 6.0以上动态权限的申请...
weixin_36367702的博客
05-25 135
前言自从Android6.0以后，运行时权限申请就成为了一大痛点！动态申请吧，说它难吧，它又不难，说它不难吧，申请起来贼复杂；不申请吧，还要给你整闪退。其实现在有很多权限申请框架了，那么为什么我还在造轮子呢？其实原因很简单，可能是年纪大了，开始喜欢简约风了，能少写一行的我绝对不想多写一个字母！说到底还是觉得现有的很多框架，用起来不是那么顺手，配置相对复杂，所以萌生了再整一个一行代码实现权限申请的想...
Android Camera2官方demo的学习
qq_38164867的博客
04-14 6078
一.介绍： Camera2 是 Android L 的一个重大更新，重新定义了相机 API，也重构了相机 API 的架构，但使用起来，还是很复杂。 官方demo地址：Camera2 二.流程： 下面根据官方demo来详细了解下Camera2的拍照流程 1.设置预览图的尺寸 mPreviewSize = chooseOptimalSize(map.getOutputSizes(Surface...
android 连接蓝牙工具类
最新发布
10-23
下面是一个简单的连接蓝牙的工具类： 首先，需要在AndroidManifest.xml文件中添加蓝牙权限： <uses-permission android:name="android.permission.BLUETOOTH"/> <uses-permission android:name="android....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值