eventSink and different states

[chriswiesner]

I have a scaffold with a top-bar that as a back/up navigation icon.

the screen has a loading and a success state.

@Parcelize
data object MyScreen : Screen {

    sealed interface State : CircuitUiState {
        val eventSink: (Event) -> Unit

        data class Success(
            val someData: List<Data>,
            override val eventSink: (Event) -> Unit,
        ) : State

        data class Loading(override val eventSink: (Event) -> Unit) : State
    }

    sealed interface Event : CircuitUiEvent {
        data object OnBackClick : Event
    }
}

i want to be able to navigate back also when the screen is loading - with this both states need to have an eventSink and to avoid type-checks i need to declare it in the parent an override it :/
also the Presenter needs to define the eventSink for both states which is a bit convoluted

return if (something) {
            MyScreen.State.Loading { event ->
            // eventsink
            }
        } else MyScreen.State.Success(
            someData,
        ) { event ->
            // eventsink
        }

is there a cleaner approach apart from only having one state class that has a isLoading flag?
(ofc eventSink for both cases can be defined as property in the Presenter - but it still feels a bit redundant)

[ZacSweers]

Any reason you can't just extract your event sink to a variable separately then?

[ZacSweers]

If it's shared via one var, why would you need to define it 3 times?

[chriswiesner]

i was referring to the state definition (interface + override for different state classes)

[erawhctim]

just wondered if there is a cleaner way of having it defined 3 times in the states then.

What if you just omit the eventSink on the State interface, and avoid having to override in each subclass?

@Parcelize
data object MyScreen : Screen {

    sealed interface State : CircuitUiState {
        data class Success(
            val someData: List<Data>,
            val eventSink: (Event) -> Unit,
        ) : State

        data class Loading(val eventSink: (Event) -> Unit) : State
    }

    sealed interface Event : CircuitUiEvent {
        data object OnBackClick : Event
    }
}

// In your presenter:
val eventSink = { event -> 
    // handle events in one place
}

return if (something) {
    MyScreen.State.Loading(eventSink)
} else {
    MyScreen.State.Success(someData, eventSink)
}

[chriswiesner]

i think that's what zac was referring to - but still requires each state variant to define the sink as a val

[erawhctim]

Correct; that part is kinda unavoidable (by design). Any model that hooks up to a UI, that needs to send events, needs an eventSink to send them to.