How to make StateFlow polymorphic in Androd?

Question

I am at stage when I would like to expose my StateFlow<Model>() into the common BaseViewModel() class to implement common operations on it without repeating them in others implementations of ViewModels. I ended up with one idea, but faced with several limitations when has built PoC. My idea and its limitations are below, your solutions for origin question are welcomed.

I split my model into interface and one concrete implementation.

sealed interface Model {
    var isLoading: Boolean
    var errors: List<String>
    /**
     * @param obj Should has the same concrete type as concrete type of object which copy() it invokes
     * */
    fun copy(obj: Model): Model
}

data class DeputiesModel(
    override var isLoading: Boolean = false,
    override var errors: List<String> = emptyList<String>(),
    var deputies: List<Deputy> = emptyList()
) : Model {
    override fun copy(obj: Model): DeputiesModel {
        if (obj !is DeputiesModel)
            throw IllegalArgumentException("Passed object implements ${Model::javaClass.name}" +
                    " interface, but should be concrete ${DeputiesModel::javaClass::name} implementation.")
        return this.copy(deputies = obj.deputies, isLoading = obj.isLoading, errors = obj.errors)
    }
}

I need a copy() method in interface to data class copy() is closed for overloading and overriding.

My StateFlow implementation has been moved in BaseViewModel()

abstract class BaseViewModel<T : Model> : ViewModel() {

    protected lateinit var state: MutableStateFlow<T>
    lateinit var uiState: StateFlow<T>

}

I added generics here to avoid casting Model type to one of its concrete implementation, e.g. DeputiesModel, in classes which inherits BaseViewModel, otherwise this extra code would made a whole intent to expose common methods redundant.

And here is a first common method:

fun removeShownError() {
    state.update { state ->
        state.errors = state.errors.filter { str -> !str.equals(state.errors.first()) }
        state.copy(state) as T
    }
}

The limitation of this design&implementation is state.copy(state) doesn't trigger uiState.collectLatest{} call when origin parameterized state.copy(isLoading = false) does it. I haven't find yet the root cause of it.

    val viewModel: DeputiesViewModel by viewModels { viewModelFactory }
    lifecycleScope.launch {
        viewModel.uiState.collectLatest { it ->
            if (it.errors.isNotEmpty()) {
                showError(
                    view = requireActivity().findViewById(R.id.nav_view),
                    text = it.errors.first(),
                    onDismiss = { viewModel.removeShownError() }
                )
            }
            (binding.list.adapter as DeputiesAdapter).update(it.deputies)
        }
    }

That's all. Your ideas are appreciated.

Answer 1

Here's how your example of the common function removeShownError() could be solved with an extension function so you don't need a BaseViewModel.

Model classes without mutability:

sealed interface Model {
    val isLoading: Boolean
    val errors: List<String>
}

data class DeputiesModel(
    override val isLoading: Boolean = false,
    override val errors: List<String> = emptyList<String>(),
    val deputies: List<Deputy> = emptyList()
) : Model 

Extension functions for shared functionality, defined at the top level somewhere:

// Since this is a sealed interface, you can create a single extension function to
// implement clearing errors for each of the implementations. This will be cleaner
// than having to deal with wrong input type problem in your current copy function
// implementation.
@Suppress("UNCHECKED_CAST")
fun <T: Model> T.withNewErrors(newErrors: List<String>): T = when (this) {
    is DeputiesModel -> copy(errors = newErrors)
    //... other types
} as T

fun <T: Model> MutableStateFlow<T>.removeShownError() {
    update { state ->
        state.withNewErrors(
            state.errors.filter { str -> !str.equals(state.errors.first()) }
        )
    }
}

Now there's no need for a BaseViewModel. You can just add to any ViewModel that has a relevant flow:

fun removeShownError() = state.removeShownError()

By the way, it doesn't make much sense to use lateinit in a ViewModel. That's a hack needed for classes like Activity where most of what you need to do to initialize variables requires Context, but the context isn't ready at class instantiation time and create() is the earliest point at which any of your own properties will be used for anything. In a ViewModel, everything you could possibly need to use is already available at class initialization via the constructor, so there's no reason to postpone initialization of a property.

Even if you did have to use lateinit for it, it wouldn't be necessary to use it for it's partner non-mutable public property, because that property could just use a custom getter, so it has no backing variable to initialize in the first place:

val uiState: StateFlow<T> get() = state