Hi @vinaygaba ,

I did something like this:

class PermissionHandler(
   private val activity: AppCompatActivity
) {

   fun requestPermission(
       permission: String,
       onResultReceived: (PermissionResult) -> Unit,
   ) {
       val requestPermissionLauncher = activity.registerForActivityResult(
           ActivityResultContracts.RequestPermission(),
       ) { granted ->
           onResultReceived(
               if (granted)
                   PermissionResult.Granted
               else
                   PermissionResult.Denied
           )
       }

       when {
           ContextCompat.checkSelfPermission(
               activity,
               permission
           ) == PackageManager.PERMISSION_GRANTED -> {
               onResultReceived(PermissionResult.Granted)
           }
           ActivityCompat.shouldShowRequestPermissionRationale(
               activity,
               permission
           ) -> {
               onResultReceived(PermissionResult.ShowRationale)
           }
           else -> requestPermissionLauncher.launch(permission)
       }
   }

}

@Composable
fun requestPermission(
   permission: String,
): State<PermissionResult> {
   val permissionHandler = AmbientPermissionHandler.current

   val permissionResult = remember(permission) {
       mutableStateOf<PermissionResult>(PermissionResult.Requesting)
   }

   remember(permission) {
       permissionHandler.requestPermission(permission) {
           permissionResult.value = it
       }
   }

   return permissionResult
}

sealed class PermissionResult {
   object Requesting : PermissionResult()

   object ShowRationale : PermissionResult()

   object Denied : PermissionResult()

   object Granted : PermissionResult()
}

val AmbientPermissionHandler: ProvidableAmbient<PermissionHandler> =
   staticAmbientOf { throw IllegalStateException("permission handler is not initialized") }

and then provide PermissionHandler as an ambient like so:

Providers(AmbientPermissionHandler provides permissionHandler) {
    ....
}

My idea was to be able to use it like:

val permissionResult by requestPermission(permission = Manifest.permission.CAMERA)
when (missionResult) {
     PermissionResult.Requesting -> Text("Requesting")
     PermissionResult.ShowRationale -> Text("Show Rationale")
     PermissionResult.Denied -> Text("Denied")
     PermissionResult.Granted -> FragmentContainer(fragment = SelfieFragment())
}

The problem is when I get to the Composable where the code above is located, I get the error:

LifecycleOwner ... is attempting to register while current state is RESUMED. LifecycleOwners must call register before they are STARTED.
        at androidx.activity.result.ActivityResultRegistry.register 
        ...

Not really sure how to solve the issue. It seems to me that at the point of a @Composable the lifecycle is already at LifecycleState.RESUMED and so registerForActivityResult(...) throws the error.

I was wondering whether you've already implemented permissions and maybe have some idea on how to solve this or do it a different way?

Uh oh!

Add Example that requests permissions from a composable #53

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions