android¿ª·¢È¨ÏÞѯÎʵÄʾÀý´úÂë

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