[Permissions] status.shouldShowRationale is always false by default #1066

Activity

1. madhurgupta10

   assigned

   manuelvicnt

   on Mar 6, 2022
2. jari-kuipers commented on Mar 9, 2022

   

   jari-kuipers

   on Mar 9, 2022

   More actions

   Also encountering this.
3. manuelvicnt commented on Mar 10, 2022

   

   manuelvicnt

   on Mar 10, 2022

   Contributor

   More actions

   Nothing we can do here in Accompanist, unfortunately. That's how permissions work. The status.shouldShowRationale value comes directly from ActivityCompat.shouldShowRequestPermissionRationale, it's the system what's giving us that value

   👎React with 👎11Reacted by Native Software Solutions LLC, Sina Nakhaei, Laxmikant Mahamuni, Ayush Bisht, mil84, Hiran Lakshika, Ikbal Kaya, Bogdan Stolyarov, Gábor Jeges, Thanos Psaridis and 1 more
4. manuelvicnt

   closed this as completedon Mar 10, 2022
5. ijero commented on Mar 11, 2022

   

   ijero

   on Mar 11, 2022

   More actions

   Try this one:

   class RequestPermissionState(initRequest: Boolean, val permissions: List<String>) {
       var request by mutableStateOf(initRequest)
   }
   
   @Composable
   fun rememberRequestPermissionsState(
       initRequest: Boolean = false,
       permissions: List<String>
   ): RequestPermissionState {
       return remember {
           RequestPermissionState(initRequest, permissions)
       }
   }
   
   @OptIn(ExperimentalPermissionsApi::class)
   @Composable
   fun RequestPermissions(requestState: RequestPermissionState, onSuccess: () -> Unit) {
       val context = LocalContext.current
       val state = rememberMultiplePermissionsState(permissions = requestState.permissions) { it ->
           val needToSetting = it.filter {
               !ActivityCompat.shouldShowRequestPermissionRationale(
                   context.findActivity(),
                   it.key
               ) && !it.value
           }.isNotEmpty()
           if (needToSetting) {
               val intent = Intent(
                   Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                   Uri.parse("package:" + context.packageName)
               )
               context.startActivity(intent)
           }
       }
   
       if (requestState.request) {
           requestState.request = false
   
           if (state.allPermissionsGranted) {
               onSuccess()
           } else {
               LaunchedEffect(key1 = Unit) {
                   state.launchMultiplePermissionRequest()
               }
           }
   
       }
   }
   
   internal fun Context.findActivity(): Activity {
       var context = this
       while (context is ContextWrapper) {
           if (context is Activity) return context
           context = context.baseContext
       }
       throw IllegalStateException("Permissions should be called in the context of an Activity")
   }
   

   Example:

       // 判断权限
       val permissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
           listOf(
               Manifest.permission.MANAGE_EXTERNAL_STORAGE,
               Manifest.permission.CAMERA,
               Manifest.permission.RECORD_AUDIO,
           )
       } else {
           listOf(
               Manifest.permission.READ_EXTERNAL_STORAGE,
               Manifest.permission.WRITE_EXTERNAL_STORAGE,
               Manifest.permission.CAMERA,
               Manifest.permission.RECORD_AUDIO,
           )
       }
       val requestState = rememberRequestPermissionsState(permissions = permissions)
       RequestPermissions(requestState = requestState) {
           // Your business logic
       }

   👍React with 👍11Reacted by Madhur Gupta, Tom Kubasik, TheNephilim88, HappyPuppy, Jero, @lice, Binish Mathew, Kwak Wonjo, Roman Makarewicz, Hiran Lakshika and 1 more
6. leoull commented on Jul 15, 2022

   

   leoull

   on Jul 15, 2022

   Last edited by leoull

   More actions

   I modified the above and added more callbacks:

   /**
    * request permission or not
    */
   class RequestPermissionState(initRequest: Boolean, val permission: String) {
       var requestPermission by mutableStateOf(initRequest)
   }
   
   /**
    * Remember whether permission should be requested or not, true initially by default
    */
   @Composable
   fun rememberRequestPermissionsState(
       initRequest: Boolean = true,
       permissions: String
   ): RequestPermissionState {
       return remember {
           RequestPermissionState(initRequest, permissions)
       }
   }
   
   /**
    * Permission requester
    */
   @OptIn(ExperimentalPermissionsApi::class)
   @Composable
   fun RequestPermission(
       context: Context,
       requestState: RequestPermissionState,
       granted: () -> Unit,
       showRational: () -> Unit,
       permanentlyDenied: () -> Unit
   ) {
       val permissionState =
           rememberPermissionState(permission = requestState.permission) { isGranted ->
               // This block will be triggered after the user chooses to grant or deny the permission
               // and we can tell if the user permanently declines or if we need to show rational
               val permissionPermanentlyDenied = !ActivityCompat.shouldShowRequestPermissionRationale(
                   context.findActivity(), requestState.permission
               ) && !isGranted
   
               if (permissionPermanentlyDenied) {
                   permanentlyDenied()
               } else if (!isGranted) {
                   showRational()
               }
           }
   
       // If requestPermission, then launchPermissionRequest and the user will be able to choose
       // to grant or deny the permission.
       // After that, the RequestPermission will recompose and permissionState above will be triggered
       // and we can differentiate whether the permission is permanently declined or whether rational
       // should be shown
       if (requestState.requestPermission) {
           requestState.requestPermission = false
           if (permissionState.status.isGranted) {
               granted()
           } else {
               LaunchedEffect(key1 = Unit) {
                   permissionState.launchPermissionRequest()
               }
           }
       }
   }

   Example:

       val context = LocalContext.current
       
       val permissionRequestState = rememberRequestPermissionsState(
           permissions = Manifest.permission.ACCESS_FINE_LOCATION
       )
       RequestPermission(
           context = context,
           requestState = permissionRequestState,
           granted = {
               // do stuff here
           },
           showRational = {
               // show Rational here
           },
           permanentlyDenied = {
              context. navigateToAppSettings()
           }
       )
   
   fun Context.navigateToAppSettings() {
       this.startActivity(
           Intent(
               Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
               Uri.fromParts("package", this.packageName, null)
           )
       )
   }

   👍React with 👍5Reacted by Jero, Daniel Wilson, Roman Makarewicz, Hiran Lakshika and Reinaldo Riant Kurnia Perdana

   😕React with 😕1Reacted by anilateapp