I managed to do it by having a wrapped

MutableStateFlow

but that involves quite a bit of boilerplate

oh but that creates a non mutable

StateFlow

though - my need is for a mutable one.

I think the easiest solution is just create a standard MutableStateFlow() and allow update it from two sides

You can do something like this:

class FlowPreferences {
    private val flows = HashMap<String, MutableStateFlow<Any>>()
    private val sharedPreferences = TODO()
    private val someScope: CoroutineScope = TODO("Lifecycle of this scope really depends on your case, it can be just GlobalScope, if preferences are global")
    fun stringFlow(key: String): MutableStateFlow<String> {
        flows.getOrPut(key) {
            MutableStateFlow<String>(sharedPreferences.getString(key)).apply {
                someScope.launch {
                    collect {
                        if (sharedPreferences != it) {
                            sharedPreferences.edit().putString(it).apply()
                        }
                    }
                }
                //TODO: it also possible observe sharedPreferences and update flow
            }
        }
    }
}

Though, I’m not sure that having hot flows for this case is right solution, I would just replace this with non-mutable StateFlow and additional method for update, yes, a bit more code, but easier to maintain and clear separation of observable state from updating of this state (they also could be parts of separate interfaces)

you can see here how I did it (the wrapping approach), to compare: https://github.com/BoD/android-kprefs/blob/mutable-state-flow/library/src/main/kotlin/org/jraf/android/kprefs/PreferenceFlowProperty.kt#L68