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