android 权限封装 看了好多权限封装基本都是copy 忍不住自己折腾了一番

最新推荐文章于 2024-08-14 11:16:36 发布
置顶 最新推荐文章于 2024-08-14 11:16:36 发布
阅读量1.7k 收藏
点赞数 1
文章标签： android 权限封装 android 6.0权限问题 权限封装 权限
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010123087/article/details/74004319
版权 
相信大家对安卓权限都有所了解 每次申请权限都要写一大堆代码 而且还要记住那么多的权限的名称 本人懒懒的 记不住 。。。
对权限这块进行了简单的封装  单个权限申请/多个权限申请  权限申请成功/失败的回调  
package com.example.android;
import android.Manifest;
import android.app.Activity;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.provider.Settings;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by zhaojihao on 2017-6-17
 * 系统权限分为9大类
 */
public class PermissionUtils {

    private static final String TAG = PermissionUtils.class.getSimpleName();
    public static final int CODE_AUDIO = 0;//录音
    public static final int CODE_GET_ACCOUNTS = 1;//读取通讯录权限
    public static final int CODE_PHONE = 2;//通话管理拨打电话
    public static final int CODE_CALENDAR = 3;//日志/日历
    public static final int CODE_CAMERA = 4;//拍照或录像
    public static final int CODE_LOCATION = 5;//获取位置信息
    public static final int CODE_SENSORS= 6;//传感器
//    public static final int CODE_READ_EXTERNAL_STORAGE = 7;//文件读取
    public static final int CODE_STORAGE = 8;//文件操作
    public static final int CODE_SMS = 9;//短信操作
    public static final int CODE_MULTI_PERMISSION = 100;

    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_READ_CALENDAR = Manifest.permission.READ_CALENDAR;
    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_SENSORS = Manifest.permission.BODY_SENSORS;
    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_SEND_SMS = Manifest.permission.SEND_SMS;

    private static PermissionGrant permission;

    private static final String[] requestPermissions = {
            PERMISSION_RECORD_AUDIO,
            PERMISSION_GET_ACCOUNTS,
            PERMISSION_READ_PHONE_STATE,
            PERMISSION_READ_CALENDAR,
            PERMISSION_CAMERA,
            PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_SENSORS,
            PERMISSION_READ_EXTERNAL_STORAGE,
            PERMISSION_WRITE_EXTERNAL_STORAGE,
            PERMISSION_SEND_SMS
    };
    interface PermissionGrant {
        void onPermissionGranted(int requestCode);
        void onFail();
    }

    /**
     * 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;
        }
        permission=permissionGrant;

        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就不申请权限，直接做你想做的。permissionGrant.onPermissionGranted(requestCode);
//        if (Build.VERSION.SDK_INT < 23) {
//            permissionGrant.onPermissionGranted(requestCode);
//            return;
//        }

        int checkSelfPermission;
        try {
            checkSelfPermission = ActivityCompat.checkSelfPermission(activity, requestPermission);
        } catch (RuntimeException e) {
            Toast.makeText(activity, "please open this permission", Toast.LENGTH_SHORT)
                    .show();
            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);
        }
    }

    private 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<>();
        for (int i = 0; i < permissions.length; i++) {
            Log.d(TAG, "permissions: [i]:" + i + ", permissions[i]" + permissions[i] + ",grantResults[i]:" + grantResults[i]);
            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, "您有一些必要的权限没有开启!现在是否去设置?");
        }

    }


    /**
     * 一次申请多个权限
     * @param activity
     * @param grant  回调
     * @param code  权限的CODE
     */
    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) {
            showMessageOKCancel(activity, "您有一些必要的权限没有开启!现在是否去设置?",
                    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, "Rationale: " + permissionsHint[requestCode], new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                ActivityCompat.requestPermissions(activity,
                        new String[]{requestPermission},
                        requestCode);
                Log.d(TAG, "showMessageOKCancel requestPermissions:" + requestPermission);
            }
        });
    }

    private static void showMessageOKCancel(final Activity context, String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(context)
                .setMessage(message)
                .setPositiveButton("是", okListener)
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        permission.onFail();
                    }
                })
                .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, "Result" + 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) {

        ArrayList<String> permissions = new ArrayList<>();
        for (int i = 0; i < code.length; i++) {
            String requestPermission = requestPermissions[code[i]];
            //TODO checkSelfPermission
            int checkSelfPermission = -1;
            try {
                checkSelfPermission = ActivityCompat.checkSelfPermission(activity, requestPermission);
            } catch (RuntimeException e) {
                Toast.makeText(activity, "please open those permission", 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;
    }
    public static void getPermissions(Activity mActivity,PermissionGrant mPermissionGrant,int code) {
        requestPermission(mActivity,code, mPermissionGrant);
    }
}

 

方法调用封装在BaseActivity  或者BaseFragment
 

 

public abstract class BaseActivity extends Activity implements ActivityCompat.OnRequestPermissionsResultCallback{
 

 

	
 

/**
 * 当权限申请结束时调用
 */
@Override
public void onRequestPermissionsResult(final int requestCode, @NonNull String[] permissions,
                                       @NonNull int[] grantResults) {
    PermissionUtils.requestPermissionsResult(this, requestCode, permissions, grantResults, mPermissionGrant);
}
//权限申请回调
public PermissionUtils.PermissionGrant mPermissionGrant = new PermissionUtils.PermissionGrant() {
    @Override
    public void onPermissionGranted(int requestCode){
        getPermission(requestCode);
    }
};
//子Activity如需申请权限重写改方法执行申请成功后的步骤
public void getPermission(int requestCode){}
 

 

}
 

 

子Activity调用
 



 

//同时申请多个权限
 

 

PermissionUtils.requestMultiPermissions(this,mPermissionGrant,new int[]{
        PermissionUtils.CODE_SMS,
        PermissionUtils.CODE_STORAGE
});
 
//单独申请一个权限 

 

PermissionUtils.requestPermission(this,PermissionUtils.CODE_AUDIO,mPermissionGrant);
 



 

//权限申请回调  如果统一界面有两个跳转申请的权限相同 则需要在申请权限之前把操作做好处理 如Intent 
 

 

@Override
public void getPermission(int requestCode) {
    Toast.makeText(PermissionActivity.this,"权限获取成功",Toast.LENGTH_LONG).show();
}
 

 
 


                

        

        

    

  


    

      

        

            

              
                
                  刘艺冰
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Qt开发经验总结

				
			

			

				

					草上爬的博客
				

				

					12-02
					
					8306
					
				

			

		

		

			
				
增加了很多轮子，同时原有模块拆分的也更细致，估计为了方便拓展个管理。把一些过度封装的东西移除了（比如同样的功能有多个函数），保证了只有一个函数执行该功能。把一些Qt5中兼容Qt4的方法废弃了，必须用Qt5中对应的新的函数。跟随时代脚步，增加了不少新特性以满足日益增长的客户需求。对某些模块和类型及处理进行了革命性的重写，运行效率提高不少。有参数类型的变化，比如 long * 到 qintptr * 等，更加适应后续的拓展以及同时对32 64位不同系统的兼容。

			
		

	



                

              
                



	

		

			

				
					
android简单的请求手机权限封装

				
			

			

				

					Fantistic_baby的博客
				

				

					03-21
					
					607
					
				

			

		

		

			
				
android权限在Android 5.1.1（API22）及以前，都是install_time permission request，但是，在Android 6.0（API23）以以后版本，都会是runtime permission request，意味着需要某个危险权限时需要在代码里去检查是否已经granted了，就是说的动态请求。
下面上一下它的简单封装，我认为很好用：
/**
 * 权限管...

			
		

	



                


  
              

                


	

		

			

				
					
Android 采用AOP方式封装6.0权限管理

				
			

			

				

					小马快跑的博客
				

				

					03-30
					
					4520
					
				

			

		

		

			
				
本篇文章已授权微信公众号 hongyangAndroid（鸿洋）独家发布

目录：




【一】背景
【二】效果图
【三】整体思路
【四】使用举例
4.1 申请单个权限
4.2 申请多个权限
4.3 跳转到设置类


【五】总结
【六】源码






【一】背景

6.0运行时申请权限已经是一个老生常谈的内容了，最近项目TargetSDKVersion升到23以上，所以我们也需要做权限管理，我...

			
		

	





	

		

			

				
					
Android 全系统版本文件读写最佳适配，CV 即用（适配到 Android 14）

					
最新发布

				
			

			

				

					非猿
				

				

					08-14
					
					312
					
				

			

		

		

			
				
Android 12及以下系统，我们只需要声明READ_EXTERNAL_STORAGE权限即可。并且由于从Android 13开始这个权限就被废弃了，因此还要加上maxSdkVersion="32"才行。参考文献：郭神：  https://blog.csdn.net/guolin_blog/article/details/137410229。Android 13新增了3个运行时权限，分别用于控制App对照片、视频、音频的访问。这是能够完美适配Android各个系统版本的本地读写权限的写法。

			
		

	



		

			
		



	

		

			

				
					
android权限的封装,Android-M-Permission

				
			

			

				

					weixin_39830303的博客
				

				

					05-26
					
					156
					
				

			

		

		

			
				
把 Android 运行时权限处理封装在 BaseActivity 中，方便业务申请时只需要简单的 1，2 行代码即可成功处理权限申请对外接口1. 请求权限操作/*** 请求权限操作* @param rationale 请求权限提示语* @param permissionRequestCode 权限 requestCode* @param perms 申请的权限列表* @param callbac...

			
		

	





	

		

			

				
					
android 对权限的简单的封装

				
			

			

				

					345丶
				

				

					05-10
					
					399
					
				

			

		

		

			
				
android 动态权限的简单封装。
在android 6.0 以后，如果你要进行一些敏感的操作，你就必须动态的申请权限。
在动态申请权限的时候必须先加入静态的权限，在清单文件中进行注册。
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

然后就可以进行动态权限的请求了。

因为权限...

			
		

	





	

		

			

				
					
Android-权限封装

				
			

			

				

					超级氯化钾的博客
				

				

					11-21
					
					329
					
				

			

		

		

			
				

package kcl.com.fqinqin.utils;

import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.annot...

			
		

	





	

		

			

				
					
Flutter 笔记 | Flutter Native 插件开发 (Android)

				
			

			

				

					川峰的博客
				

				

					05-20
					
					2130
					
				

			

		

		

			
				
BasicMessageChannel、 MethodChannel、 EventChannel是开发者和 Flutter Framework 进行通信的接口，它们的底层通信都是通过 messenger 字段所持有的BinaryMessenger接口来实现的。Platform view 允许将原生视图嵌入到 Flutter 应用中，所以您可以通过 Dart 将变换、裁剪和不透明度等效果应用到原生视图。
Flutter 支持两种集成模式：虚拟显示模式 (Virtual displays) 和混合集成模式 (

			
		

	





	

		

			

				
					
ym——Andorid-15k+的面试题。

					
热门推荐

				
			

			

				

					陈宇明
				

				

					08-07
					
					2万+
					
				

			

		

		

			
				
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。
特别献上整理过的50道面试题目
1.listView的优化方式





重用conve

			
		

	





	

		

			

				
					
Android 常用 adb 命令总结

				
			

			

				

					Now do it
				

				

					06-09
					
					228
					
				

			

		

		

			
				
针对移动端 Android 的测试， adb 命令是很重要的一个点，必须将常用的 adb 命令熟记于心， 将会为 Android 测试带来很大的方便，其中很多命令将会用于自动化测试的脚本当中。
Android Debug Bridge
adb 其实就是 Android Debug Bridge, Android 调试桥的缩写，adb 是一个 C/S 架构的命令行工具，主要由 3 部分组成：
运行在...

			
		

	





	

		

			

				
					
Android常用adb命令总结

				
			

			

				

					a1809032425的博客
				

				

					04-20
					
					203
					
				

			

		

		

			
				
Android常用adb命令总结参考网址：https://blog.csdn.net/lgb718978857/article/details/70170784Android调试桥adb其实就是Android Debug Bridge，Android调试桥的缩写，adb是一个C / S架构的命令行工具，主要由3部分组成：运行在PC端的客户端：可以通过它对Android应用进行安装，卸载及调试Ecl...

			
		

	





	

		

			

				
					
Android6.0运行权限封装，一句代码实现

				
			

			

				

					05-03
				

			

		

		

			
				
Android6.0运行权限封装，轻轻松松一句代码实现，并添加了同意及拒绝授权时的监听回调,方便添加操作

			
		

	





	

		

			

				
					
Android-SchPermission一个自己封装的Android动态申请权限库

				
			

			

				

					08-12
				

			

		

		

			
				
SchPermission一个自己封装的Android动态申请权限库

			
		

	





	

		

			

				
					
android 权限

				
			

			

				

					qq_42384206的博客
				

				

					10-25
					
					193
					
				

			

		

		

			
				
android 权限
  andorid权限在6.0之后，因为要保护用户隐私，所以开发者要主动申请动态权限，才能获取相关的功能，下面是动态获取权限的方法，以及权限组的说明。

权限
权限组，申请一个即获取所有的权限
group:android.permission-group.CONTACTS
    // 写联系人
    permission:android.permission.WRITE_...

			
		

	





	

		

			

				
					
android动态权限封装,Android 动态权限封装

				
			

			

				

					weixin_30182831的博客
				

				

					05-25
					
					214
					
				

			

		

		

			
				
PermissionActivitypackage com.example.appdemo;import android.content.Context;import android.content.DialogInterface;import android.content.Intent;import android.content.pm.PackageManager;import androi...

			
		

	





	

		

			

				
					
Android 6.0 权限封装

				
			

			

				

					u010345983的博客
				

				

					08-11
					
					216
					
				

			

		

		

			
				
Android 6.0 权限封装

			
		

	





	

		

			

				
					
Android 6.0权限封装

				
			

			

				

					jiahongfeinew的博客
				

				

					02-01
					
					237
					
				

			

		

		

			
				
简书地址：https://www.jianshu.com/p/7ae6f234f392 
GitHub地址：https://github.com/jiahongfei/OKPermission


  本篇文章来介绍Android6.0系统申请权限问题以及我自己封装的一个开源库。github地址点击这里。 
  开源库支持：弹出权限说明对话框，单个、多个权限申请。




Android6.0权限

			
		

	





	

		

			

				
					
Android6.0权限封装

				
			

			

				

					蓝枫
				

				

					03-05
					
					1213
					
				

			

		

		

			
				
简介Android6.0中对权限分为了一般权限和危险权限。
一般权限：只要在清单文件中注册即可使用。
危险权限：除了要在清单文件中注册外，还要对用户进行请求权限弹窗提醒，才可以使用。
危险权限关于日历的权限：<uses-permission android:name="android.permission.READ_CALENDAR"/>
<uses-permission android:name=

			
		

	





	

		

			

				
					
android运行时权限封装,封装android运行时权限(EPermission)

				
			

			

				

					weixin_35419195的博客
				

				

					05-27
					
					274
					
				

			

		

		

			
				
在我的上一篇文章详解android6-0权限 中解释了关于android 6.0后关于运行时权限的判断，申请，回调，我们采用的是常规的申请流程，这篇文章我们将要根据申请的流程，基于Annotation Processing Tool技术，封装一个EPermission的库，方便大家使用使用下面介绍一下EPermission的使用使用到注解@PermissionGrant  标识某个权限被同意授权后...

			
		

	





	

		

			

				
					
理解Java面向对象封装：权限修饰与封装实践

				
			

			

				

					
				

			

		

		

			
				
5. **类和对象基础**：理解封装的前提是对Java的基本结构有深入认识，如类和对象。类是面向对象编程的基石，包含了属性（成员变量）和行为（方法），封装则是将它们组织在一起，形成一个完整的数据结构。  通过本文...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值