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.");
  }
}}

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);
  }
}

@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);
}