Luego de investigar en varios repositorios y sitios webs de internet al concluir hemos descubierto la respuesta que te enseñamos pronto.
Solución:
Después de M Preview 1, si se muestra el cuadro de diálogo por primera vez, no hay Nunca preguntes de nuevo caja.
Si el usuario deniega la solicitud de permiso, habrá un Nunca preguntes de nuevo casilla de verificación en el diálogo de permisos la segunda vez se solicita permiso.
Entonces la lógica debería ser así:
-
Solicitar permiso:
if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) ActivityCompat.requestPermissions(context, new String[]Manifest.permission.WRITE_EXTERNAL_STORAGE, REQUEST_CODE); else //Do the stuff that requires permission... -
Compruebe si el permiso fue denegado o concedido en
onRequestPermissionsResult.Si el permiso fue denegado previamente, esta vez habrá un Nunca preguntes de nuevo casilla de verificación en el diálogo de permisos.
Llama
shouldShowRequestPermissionRationalepara ver si el usuario marcó Nunca preguntes de nuevo.shouldShowRequestPermissionRationaledevuelve el método false solo si el usuario seleccionó Nunca preguntes de nuevo o la política del dispositivo prohíbe que la aplicación tenga ese permiso:if (grantResults.length > 0) if(grantResults[0] == PackageManager.PERMISSION_GRANTED) //Do the stuff that requires permission... else if (grantResults[0] == PackageManager.PERMISSION_DENIED) // Should we show an explanation? if (ActivityCompat.shouldShowRequestPermissionRationale(context, Manifest.permission.WRITE_EXTERNAL_STORAGE)) //Show permission explanation dialog... else //Never ask again selected, or device policy prohibits the app from having that permission. //So, disable that feature, or fall back to another situation...
Por lo tanto, no tendrá que realizar un seguimiento si un usuario marcó Nunca preguntes de nuevo o no.
Tuve el mismo problema y lo resolví. Para hacer la vida mucho más simple, escribí una clase de utilidad para manejar los permisos de tiempo de ejecución.
public class PermissionUtil
/*
* Check if version is marshmallow and above.
* Used in deciding to ask runtime permission
* */
public static boolean shouldAskPermission()
return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M);
private static boolean shouldAskPermission(Context context, String permission)
if (shouldAskPermission())
int permissionResult = ActivityCompat.checkSelfPermission(context, permission);
if (permissionResult != PackageManager.PERMISSION_GRANTED)
return true;
return false;
public static void checkPermission(Context context, String permission, PermissionAskListener listener)
/*
* If permission is not granted
* */
if (shouldAskPermission(context, permission))
/*
* If permission denied previously
* */
if (((Activity) context).shouldShowRequestPermissionRationale(permission))
listener.onPermissionPreviouslyDenied();
else
/*
* Permission denied or first time requested
* */
if (PreferencesUtil.isFirstTimeAskingPermission(context, permission))
PreferencesUtil.firstTimeAskingPermission(context, permission, false);
listener.onPermissionAsk();
else
/*
* Handle the feature without permission or ask user to manually allow permission
* */
listener.onPermissionDisabled();
else
listener.onPermissionGranted();
/*
* Callback on various cases on checking permission
*
* 1. Below M, runtime permission not needed. In that case onPermissionGranted() would be called.
* If permission is already granted, onPermissionGranted() would be called.
*
* 2. Above M, if the permission is being asked first time onPermissionAsk() would be called.
*
* 3. Above M, if the permission is previously asked but not granted, onPermissionPreviouslyDenied()
* would be called.
*
* 4. Above M, if the permission is disabled by device policy or the user checked "Never ask again"
* check box on previous request permission, onPermissionDisabled() would be called.
* */
public interface PermissionAskListener
/*
* Callback to ask permission
* */
void onPermissionAsk();
/*
* Callback on permission denied
* */
void onPermissionPreviouslyDenied();
/*
* Callback on permission "Never show again" checked and denied
* */
void onPermissionDisabled();
/*
* Callback on permission granted
* */
void onPermissionGranted();
Y el PreferenceUtil Los métodos son los siguientes.
public static void firstTimeAskingPermission(Context context, String permission, boolean isFirstTime)
SharedPreferences sharedPreference = context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE;
sharedPreference.edit().putBoolean(permission, isFirstTime).apply();
public static boolean isFirstTimeAskingPermission(Context context, String permission)
return context.getSharedPreferences(PREFS_FILE_NAME, MODE_PRIVATE).getBoolean(permission, true);
Ahora, todo lo que necesitas es usar el método checkPermission con argumentos adecuados.
Aquí hay un ejemplo,
PermissionUtil.checkPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE,
new PermissionUtil.PermissionAskListener()
@Override
public void onPermissionAsk()
ActivityCompat.requestPermissions(
thisActivity,
new String[]Manifest.permission.READ_CONTACTS,
REQUEST_EXTERNAL_STORAGE
);
@Override
public void onPermissionPreviouslyDenied()
//show a dialog explaining permission and then request permission
@Override
public void onPermissionDisabled()
Toast.makeText(context, "Permission Disabled.", Toast.LENGTH_SHORT).show();
@Override
public void onPermissionGranted()
readContacts();
);
Caso 1: La aplicación no tiene permiso y no se le ha pedido permiso al usuario antes. En este caso, shouldShowRequestPermissionRationale () devolverá false porque es la primera vez que le preguntamos al usuario.
Caso 2: el usuario ha denegado el permiso y ha seleccionado “No volver a preguntar”, en este caso también debería devolver el resultado shouldShowRequestPermissionRationale () false.
Me gustaría enviar al usuario a la página de configuración de la aplicación en el Caso 2. ¿Cómo puedo diferenciar estos dos casos?
Recibirás la devolución de llamada onPermissionAsk para el caso 1, y onPermissionDisabled para el caso 2.
Feliz codificación 🙂
ACTUALIZAR
Creo que la respuesta de CanC a continuación es la correcta que debe seguirse. La única forma de saberlo con certeza es verificar esto en la devolución de llamada onRequestPermissionResult usando shouldShowPermissionRationale.
==
Mi respuesta original:
La única forma que he encontrado es realizar un seguimiento por su cuenta de si es la primera vez o no (por ejemplo, utilizando preferencias compartidas). Si no es la primera vez, utilice shouldShowRequestPermissionRationale() para diferenciar.
Consulte también: Android M – comprobar el permiso de ejecución – ¿cómo determinar si el usuario marcó “No volver a preguntar”?