fergusonm

class Thing(
    private val savedStateHandle: SavedStateHandle,
    private val key: String,
) {
    private val someExistingStateFlow = MutableStateFlow<String>(savedStateHandle[key] ?: "default Initial")
    private val myStateFlow = someExistingStateFlow.saveWith(savedStateHandle = savedStateHandle, key = key)
    private val myNewStateFlow = SaveableMutableStateFlow<String>(savedStateHandle = savedStateHandle, key = key)

}

fergusonm

class MyMultiPlatformViewModel @Inject constructor(
    private val scope: CoroutineScope,
    private val stateHelper: SavedStateHelper,
) : CoroutineScope by scope, AutoCloseable {
    private var screenId: String by stateHelper.savedState("screenId", default = "")

    fun doAThing() {}

    override fun close() {

fergusonm

// In your view model
private val _eventChannel = Channel<Event>(Channel.BUFFERED)
val events = _eventChannel.receiveAsFlow()

fergusonm

// In your view/fragment
viewLifecycleOwner.lifecycleScope.launch {
    viewModel.viewState
        .flowWithLifecycle(viewLifecycleOwner.lifecycle, Lifecycle.State.STARTED)
        .collect { 
            // do something with the UI updates
        }
}

fergusonm

class MyViewMode: ViewModel() {
    data class ViewState(
        val someUIProperty: String = "",
        val someOtherUIProperty: Int = 1,
    )
    
    private val _viewState = MutableStateFlow<ViewState>(ViewState())
    val viewState = _viewState.asStateFlow()
}

fergusonm

viewModel.events
    .observeWithLifecycle(fragment = this, minActiveState = Lifecycle.State.RESUMED) {
        // do things
    }

viewModel.events
    .observeWithLifecycle(lifecycleOwner = viewLifecycleOwner, minActiveState = Lifecycle.State.RESUMED) {
        // do things
    }

fergusonm

inline fun <reified T> Flow<T>.observeWithLifecycle(
        lifecycleOwner: LifecycleOwner,
        minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
        noinline action: suspend (T) -> Unit
): Job = lifecycleOwner.lifecycleScope.launch {
    flowWithLifecycle(lifecycleOwner.lifecycle, minActiveState).collect(action)
}

inline fun <reified T> Flow<T>.observeWithLifecycle(
        fragment: Fragment,

fergusonm

viewModel.events
    .onEach {
        // can get cancelled when the lifecycle state falls below min
    }
    .flowWithLifecycle(lifecycle = viewLifecycleOwner.lifecycle, minActiveState = Lifecycle.State.STARTED)
    .onEach {
        // Do things
    }
    .launchIn(viewLifecycleOwner.lifecycleScope)

fergusonm

fun <T> Flow<T>.collectIn(
    lifecycleOwner: LifecycleOwner,
    minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
    action: suspend (T) -> Unit
): Job = lifecycleOwner.lifecycleScope.launch {
    flowWithLifecycle(lifecycleOwner.lifecycle, minActiveState).collect(action)
}

fergusonm

class MainFragment : Fragment(R.layout.main_fragment) {

    companion object {
        fun newInstance() = MainFragment()
    }

    private lateinit var viewModel: MainViewModel

    override fun onCreate(savedInstanceState: Bundle?) {