Boolean flows sync

Issue

I have few StateFlow fields in the ViewModel class. It's add/edit form screen where each StateFlow is validation property for each editable field on the screen.

I would like to write some class FormValidation with StateFlow property for validation state of whole form. Value of this field based on the values of validation state of all fields and emit true when all field is valid and false when any field is invalid.

Something like this:

class FormValidation(initValue: Boolean, vararg fieldIsValid: StateFlow<Boolean>) {
    
    private val _isValid = MutableStateFlow(initValue)
    val isValid: StateFlow<Boolean> = _isValid
    
    init {
        // todo: how to combine, subscribe and sync values of all fieldIsValid flows?
    }
    
}

I know how to do it with LiveData<Boolean> and MediatorLiveData but i can't understand how to make it with flows.

---

Solution based on the answer of @tenfour04

class BooleanFlowMediator(scope: CoroutineScope, initValue: Boolean, vararg flows: Flow<Boolean>) {
    val sync: StateFlow<Boolean> = combine(*flows) { values ->
        values.all { it }
    }.stateIn(scope, SharingStarted.Eagerly, initValue)
}

Demo code with StateFlow and ViewModel

class SyncViewModel : ViewModel() {

    companion object {
        private const val DEFAULT_VALUE: Boolean = false
    }

    private val values: List<List<Boolean>> = listOf(
        listOf(false, false, false),
        listOf(true, false, false),
        listOf(false, true, true),
        listOf(true, true, true)
    )

    private var index: Int = 0

    private val _flow1 = MutableStateFlow(DEFAULT_VALUE)
    val flow1: StateFlow<Boolean> = _flow1

    private val _flow2 = MutableStateFlow(DEFAULT_VALUE)
    val flow2: StateFlow<Boolean> = _flow2

    private val _flow3 = MutableStateFlow(DEFAULT_VALUE)
    val flow3: StateFlow<Boolean> = _flow3

    val mediator = BooleanFlowMediator(viewModelScope, DEFAULT_VALUE,
        flow1, flow2, flow3)

    fun generateValues() {
        val idx = (index + 1).mod(values.size).also { index = it }
        val row = values[idx]
        _flow1.value = row[0]
        _flow2.value = row[1]
        _flow3.value = row[2]
    }

}

Solution

I think you can do this using combine. It returns a new Flow that emits each time any of the source Flows emits, using the latest values of each in a lambda to determine its emitted value.

There are also overloads of combine for up to five input Flows of different types, and one for an arbitrary number of Flows of the same type, which is what we want here.

Since Flow operators return basic cold Flows, but if you want to have a StateFlow so you can determine the initial value, you need to use stateIn to convert it back to a StateFlow with an initial value. And for that you'll need a CoroutineScope for it to run the flow in. I'll leave it to you to determine the best scope to use. Maybe it should be passed in from an owning class (like passing viewModelScope to it if the class instance is "owned" by the ViewModel). If you're not using a passed in scope, you will have to manually cancel the scope when this class instance is done with, or else the flow will leak.

I didn't test this code, but I think this should do it.

class FormValidation(initValue: Boolean, vararg fieldIsValid: StateFlow<Boolean>) {

    private val scope = MainScope()

    val isValid: StateFlow<Boolean> =
        combine(*fieldIsValid) { values -> values.all { it } }
            .stateIn(scope, SharingStarted.Eagerly, initValue)

}

However, if you don't need to synchronously inspect the most recent value of the Flow (StateFlow.value), then you don't need a StateFlow at all, and you can just expose a cold Flow. The instant the cold Flow is collected, it will start collecting its source StateFlows, so it will immediately emit its first value based on the current values of all the sources.

class FormValidation(initValue: Boolean, vararg fieldIsValid: StateFlow<Boolean>) {

    val isValid: Flow<Boolean> = when {
        fieldIsValid.isEmpty() -> flowOf(initValue) // ensure at least one value emitted
        else -> combine(*fieldIsValid) { values -> values.all { it } }
            .distinctUntilChanged()
    }

}

Answered By - Tenfour04