Permisos de tiempo de ejecución de Android con AndroidX RequestPermission ejemplo simple de contrato | Autor: ChandraSaiMohan bhupathi | Agosto de 2021

explicar:

Asistente de permisos:

Esta clase contiene varios métodos para manejar los permisos en tiempo de ejecución. Esta categoría es el único punto de contacto para todo el procesamiento de permisos en tiempo de ejecución. Activity / Fragment puede usar esta clase auxiliar para manejar todos los permisos de tiempo de ejecución.

1. Determine si se han concedido permisos a la aplicación:

ContextCompat.checkSelfPermission (): Verifique si el usuario le ha otorgado permisos específicos a su aplicación.

Este método devuelve PERMISSION_GRANTED Cualquiera PERMISSION_DENIED, Dependiendo de si su aplicación tiene permisos.

Este es el primer método que debe llamarse como parte de la verificación de si se otorga un permiso en particular.

Ejemplo de código de los pasos anteriores:

context?.requireContext()?.let 
ContextCompat.checkSelfPermission(
it,
manifestPermission
)
 == PackageManager.PERMISSION_GRANTED -> 
println("Permission Granted....")

Donde Contexto ¿Es el contexto del fragmento y Permisos de lista Es necesario verificar si se otorga el permiso, que debe declararse en el archivo de manifiesto.

En este ejemplo «manifestPermission «es Lista. Permisos.cámara.

2. Explique por qué la aplicación requiere permisos:

En los pasos anteriores, si «ContextCompat.checkSelfPermission ()» Devuelve el método PERMISSION_DENIEDY luego llama shouldShowRequestPermissionRationale ().Si este método regresa true, Para mostrar la IU educativa al usuario. En esta interfaz de usuario, describa por qué la función que el usuario desea habilitar requiere permisos específicos.

En esta aplicación, mostraré un cuadro de diálogo de advertencia que muestra el propósito de los permisos. Si el usuario hace clic en el botón «Aceptar» en el cuadro de diálogo de alerta, veré el cuadro de diálogo de permisos del sistema para otorgar / denegar permisos.

ActivityCompat.shouldShowRequestPermissionRationale(
context?.requireContext() as Activity,
manifestPermission
) -> 
println("Show Request Permission Rationale")
//Display Alert Dialog.

3. Solicite permiso:

Después de que el usuario ve la IU educativa (en nuestro caso, el cuadro de diálogo de alerta), si el usuario hace clic en el botón «Aceptar» en el cuadro de diálogo de alerta para solicitar permiso nuevamente, verá un cuadro de diálogo de permisos del sistema en el que puede Elija si desea otorgar permisos específicos a su aplicación.

Nota IMPORTANTE:

Tradicionalmente, podemos administrar el código de solicitud nosotros mismos como parte de la solicitud de permiso e incluir este código de solicitud en su lógica de devolución de llamada de permiso.

Otra opción es utilizar el contrato RequestPermission incluido en la biblioteca de AndroidX, donde puede permitir que el sistema administre el código de solicitud de permiso por usted. Debido a que usar el contrato RequestPermission puede simplificar su lógica, se recomienda que lo use siempre que sea posible.

Solicitar contrato de permiso:

El contrato RequestPermission contiene 2 categorías:

Pedir permiso:Solicitar permiso único

2. Solicite múltiples permisos:Solicite múltiples permisos al mismo tiempo.

En la lógica de inicialización de su actividad o fragmento, pase una implementación ActivityResultCallback llamada registerForActivityResult(). Esta ActivityResultCallback Defina cómo su aplicación maneja las respuestas de los usuarios a las solicitudes de permisos.

Mantenga una referencia al valor de retorno registerForActivityResult(), Este es el tipo ActivityResultLauncher.

Para mostrar el cuadro de diálogo de permisos del sistema cuando sea necesario, llame launch() Método en la instancia ActivityResultLauncher Guardaste en el paso anterior.

Ejemplo de código de los pasos anteriores:

Pedir permiso:

private val requestPermissionLauncher =
context.registerForActivityResult(
ActivityResultContracts.RequestPermission()
    )  isGranted: Boolean ->
if (isGranted) 
Log.i("Permission: ", "Granted")
 else 
Log.i("Permission: ", "Denied")

Solicitar múltiples permisos

private val requestMultiplePermissionsLauncher = context.registerForActivityResult(
ActivityResultContracts.RequestMultiplePermissions()
)  permissions ->
permissions.entries.forEach 
Log.i("DEBUG", "$it.key = $it.value")
if(it.value)
println("Successful......")

Utilice start ():

fun launchPermissionDialogForMultiplePermissions(manifestPermissions: Array<String>)
requestMultiplePermissionsLauncher.launch(manifestPermissions)
 fun launchPermissionDialog(manifestPermission: String)
requestPermissionLauncher.launch(
manifestPermission
)

Donde Permisos de lista: Una matriz de múltiples permisos. (En nuestro ejemplo es leer y escribir contactos)

Donde Permisos de lista: Es un permiso único (cámara en nuestro caso)

Asistente de permisos: Pon todo lo discutido anteriormente en una clase

class PermissionHelper(context: Fragment,permissionListener: PermissionListener) {
private var context: Fragment? = null
private var permissionListener : PermissionListener? = null
init 
this.context = context
this.permissionListener = permissionListener
private val requestPermissionLauncher =
context.registerForActivityResult(
ActivityResultContracts.RequestPermission()
)  isGranted: Boolean ->
if (isGranted) 
Log.i("Permission: ", "Granted")
permissionListener?.isPermissionGranted(true)
 else 
Log.i("Permission: ", "Denied")

private val requestMultiplePermissionsLauncher = context.registerForActivityResult(
ActivityResultContracts.RequestMultiplePermissions()
)  permissions ->
permissions.entries.forEach 
Log.i("DEBUG", "$it.key = $it.value")
if(it.value)
println("Successful......")
permissionListener?.isPermissionGranted(true)


fun checkForPermissions(manifestPermission: String) 
when 
context?.requireContext()?.let 
ContextCompat.checkSelfPermission(
it,
manifestPermission
)
 == PackageManager.PERMISSION_GRANTED -> 
println("Permission Granted....")
permissionListener?.isPermissionGranted(true)
ActivityCompat.shouldShowRequestPermissionRationale(
context?.requireContext() as Activity,
manifestPermission
) -> 
println("Show Request Permission Rationale")
permissionListener?.isPermissionGranted(false)
permissionListener?.shouldShowRationaleInfo()
else -> 
launchPermissionDialog(manifestPermission)
println("Final Else....")


private var isDenied : Boolean  = false
fun checkForMultiplePermissions(manifestPermissions: Array<String>) 
for (permission in manifestPermissions) 
context?.requireContext()?.let 
if (ContextCompat.checkSelfPermission(
it,
permission
) == PackageManager.PERMISSION_GRANTED
) 
println("Permission Granted....")
permissionListener?.isPermissionGranted(true)
 else if (ActivityCompat.shouldShowRequestPermissionRationale(
context?.requireContext() as Activity,
permission
)
) 
isDenied = true
//    requestMultiplePermissionsLauncher.launch(manifestPermissions)
 else 
requestMultiplePermissionsLauncher.launch(manifestPermissions)



if(isDenied)
permissionListener?.isPermissionGranted(false)
permissionListener?.shouldShowRationaleInfo()

fun launchPermissionDialogForMultiplePermissions(manifestPermissions: Array<String>)
requestMultiplePermissionsLauncher.launch(manifestPermissions)

fun launchPermissionDialog(manifestPermission: String)
requestPermissionLauncher.launch(
manifestPermission
)

}

En lo anterior, tenemos dos funciones para tratar con permisos únicos / múltiples, como parte del propósito de la explicación:

fun checkForMultiplePermissions(manifestPermissions: Array<String>)
//Handles Multiple permissions logicfun checkForPermissions() // To handle single permission logic

Oyente de permiso: Esta es una interfaz implementada en Fragmento / Actividad, que se utiliza para mostrar un cuadro de diálogo de alerta (mostrar información sobre la importancia de los permisos) al otorgar permisos, o para encender la cámara o permitir la lectura / escritura de contactos.

interface PermissionListener 
fun   shouldShowRationaleInfo()
fun   isPermissionGranted(isGranted : Boolean)

Fragmento de permiso de la cámara:

Si se concede el permiso, se permite el acceso a las imágenes de la cámara. También contiene un botón para navegar a la siguiente pantalla.

Aquí es donde inicializamos la clase PermissionHelper y manejamos las devoluciones de llamada para mostrar el AlertDialog e iniciar la cámara.

Asistente de inicialización de permisos:

//Initialize PermissionHelper
permissionHelper =  PermissionHelper(this,this)//Make call to singlePermission logicpermissionHelper.checkForPermissions(Manifest.permission.CAMERA)

Leer y escribir fragmentos de contactos:

Este fragmento demuestra el acceso a múltiples permisos en tiempo de ejecución y permite leer / escribir contactos desde el dispositivo cuando se otorgan permisos.

permissionHelper =  PermissionHelper(this, this)permissionHelper.checkForMultiplePermissions(
arrayOf(
Manifest.permission.READ_CONTACTS,
Manifest.permission.WRITE_CONTACTS
)
)

En el ejemplo de código anterior, inicializamos PermissionHelper y llamamos al método checkForMultiplePermissions (), que declara la matriz de permisos en el manifiesto.

Felicidades:

En este blog, presentamos los siguientes métodos para manejar permisos en tiempo de ejecución en aplicaciones de Android Solicitar contrato de permiso, incluido en la biblioteca de AndroidX En lugar de manejarlo usted mismo, use un ejemplo simple para simplificar el manejo de permisos.

PermissionsHelper se puede incluir en cualquier proyecto para manejar los permisos de tiempo de ejecución y personalizarlos según las necesidades de la devolución de llamada.

Referirse a:

https://developer.android.com/training/permissions/requesting

https://developer.android.com/guide/topics/permissions/overview#runtime