mattmook

class PostListViewModel(
    savedStateHandle: SavedStateHandle,
    private val postRepository: PostRepository
) : ViewModel(), ContainerHost<PostListState, NavigationEvent> {

    override val container = container<PostListState, NavigationEvent>(
        initialState = PostListState(),
        savedStateHandle = savedStateHandle
    ) { state ->
        // Executed on creation

mattmook

lifecycleScope.launchWhenCreated {
    suspendCancellableCoroutine { continuation ->
        val unsubscribe = viewModel.store.subscribe {
            render(viewModel.store.state)
        }

        continuation.invokeOnCancellation {
            unsubscribe()
        }
    }

mattmook

class PostDetailsViewModel(
    private val postRepository: PostRepository,
    private val postOverview: PostOverview
) : ViewModel() {

    private val detailsMiddleware = middleware<PostDetailState> { store, next, action ->
        when (action) {
            is ActionTypes.INIT -> store.dispatch(loadDetails(postOverview.id))
            else -> next(action)
        }

mattmook

class PostListViewModel : AndroidDataFlow(defaultState = PostListState()) {

    init {
        action1()
        action2()
    }

    private fun action1() = actionOn<PostListState> { state ->
        delay(5000)

mattmook

onStates(viewModel) {
    reduce(adapter, it as PostListState)
}
onEvents(viewModel) {
    sideEffect(it as NavigationEvent)
}

mattmook

class PostListViewModel(
    savedStateHandle: SavedStateHandle,
    private val postRepository: PostRepository
) : AndroidDataFlow(defaultState = PostListState(), savedStateHandle) {

    init {
        actionOn<PostListState> {
            if (it.overviews.isEmpty()) {
                loadOverviews()
            }

mattmook

class NoteListViewModel(
    initialState: State?,
    private val loadNoteListUseCase: GetNoteListUseCase
) : CoroutineViewModel<Action, State>() {
    override val initialState = initialState ?: State(isIdle = true)
    private val reducer: Reducer<State, Change> = { state, change ->
        when (change) {
            is Change.Loading -> state.copy(
                isIdle = false,
                isLoading = true,

mattmook

class PostListViewModel @AssistedInject constructor(
    @Assisted initialState: PostListState,
    private val postRepository: PostRepository
) : MavericksViewModel<PostListState>(initialState) {

    private val _sideEffect =
        Channel<NavigationEvent>(Channel.BUFFERED)
    val sideEffect: Flow<NavigationEvent> =
        _sideEffect.receiveAsFlow()

mattmook

fun onViewCreated(view: PostListView) {
    binder?.stop()
    binder = bind(lifecycle, BinderLifecycleMode.CREATE_DESTROY) {
        store.states bindTo view
        store.labels bindTo view::sideEffect
    }
}

mattmook

internal class PostListStoreFactory(
    private val storeFactory: StoreFactory,
    private val postRepository: PostRepository,
    val stateKeeper: StateKeeper<PostListState>
) {

    fun create() = object : Store<PostListIntent, PostListState, NavigationEvent> by storeFactory.create(
        name = "PostListStore",
        initialState = stateKeeper.consume() ?: PostListState(),
        bootstrapper = SimpleBootstrapper(Unit),