android开发权限询问的示例代码

现在基于信息安全问题，特别是版本是23以上权限越严格。

特别是拍照，读，写权限

一般权限允许过，下次就不用询问了的，所以很多应用都喜欢在首页或者启动页直接询问，不允许的就用不了1、下面给出封装好的类，至于什么时候调看项目需要

public class EasyPermissions {

private static final String TAG = "EasyPermissions";

public interface PermissionCallbacks extends
   ActivityCompat.OnRequestPermissionsResultCallback {

void onPermissionsGranted(List<String> perms);

void onPermissionsDenied(List<String> perms);

}

/**
* Check if the calling context has a set of permissions.
*
* @param context the calling context.
* @param perms  one ore more permissions, such as {@code android.Manifest.permission.CAMERA}.
* @return true if all permissions are already granted, false if at least one permission
* is not yet granted.
*/
public static boolean hasPermissions(Context context, String... perms) {
 for (String perm : perms) {
   boolean hasPerm = (ContextCompat.checkSelfPermission(context, perm) == PackageManager.PERMISSION_GRANTED);
   if (!hasPerm) {
     return false;
   }
 }

return true;
}

/**
* Request a set of permissions, showing rationale if the system requests it.
*
* @param object   Activity or Fragment requesting permissions. Should implement
*          {@link ActivityCompat.OnRequestPermissionsResultCallback}
*          or
*          {@link android.support.v13.app.FragmentCompat.OnRequestPermissionsResultCallback}
* @param rationale  a message explaining why the application needs this set of permissions, will
*          be displayed if the user rejects the request the first time.
* @param requestCode request code to track this request, must be < 256.
* @param perms    a set of permissions to be requested.
*/
public static void requestPermissions(final Object object, String rationale,
   final int requestCode, final String... perms) {
 requestPermissions(object, rationale,
     android.R.string.ok,
     android.R.string.cancel,
     requestCode, perms);
}

/**
* Request a set of permissions, showing rationale if the system requests it.
*
* @param object     Activity or Fragment requesting permissions. Should implement
*            {@link ActivityCompat.OnRequestPermissionsResultCallback}
*            or
*            {@link android.support.v13.app.FragmentCompat.OnRequestPermissionsResultCallback}
* @param rationale   a message explaining why the application needs this set of permissions, will
*            be displayed if the user rejects the request the first time.
* @param positiveButton custom text for positive button
* @param negativeButton custom text for negative button
* @param requestCode  request code to track this request, must be < 256.
* @param perms     a set of permissions to be requested.
*/
public static void requestPermissions(final Object object, String rationale,
   @StringRes int positiveButton,
   @StringRes int negativeButton,
   final int requestCode, final String... perms) {

checkCallingObjectSuitability(object);

boolean shouldShowRationale = false;
 for (String perm : perms) {
   shouldShowRationale = shouldShowRationale || shouldShowRequestPermissionRationale(object, perm);
 }

if (shouldShowRationale) {
   //弹框询问
   AlertDialog dialog = new AlertDialog.Builder(getActivity(object))
       .setMessage(rationale)
       .setPositiveButton(positiveButton, new DialogInterface.OnClickListener() {
         @Override
         public void onClick(DialogInterface dialog, int which) {
           executePermissionsRequest(object, perms, requestCode);
         }
       })
       .setNegativeButton(negativeButton, new DialogInterface.OnClickListener() {
         @Override
         public void onClick(DialogInterface dialog, int which) {
           // Do nothing, user does not want to request
           PermissionCallbacks callbacks = (PermissionCallbacks) object;
           if(callbacks != null) {
             callbacks.onPermissionsDenied(new ArrayList<String>());
           }
         }
       }).create();
   dialog.show();
 } else {
   executePermissionsRequest(object, perms, requestCode);
 }
}

/**
* Handle the result of a permission request, should be called from the calling Activity's
* {@link ActivityCompat.OnRequestPermissionsResultCallback#onRequestPermissionsResult(int, String[], int[])}
* method.
* <p/>
* If any permissions were granted or denied, the Activity will receive the appropriate
* callbacks through {@link PermissionCallbacks} and methods annotated with
* {@link AfterPermissionGranted} will be run if appropriate.
*
* @param requestCode requestCode argument to permission result callback.
* @param permissions permissions argument to permission result callback.
* @param grantResults grantResults argument to permission result callback.
* @param object    the calling Activity or Fragment.
* @throws IllegalArgumentException if the calling Activity does not implement
*                 {@link PermissionCallbacks}.
*/
public static void onRequestPermissionsResult(int requestCode, String[] permissions,
   int[] grantResults, Object object) {

checkCallingObjectSuitability(object);
 PermissionCallbacks callbacks = (PermissionCallbacks) object;

// Make a collection of granted and denied permissions from the request.
 ArrayList<String> granted = new ArrayList<>();
 ArrayList<String> denied = new ArrayList<>();
 for (int i = 0; i < permissions.length; i++) {
   String perm = permissions[i];
   if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
     granted.add(perm);
   } else {
     denied.add(perm);
   }
 }

// Report granted permissions, if any.
 if (!granted.isEmpty()) {
   // Notify callbacks
   callbacks.onPermissionsGranted(granted);
 }

// Report denied permissions, if any.
 if (!denied.isEmpty()) {
   callbacks.onPermissionsDenied(denied);
 }

// If 100％ successful, call annotated methods
 if (!granted.isEmpty() && denied.isEmpty()) {
   runAnnotatedMethods(object, requestCode);
 }
}

private static boolean shouldShowRequestPermissionRationale(Object object, String perm) {
 if (object instanceof Activity) {
   return ActivityCompat.shouldShowRequestPermissionRationale((Activity) object, perm);
 } else if (object instanceof Fragment) {
   return ((Fragment) object).shouldShowRequestPermissionRationale(perm);
 } else {
   return false;
 }
}

private static void executePermissionsRequest(Object object, String[] perms, int requestCode) {
 checkCallingObjectSuitability(object);

if (object instanceof Activity) {
   ActivityCompat.requestPermissions((Activity) object, perms, requestCode);
 } else if (object instanceof Fragment) {
   ((Fragment) object).requestPermissions(perms, requestCode);
 }
}

private static Activity getActivity(Object object) {
 if (object instanceof Activity) {
   return ((Activity) object);
 } else if (object instanceof Fragment) {
   return ((Fragment) object).getActivity();
 } else {
   return null;
 }
}

private static void runAnnotatedMethods(Object object, int requestCode) {
 Class clazz = object.getClass();
 for (Method method : clazz.getDeclaredMethods()) {
   if (method.isAnnotationPresent(AfterPermissionGranted.class)) {
     // Check for annotated methods with matching request code.
     AfterPermissionGranted ann = method.getAnnotation(AfterPermissionGranted.class);
     if (ann.value() == requestCode) {
       // Method must be void so that we can invoke it
       if (method.getParameterTypes().length > 0) {
         throw new RuntimeException("Cannot execute non-void method " + method.getName());
       }

try {
         // Make method accessible if private
         if (!method.isAccessible()) {
           method.setAccessible(true);
         }
         method.invoke(object);
       } catch (IllegalAccessException e) {
         ILogger.e(TAG, "runDefaultMethod:IllegalAccessException", e);
       } catch (InvocationTargetException e) {
         ILogger.e(TAG, "runDefaultMethod:InvocationTargetException", e);
       }
     }
   }
 }
}

private static void checkCallingObjectSuitability(Object object) {
 // Make sure Object is an Activity or Fragment
 if (!((object instanceof Fragment) || (object instanceof Activity))) {
   throw new IllegalArgumentException("Caller must be an Activity or a Fragment.");
 }

// Make sure Object implements callbacks
 if (!(object instanceof PermissionCallbacks)) {
   throw new IllegalArgumentException("Caller must implement PermissionCallbacks.");
 }
}}

注：这个类不是我写的，分享给大家

2、调用示例（activity或fragment）：（方法调用的时机随你）

private void requestGalleryPermission() {
 //权限参数可以添加很多，不固定参数的
 if (EasyPermissions.hasPermissions(this, Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
   getPhotos();//如果具有权限做的操作
 } else {
   // Ask for one permission
   EasyPermissions.requestPermissions(this, getString(R.string.permissions_tips_gallery),
       GalleryFinal.PERMISSIONS_CODE_GALLERY, Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE);
 }
}

3、拒绝和允许做的操作（activity或fragment）：

@Override
public void onPermissionsGranted(List<String> list) {
 //允许
 getPhotos();
}

@Override
public void onPermissionsDenied(List<String> list) {
 //拒绝
 mTvEmptyView.setText(R.string.permissions_denied_tips);
 //mIvTakePhoto.setVisibility(View.GONE);
}

来源：https://www.jianshu.com/p/fbfa785ed6ce