@Test public void onPermissionDeniedDoSequentialCheckPermissionThenNotifiesListener()
    throws InterruptedException {
  givenPermissionIsAlreadyDenied(ANY_PERMISSION);
  givenShouldShowRationaleForPermission(ANY_PERMISSION);
  PermissionListener checkPermissionOnDeniedPermissionListener =
      givenARetryCheckPermissionOnDeniedPermissionListener(permissionListener);

  whenCheckPermission(checkPermissionOnDeniedPermissionListener, ANY_PERMISSION);
  dexter.onPermissionRequestDenied(Collections.singletonList(ANY_PERMISSION));

  asyncExecutor.waitForExecution();
  thenPermissionIsDenied(ANY_PERMISSION);
}
 

@Override public void check(final PermissionListener listener, final String permission) {
  dexter.checkPermission(listener, permission, THREAD);
  asyncExecutor.execute(new Runnable() {
    @Override public void run() {
      dexter.onActivityReady(activity);
      dexter.onPermissionRequestDenied(Collections.singletonList(permission));
    }
  });
}
 

@Override
public void askForPermission(@NonNull Permission permission,
                             @NonNull UserPermissionRequestResponseListener userResponse, @NonNull Activity activity) {

    PermissionListener[] listeners = createListeners(permission, userResponse, activity);
    Dexter.withActivity(activity)
            .withPermission(permission.getAndroidPermissionStringType())
            .withListener(new CompositePermissionListener(listeners))
            .check();
}
 

private PermissionListener[] createListeners(Permission permission,
                                             UserPermissionRequestResponseListener userResponse, Activity activity) {

    PermissionListener basicListener = getPermissionListenerImpl(permission, userResponse);

    try {
        ViewGroup viewGroup = PermissionsUIViews.getAppContainer(activity);
        PermissionListener listener = getDefaultDeniedPermissionListener(viewGroup, permission);
        return new PermissionListener[]{basicListener, listener};
    } catch (NullContainerException n) {
        return new PermissionListener[]{basicListener};
    }
}
 

private PermissionListener getDefaultDeniedPermissionListener(ViewGroup rootView,
                                                              Permission permission) {

    return SnackbarOnDeniedPermissionListener.Builder.with(rootView,
            permission.getPermissionRationaleMessage())
            .withOpenSettingsButton(permission.getPermissionSettingsDeniedFeedback())
            .build();
}
 

MultiplePermissionsListenerToPermissionListenerAdapter(PermissionListener listener) {
  this.listener = listener;
}
 

@Override public DexterBuilder withListener(PermissionListener listener) {
  this.listener = new MultiplePermissionsListenerToPermissionListenerAdapter(listener);
  return this;
}
 

private void checkSinglePermission(PermissionListener listener, String permission,
    Thread thread) {
  MultiplePermissionsListener adapter =
      new MultiplePermissionsListenerToPermissionListenerAdapter(listener);
  checkMultiplePermissions(adapter, Collections.singleton(permission), thread);
}
 

private PermissionListener givenARetryCheckPermissionOnDeniedPermissionListener(
    PermissionListener permissionListener) {
  return new RetryCheckPermissionOnDeniedPermissionListener(permissionListener,
      new CheckPermissionWithOnActivityReadyInBackground());
}
 

private void whenCheckPermission(PermissionListener permissionListener, String permission) {
  dexter.checkPermission(permissionListener, permission, THREAD);
  dexter.onActivityReady(activity);
}
 

public RetryCheckPermissionOnDeniedPermissionListener(PermissionListener listener,
    CheckPermissionAction checkPermission) {
  this.listener = listener;
  this.checkPermission = checkPermission;
}
 

private PermissionListener getPermissionListenerImpl(final Permission permission,
                                                     final UserPermissionRequestResponseListener userPermissionRequestResponseListener) {
    return new GenericPermissionListenerImpl(permission, userPermissionRequestResponseListener,
            contextProvider);
}
 

/**
 * Checks the state of a specific permission reporting it when ready to the listener.
 *
 * @param listener The class that will be reported when the state of the permission is ready
 * @param permission One of the values found in {@link android.Manifest.permission}
 * @param thread thread the Listener methods will be called on
 */
void checkPermission(PermissionListener listener, String permission, Thread thread) {
  checkSinglePermission(listener, permission, thread);
}
 

DexterBuilder withListener(PermissionListener listener); 

void check(PermissionListener listener, String permission);