private void finalizeAction(Permissive.Action action) { Context context = action.getContext(); if (context != null) { final int[] grants = getPermissionGrants(context, action.getPermissions()); fireActionCallbacks(action, new RequestPermissionsResult(action.getPermissions(), grants)); } }
private boolean showRationaleForRequest(Permissive.Request request) { Activity activity = request.getContext(); if (null == activity) { return false; } final String[] rationalePermissions = Permissive.getPermissionsRequiringRationale(activity, request.getPermissions()); if (request.shouldDisplayRationale()) { final PermissiveMessenger messenger = new PermissiveMessenger(handler, request.getPermissions()); return request.showRationale(rationalePermissions, messenger) && !request.rebuild; } return false; }
protected void firePermissionsRefusedListener(String[] refusedPermissions) { final PermissionsRefusedListener listener = getPermissionsRefusedListener(); if (listener != null) { listener.onPermissionsRefused(refusedPermissions); } }
public void educateForLocationPermission(View view) { new Permissive.Request(Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION) .showRationaleFirst(true) .withRationale(new EducateInContextFragment()) .whenPermissionsGranted(this::onPermissionsGranted) .whenPermissionsRefused(this::onPermissionsRefused) .execute(this); }
public void askForCameraPermission(View view) { new Permissive.Request(Manifest.permission.CAMERA) .withRationale(new AskInContextFragment()) .whenPermissionsGranted(this::onPermissionsGranted) .whenPermissionsRefused(this::onPermissionsRefused) .execute(this); }
@Override public void onResume() { super.onResume(); if (Permissive.filterPermissions(getContext(), getPermissiveMessenger().getRequestedPermissions(), PackageManager.PERMISSION_GRANTED).length > 0) { // if user granted permission via Settings, then finish this fragment finishFragment(); } }
/** * Executes this Request with a given Activity context. * * <p>Keep in mind, that if the activity disappears, then the Request will not be executed.</p> * * @param activity The Activity context which is saved as weak reference. */ @Override public void execute(Activity activity) { super.execute(activity); }
private void fireActionCallbacks(Permissive.Action action, RequestPermissionsResult result) { if (action != null) { if (result.grantedPermissions.length > 0) { action.firePermissionsGrantedListener(result.grantedPermissions); } if (result.refusedPermissions.length > 0) { action.firePermissionsRefusedListener(result.refusedPermissions); } action.firePermissionsResultListener(result.grantedPermissions, result.refusedPermissions); } }
private boolean processPermissionsResultFor(Permissive.Action action, RequestPermissionsResult result) { if (action instanceof Permissive.Request) { Permissive.Request request = (Permissive.Request) action; if (result.hasAnyRefusedPermissions() && showRationaleForRequest(request)) { return true; } } else { Log.e(TAG, "No request could receive result: " + action); } finalizeAction(action); return false; }
protected void firePermissionsResultListener(String[] grantedPermissions, String[] refusedPermissions) { final PermissionsResultListener listener = getPermissionsResultListener(); if (listener != null) { listener.onPermissionsResult(grantedPermissions, refusedPermissions); } }
protected void firePermissionsGrantedListener(String[] grantedPermissions) { final PermissionsGrantedListener listener = getPermissionsGrantedListener(); if (listener != null) { listener.onPermissionsGranted(grantedPermissions); } }
/** * Sends a message to repeat current request. * * @return {@code true} if the message was sent. Otherwise is {@code false}. */ public synchronized boolean repeatRequest() { return repeatRequest(false); }
private boolean restoreActivity() { return sendMsg(PermissiveHandler.RESTORE_ACTIVITY, getActivity()); }
/** * Recreates the request object with identical set of permissions to be requested. * No listeners or other settings are restored. * * <p>It may be required to execute the request again, when the process is killed. * Then, all requests and actions are lost, but activities and fragments are restored. * Also, it may happen, that a rationale or even the Android permission request is restored, * so we should rebuild old {@link Permissive.Request} to handle pending request.</p> * * @return Rebuilt request object. */ public Permissive.Request rebuildRequest() { return new Permissive.Request(true, permissions); }
protected boolean showRationale(String[] permissions, PermissiveMessenger messenger) { shouldDisplayRationale = false; Rationale rationale; if (rationaleRef != null && (rationale = rationaleRef.get()) != null) { rationale.onShowRationale(getContext(), permissions, messenger); return true; } // show globally registered rationale, if any return Permissive.fireGlobalRationale(getContext(), permissions, messenger); }
@Override public String toString() { String str = super.toString(); return str.substring(0, str.length() - 1) + ", rationaleListener=" + getRationale() + '}'; }
/** * Checks whether you have been granted a particular permission. * This method is similar to {@link Context#checkSelfPermission(String)}, * but returns a boolean value instead of integer value. * * @param context Provide a context. Can't be {@code null}. * @param permission A permission that should be checked. Can't be {@code null}. * @return {@code true} when permission is granted, otherwise {@code false}. */ public static boolean checkPermission(Context context, String permission) { return checkPermissionInt(context, permission) == PackageManager.PERMISSION_GRANTED; }
/** * Returns {@code true} when there are currently any pending actions or requests. * * <p>Note: The method is temporary and can be deleted soon. */ public static boolean hasPendingActions() { return permissiveHandler.hasPendingActions(); }
private boolean sendMsg(int what) { return sendMsg(what, null); }
private static int[] getPermissionGrants(Context context, String[] permissions) { final int[] grantResults = new int[permissions.length]; final int permissionCount = permissions.length; for (int i = 0; i < permissionCount; i++) { grantResults[i] = Permissive.checkPermissionInt(context, permissions[i]); } return grantResults; }