Android6.0权限管理之开源项目Grant
2016-07-29 11:20
357 查看
本文在CSDN博客首发 转载请注明出处 http://blog.csdn.net/u011071427/article/details/52062947 本文出自Allen李的博客
Android开发者应该都知道在Android6.0后添加了权限的动态管理,我以前也写过一片博客关于怎么处理权限的动态申请。传送门
今天主要介绍Github上的开源项目Grant是如何处理权限管理的。
先来一个Github的传送门:Grant
然后直接上代码
Grant里面一共有三个类,分别是:
(1)Permissions
package com.anthonycr.grant; /** * Enum class to handle the different states * of permissions since the PackageManager only * has a granted and denied state. */ enum Permissions { GRANTED, DENIED, NOT_FOUND }
这是一个枚举类,用来对应三种状态:已授权,授权失败,未发现的权限
(2)PermissionsManager
package com.anthonycr.grant; import android.Manifest; import android.app.Activity; import android.content.Context; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.os.Build; import android.support.annotation.NonNull; import android.support.annotation.Nullable; import android.support.v4.app.ActivityCompat; import android.support.v4.app.Fragment; import android.util.Log; import java.lang.ref.WeakReference; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; /** * A class to help you manage your permissions simply. */ public class PermissionsManager { private static final String TAG = PermissionsManager.class.getSimpleName(); private final Set<String> mPendingRequests = new HashSet<>(1); private final Set<String> mPermissions = new HashSet<>(1); private final List<WeakReference<PermissionsResultAction>> mPendingActions = new ArrayList<>(1); private static PermissionsManager mInstance = null; public static PermissionsManager getInstance() { if (mInstance == null) { mInstance = new PermissionsManager(); } return mInstance; } private PermissionsManager() { initializePermissionsMap(); } /** * This method uses reflection to read all the permissions in the Manifest class. * This is necessary because some permissions do not exist on older versions of Android, * since they do not exist, they will be denied when you check whether you have permission * which is problematic since a new permission is often added where there was no previous * permission required. We initialize a Set of available permissions and check the set * when checking if we have permission since we want to know when we are denied a permission * because it doesn't exist yet. */ private synchronized void initializePermissionsMap() { Field[] fields = Manifest.permission.class.getFields(); for (Field field : fields) { String name = null; try { name = (String) field.get(""); } catch (IllegalAccessException e) { Log.e(TAG, "Could not access field", e); } mPermissions.add(name); } } /** * This method retrieves all the permissions declared in the application's manifest. * It returns a non null array of permisions that can be declared. * * @param activity the Activity necessary to check what permissions we have. * @return a non null array of permissions that are declared in the application manifest. */ @NonNull private synchronized String[] getManifestPermissions(@NonNull final Activity activity) { PackageInfo packageInfo = null; List<String> list = new ArrayList<>(1); try { Log.d(TAG, activity.getPackageName()); packageInfo = activity.getPackageManager().getPackageInfo(activity.getPackageName(), PackageManager.GET_PERMISSIONS); } catch (PackageManager.NameNotFoundException e) { Log.e(TAG, "A problem occurred when retrieving permissions", e); } if (packageInfo != null) { String[] permissions = packageInfo.requestedPermissions; if (permissions != null) { for (String perm : permissions) { Log.d(TAG, "Manifest contained permission: " + perm); list.add(perm); } } } return list.toArray(new String[list.size()]); } /** * This method adds the {@link PermissionsResultAction} to the current list * of pending actions that will be completed when the permissions are * received. The list of permissions passed to this method are registered * in the PermissionsResultAction object so that it will be notified of changes * made to these permissions. * * @param permissions the required permissions for the action to be executed. * @param action the action to add to the current list of pending actions. */ private synchronized void addPendingAction(@NonNull String[] permissions, @Nullable PermissionsResultAction action) { if (action == null) { return; } action.registerPermissions(permissions); mPendingActions.add(new WeakReference<>(action)); } /** * This method removes a pending action from the list of pending actions. * It is used for cases where the permission has already been granted, so * you immediately wish to remove the pending action from the queue and * execute the action. * * @param action the action to remove */ private synchronized void removePendingAction(@Nullable PermissionsResultAction action) { for (Iterator<WeakReference<PermissionsResultAction>> iterator = mPendingActions.iterator(); iterator.hasNext(); ) { WeakReference<PermissionsResultAction> weakRef = iterator.next(); if (weakRef.get() == action || weakRef.get() == null) { iterator.remove(); } } } /** * This static method can be used to check whether or not you have a specific permission. * It is basically a less verbose method of using {@link ActivityCompat#checkSelfPermission(Context, String)} * and will simply return a boolean whether or not you have the permission. If you pass * in a null Context object, it will return false as otherwise it cannot check the permission. * However, the Activity parameter is nullable so that you can pass in a reference that you * are not always sure will be valid or not (e.g. getActivity() from Fragment). * * @param context the Context necessary to check the permission * @param permission the permission to check * @return true if you have been granted the permission, false otherwise */ @SuppressWarnings("unused") public synchronized boolean hasPermission(@Nullable Context context, @NonNull String permission) { return context != null && (ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED || !mPermissions.contains(permission)); } /** * This static method can be used to check whether or not you have several specific permissions. * It is simpler than checking using {@link ActivityCompat#checkSelfPermission(Context, String)} * for each permission and will simply return a boolean whether or not you have all the permissions. * If you pass in a null Context object, it will return false as otherwise it cannot check the * permission. However, the Activity parameter is nullable so that you can pass in a reference * that you are not always sure will be valid or not (e.g. getActivity() from Fragment). * * @param context the Context necessary to check the permission * @param permissions the permissions to check * @return true if you have been granted all the permissions, false otherwise */ @SuppressWarnings("unused") public synchronized boolean hasAllPermissions(@Nullable Context context, @NonNull String[] permissions) { if (context == null) { return false; } boolean hasAllPermissions = true; for (String perm : permissions) { hasAllPermissions &= hasPermission(context, perm); } return hasAllPermissions; } /** * This method will request all the permissions declared in your application manifest * for the specified {@link PermissionsResultAction}. The purpose of this method is to enable * all permissions to be requested at one shot. The PermissionsResultAction is used to notify * you of the user allowing or denying each permission. The Activity and PermissionsResultAction * parameters are both annotated Nullable, but this method will not work if the Activity * is null. It is only annotated Nullable as a courtesy to prevent crashes in the case * that you call this from a Fragment where {@link Fragment#getActivity()} could yield * null. Additionally, you will not receive any notification of permissions being granted * if you provide a null PermissionsResultAction. * * @param activity the Activity necessary to request and check permissions. * @param action the PermissionsResultAction used to notify you of permissions being accepted. */ @SuppressWarnings("unused") public synchronized void requestAllManifestPermissionsIfNecessary(final @Nullable Activity activity, final @Nullable PermissionsResultAction action) { if (activity == null) { return; } String[] perms = getManifestPermissions(activity); requestPermissionsIfNecessaryForResult(activity, perms, action); } /** * This method should be used to execute a {@link PermissionsResultAction} for the array * of permissions passed to this method. This method will request the permissions if * they need to be requested (i.e. we don't have permission yet) and will add the * PermissionsResultAction to the queue to be notified of permissions being granted or * denied. In the case of pre-Android Marshmallow, permissions will be granted immediately. * The Activity variable is nullable, but if it is null, the method will fail to execute. * This is only nullable as a courtesy for Fragments where getActivity() may yeild null * if the Fragment is not currently added to its parent Activity. * * @param activity the activity necessary to request the permissions. * @param permissions the list of permissions to request for the {@link PermissionsResultAction}. * @param action the PermissionsResultAction to notify when the permissions are granted or denied. */ @SuppressWarnings("unused") public synchronized void requestPermissionsIfNecessaryForResult(@Nullable Activity activity, @NonNull String[] permissions, @Nullable PermissionsResultAction action) { if (activity == null) { return; } addPendingAction(permissions, action); if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { doPermissionWorkBeforeAndroidM(activity, permissions, action); } else { List<String> permList = getPermissionsListToRequest(activity, permissions, action); if (permList.isEmpty()) { //if there is no permission to request, there is no reason to keep the action int the list removePendingAction(action); } else { String[] permsToRequest = permList.toArray(new String[permList.size()]); mPendingRequests.addAll(permList); ActivityCompat.requestPermissions(activity, permsToRequest, 1); } } } /** * This method should be used to execute a {@link PermissionsResultAction} for the array * of permissions passed to this method. This method will request the permissions if * they need to be requested (i.e. we don't have permission yet) and will add the * PermissionsResultAction to the queue to be notified of permissions being granted or * denied. In the case of pre-Android Marshmallow, permissions will be granted immediately. * The Fragment variable is used, but if {@link Fragment#getActivity()} returns null, this method * will fail to work as the activity reference is necessary to check for permissions. * * @param fragment the fragment necessary to request the permissions. * @param permissions the list of permissions to request for the {@link PermissionsResultAction}. * @param action the PermissionsResultAction to notify when the permissions are granted or denied. */ @SuppressWarnings("unused") public synchronized void requestPermissionsIfNecessaryForResult(@NonNull Fragment fragment, @NonNull String[] permissions, @Nullable PermissionsResultAction action) { Activity activity = fragment.getActivity(); if (activity == null) { return; } addPendingAction(permissions, action); if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { doPermissionWorkBeforeAndroidM(activity, permissions, action); } else { List<String> permList = getPermissionsListToRequest(activity, permissions, action); if (permList.isEmpty()) { //if there is no permission to request, there is no reason to keep the action int the list removePendingAction(action); } else { String[] permsToRequest = permList.toArray(new String[permList.size()]); mPendingRequests.addAll(permList); fragment.requestPermissions(permsToRequest, 1); } } } /** * This method notifies the PermissionsManager that the permissions have change. If you are making * the permissions requests using an Activity, then this method should be called from the * Activity callback onRequestPermissionsResult() with the variables passed to that method. If * you are passing a Fragment to make the permissions request, then you should call this in * the {@link Fragment#onRequestPermissionsResult(int, String[], int[])} method. * It will notify all the pending PermissionsResultAction objects currently * in the queue, and will remove the permissions request from the list of pending requests. * * @param permissions the permissions that have changed. * @param results the values for each permission. */ @SuppressWarnings("unused") public synchronized void notifyPermissionsChange(@NonNull String[] permissions, @NonNull int[] results) { int size = permissions.length; if (results.length < size) { size = results.length; } Iterator<WeakReference<PermissionsResultAction>> iterator = mPendingActions.iterator(); while (iterator.hasNext()) { PermissionsResultAction action = iterator.next().get(); for (int n = 0; n < size; n++) { if (action == null || action.onResult(permissions , results )) { iterator.remove(); break; } } } for (int n = 0; n < size; n++) { mPendingRequests.remove(permissions ); } } /** * When request permissions on devices before Android M (Android 6.0, API Level 23) * Do the granted or denied work directly according to the permission status * * @param activity the activity to check permissions * @param permissions the permissions names * @param action the callback work object, containing what we what to do after * permission check */ private void doPermissionWorkBeforeAndroidM(@NonNull Activity activity, @NonNull String[] permissions, @Nullable PermissionsResultAction action) { for (String perm : permissions) { if (action != null) { if (!mPermissions.contains(perm)) { action.onResult(perm, Permissions.NOT_FOUND); } else if (ActivityCompat.checkSelfPermission(activity, perm) != PackageManager.PERMISSION_GRANTED) { action.onResult(perm, Permissions.DENIED); } else { action.onResult(perm, Permissions.GRANTED); } } } } /** * Filter the permissions list: * If a permission is not granted, add it to the result list * if a permission is granted, do the granted work, do not add it to the result list * * @param activity the activity to check permissions * @param permissions all the permissions names * @param action the callback work object, containing what we what to do after * permission check * @return a list of permissions names that are not granted yet */ @NonNull private List<String> getPermissionsListToRequest(@NonNull Activity activity, @NonNull String[] permissions, @Nullable PermissionsResultAction action) { List<String> permList = new ArrayList<>(permissions.length); for (String perm : permissions) { if (!mPermissions.contains(perm)) { if (action != null) { action.onResult(perm, Permissions.NOT_FOUND); } } else if (ActivityCompat.checkSelfPermission(activity, perm) != PackageManager.PERMISSION_GRANTED) { if (!mPendingRequests.contains(perm)) { permList.add(perm); } } else { if (action != null) { action.onResult(perm, Permissions.GRANTED); } } } return permList; } }这个类主要是获取单例下的权限管理类,然后通过内部方法进行权限管理
(3)PermissionsResultAction
package com.anthonycr.grant; import android.content.pm.PackageManager; import android.os.Handler; import android.os.Looper; import android.support.annotation.CallSuper; import android.support.annotation.NonNull; import android.util.Log; import java.util.Collections; import java.util.HashSet; import java.util.Set; /** * This abstract class should be used to create an if/else action that the PermissionsManager * can execute when the permissions you request are granted or denied. Simple use involves * creating an anonymous instance of it and passing that instance to the * requestPermissionsIfNecessaryForResult method. The result will be sent back to you as * either onGranted (all permissions have been granted), or onDenied (a required permission * has been denied). Ideally you put your functionality in the onGranted method and notify * the user what won't work in the onDenied method. */ public abstract class PermissionsResultAction { private static final String TAG = PermissionsResultAction.class.getSimpleName(); private final Set<String> mPermissions = new HashSet<>(1); private Looper mLooper = Looper.getMainLooper(); /** * Default Constructor */ public PermissionsResultAction() {} /** * Alternate Constructor. Pass the looper you wish the PermissionsResultAction * callbacks to be executed on if it is not the current Looper. For instance, * if you are making a permissions request from a background thread but wish the * callback to be on the UI thread, use this constructor to specify the UI Looper. * * @param looper the looper that the callbacks will be called using. */ @SuppressWarnings("unused") public PermissionsResultAction(@NonNull Looper looper) {mLooper = looper;} /** * This method is called when ALL permissions that have been * requested have been granted by the user. In this method * you should put all your permissions sensitive code that can * only be executed with the required permissions. */ public abstract void onGranted(); /** * This method is called when a permission has been denied by * the user. It provides you with the permission that was denied * and will be executed on the Looper you pass to the constructor * of this class, or the Looper that this object was created on. * * @param permission the permission that was denied. */ public abstract void onDenied(String permission); /** * This method is used to determine if a permission not * being present on the current Android platform should * affect whether the PermissionsResultAction should continue * listening for events. By default, it returns true and will * simply ignore the permission that did not exist. Usually this will * work fine since most new permissions are introduced to * restrict what was previously allowed without permission. * If that is not the case for your particular permission you * request, override this method and return false to result in the * Action being denied. * * @param permission the permission that doesn't exist on this * Android version * @return return true if the PermissionsResultAction should * ignore the lack of the permission and proceed with exection * or false if the PermissionsResultAction should treat the * absence of the permission on the API level as a denial. */ @SuppressWarnings({"WeakerAccess", "SameReturnValue"}) public synchronized boolean shouldIgnorePermissionNotFound(String permission) { Log.d(TAG, "Permission not found: " + permission); return true; } @SuppressWarnings("WeakerAccess") @CallSuper protected synchronized final boolean onResult(final @NonNull String permission, int result) { if (result == PackageManager.PERMISSION_GRANTED) { return onResult(permission, Permissions.GRANTED); } else { return onResult(permission, Permissions.DENIED); } } /** * This method is called when a particular permission has changed. * This method will be called for all permissions, so this method determines * if the permission affects the state or not and whether it can proceed with * calling onGranted or if onDenied should be called. * * @param permission the permission that changed. * @param result the result for that permission. * @return this method returns true if its primary action has been completed * and it should be removed from the data structure holding a reference to it. */ @SuppressWarnings("WeakerAccess") @CallSuper protected synchronized final boolean onResult(final @NonNull String permission, Permissions result) { mPermissions.remove(permission); if (result == Permissions.GRANTED) { if (mPermissions.isEmpty()) { new Handler(mLooper).post(new Runnable() { @Override public void run() { onGranted(); } }); return true; } } else if (result == Permissions.DENIED) { new Handler(mLooper).post(new Runnable() { @Override public void run() { onDenied(permission); } }); return true; } else if (result == Permissions.NOT_FOUND) { if (shouldIgnorePermissionNotFound(permission)) { if (mPermissions.isEmpty()) { new Handler(mLooper).post(new Runnable() { @Override public void run() { onGranted(); } }); return true; } } else { new Handler(mLooper).post(new Runnable() { @Override public void run() { onDenied(permission); } }); return true; } } return false; } /** * This method registers the PermissionsResultAction object for the specified permissions * so that it will know which permissions to look for changes to. The PermissionsResultAction * will then know to look out for changes to these permissions. * * @param perms the permissions to listen for */ @SuppressWarnings("WeakerAccess") @CallSuper protected synchronized final void registerPermissions(@NonNull String[] perms) { Collections.addAll(mPermissions, perms); } }这个类是用来做回调使用的,方便在调用过以后进行回调。
没有做翻译,如果看不懂,用翻译软件一点一点看把。
下面写一个例子,来进行示范:
public class SplashActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // requestWindowFeature(Window.FEATURE_NO_TITLE); //设置无标题 // getWindow().setFlags(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT); //设置全屏 setContentView(R.layout.activity_splash); requestAllPermission();//请求获取全部权限 } /** * 请求获取全部权限,调用权限管理类,然后放进去需要申请的权限,通过接口回调的方法获得权限获取结果 */ private void requestAllPermission() { PermissionsManager.getInstance().requestPermissionsIfNecessaryForResult(SplashActivity.this, ConstantString.permissions, new PermissionsResultAction() { @Override public void onGranted() { L.i("onGranted"); myHandler.sendEmptyMessage(GETPERMISSION_SUCCESS); } @Override public void onDenied(String permission) { L.i("onDenied"); myHandler.sendEmptyMessage(GETPERMISSION_FAILER); } }); } private static final int GETPERMISSION_SUCCESS = 1;//获取权限成功 private static final int GETPERMISSION_FAILER = 2;//获取权限失败 private MyHandler myHandler = new MyHandler(); private class MyHandler extends Handler { @Override public void handleMessage(Message msg) { super.handleMessage(msg); switch (msg.what) { case GETPERMISSION_SUCCESS: <span style="white-space:pre"> </span> startActivity(new Intent(SplashActivity.this,MainActivity.class)); break; case GETPERMISSION_FAILER: T.showShort(SplashActivity.this, "应用没有获取权限,请重新打开应用,或者到设置页面添加权限以后再从新打开。"); break; } } } //因为权限管理类无法监听系统,所以需要重写onRequestPermissionResult方法,更新权限管理类,并回调结果。这个是必须要有的。 @Override public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { PermissionsManager.getInstance().notifyPermissionsChange(permissions, grantResults); } }
看过上面的代码以后是不是觉得6.0的权限管理变的简单了,但是还有更见的一个方法 requestAllManifestPermissionIfNecessary() 这个方法会自动查询清单文件当中申请的权限,然后自动调取系统的权限获取方法,一次解决所有问题。
上述方式用来解决权限管理对于大家的代码结构会有很大的提升,同时减少大家的代码量,期望给大家更多的问题解决方案。
相关文章推荐
- Android6.0权限管理之开源项目Grant
- ASP.NET通用权限管理系统(FrameWork) 0.9.0 Beta (开源项目)
- ASP.NET通用权限管理系统(FrameWork) 0.9.0 Beta (开源项目)
- Android6.0权限管理-开源框架源码分析
- [ABP开源项目]--vue+vuex+vue-router+EF的权限管理系统
- 免费或开源的项目管理工具
- Linux/Unix中的SUID和SGID文件权限和在CVS项目管理中的应用
- 中小型项目的权限管理的数据关系图
- Asp.net RBAC membership framework For Visual Studio 2005 免费开源的Asp.net 权限管理系统 发布预告
- 开源jsp权限管理,实现代码
- dotproject 是一个很不错开源项目管理系统
- 朗志轻量级项目管理解决方案-RBAC角色权限模块介绍
- Java语言介绍(04)开源项目(07)项目管理工具(01)XPlanner
- 使用VS2008+SVN插件配合Google Code搭建自己的开源项目管理
- 软件项目管理系统:项目资料模块权限分配设计文档
- [开源]ASP.NET通用权限管理系统(FrameWork) 1.0.2 Release
- DotProject开源项目管理(http://blog.csdn.net/yuandj)
- 设计模式的项目----权限管理系统
- 一个管理TFS权限的工具,同时管理项目sharepoint和report
- 采用ruby on rails语言开发的开源项目管理工具redmine