Presenter -> when expression not reacting to state changes, Maybe I should use a FlowPresenter?

[shaharKeisarApps]

Hello,

I'm currently developing an application using Circuit, and I've encountered a situation where a when expression inside a

@Composable
    override fun present(): SelectLocationScreen.State 
    

doesn't seem to react to changes in a state variable (isPermissionGranted in my case).

Here's a simplified version of my code:

@Composable
override fun present(): SelectLocationScreen.State {
    var isPermissionGranted by remember{ mutableStateOf(false)}

    return when{
        !isPermissionGranted -> SelectLocationScreen.State.CheckForPermissions { event ->
            when (event) {
                SelectLocationScreen.Event.PermissionsDenied ->{
                    // Navigate to app settings
                }

                SelectLocationScreen.Event.PermissionsGranted ->
                    isPermissionGranted = true

                SelectLocationScreen.Event.AskForPermission ->{
                    isPermissionGranted = false
                    navigator.goTo(AskForPermissionScreen)
                }

                else -> {}
            }
    }
        else -> SelectLocationScreen.State.GeofenceMap(
            location = locationSelected,
            radius = radiusSelected
        ) { event ->
            // Handle events
        }
    }
}

In this code, I'm expecting the when expression to react to changes in the isPermissionGranted state, and accordingly return a different state. However, it seems like the when expression isn't "collecting" the new values of isPermissionGranted, and the UI isn't updating to reflect the new state.

I consider using FlowPresenter, as in the Counter sample.

this is my full code:

@Parcelize
object SelectLocationScreen : Screen {

    sealed interface Event : CircuitUiEvent {
        data class LocationSelected(val location: LatLng) : Event
        data class RadiusChanged(val radius: Float) : Event
        object ClearLocation : Event
        object NextClicked : Event
        object AskForPermission : Event
        object PermissionsGranted : Event
        object PermissionsDenied : Event
    }

    sealed class State : CircuitUiState {

        data class CheckForPermissions(
            val eventSink: (Event) -> Unit = {},
        ) : State()

        data class GeofenceMap(
            val location: LatLng? = null,
            val radius: Float = 100f, // Default radius
            val eventSink: (Event) -> Unit = {},
        ) : State()
    }
}


class SelectLocationPresenter
@AssistedInject
constructor(
    @Assisted private val navigator: Navigator,
) : Presenter<SelectLocationScreen.State> {

    @Composable
    override fun present(): SelectLocationScreen.State {
        val emptyLocation = LatLng(0.0, 0.0)
        var locationSelected by rememberSaveable { mutableStateOf(emptyLocation) }
        var radiusSelected by rememberSaveable { mutableStateOf(100f) } // Default radius
        var isPermissionGranted by remember{ mutableStateOf(false)}

        return when{
            !isPermissionGranted -> SelectLocationScreen.State.CheckForPermissions { event ->
                when (event) {
                    SelectLocationScreen.Event.PermissionsDenied ->{
                        //todo: navigate to app settings
                        /*isPermissionGranted = false
                        navigator.goTo(AskForPermissionScreen)*/
                    }

                    SelectLocationScreen.Event.PermissionsGranted ->
                        isPermissionGranted = true

                    SelectLocationScreen.Event.AskForPermission ->{
                        isPermissionGranted = false
                        navigator.goTo(AskForPermissionScreen)
                    }

                    else -> {}
                }
        }
            else -> SelectLocationScreen.State.GeofenceMap(
                location = locationSelected,
                radius = radiusSelected
            ) { event ->
                when (event) {
                    is SelectLocationScreen.Event.LocationSelected -> locationSelected =
                        event.location

                    is SelectLocationScreen.Event.RadiusChanged -> radiusSelected = event.radius
                    SelectLocationScreen.Event.ClearLocation -> {
                        locationSelected = emptyLocation
                        radiusSelected = 100f // Reset radius
                    }

                    SelectLocationScreen.Event.NextClicked -> {
                        // Navigate to the next screen
                        // navigator.navigate(...)
                    }

                    else -> {}

                }
            }
        }
    }
    
    @CircuitInject(SelectLocationScreen::class, AppScope::class)
@Composable
fun SelectLocationsContent(
    state: SelectLocationScreen.State,
    modifier: Modifier = Modifier,
) {
    val context = LocalContext.current
    val fusedLocationClient = remember { LocationServices.getFusedLocationProviderClient(context) }
    val foregroundLocationPermission = Manifest.permission.ACCESS_FINE_LOCATION
    val backgroundLocationPermission = Manifest.permission.ACCESS_BACKGROUND_LOCATION


    when (state) {
        is SelectLocationScreen.State.CheckForPermissions -> {
            val foregroundPermissionCheck = ContextCompat.checkSelfPermission(
                context,
                foregroundLocationPermission
            )

            val backgroundPermissionCheck = ContextCompat.checkSelfPermission(
                context,
                backgroundLocationPermission
            )
            backgroundPermissionCheck == PackageManager.PERMISSION_GRANTED && foregroundPermissionCheck == PackageManager.PERMISSION_GRANTED
            if (backgroundPermissionCheck == PackageManager.PERMISSION_GRANTED) {
                state.eventSink(SelectLocationScreen.Event.PermissionsGranted)
            } else {
                state.eventSink(SelectLocationScreen.Event.AskForPermission)
            }


        }
        is SelectLocationScreen.State.GeofenceMap -> {
            GeofenceMapUI(modifier, state)
        }

    }
    
   

Any guidance or suggestions would be greatly appreciated.

Thank you!

[ZacSweers]

Are you able to write a reproducing test? Using circuit's test extensions should help with trying to debug this