pedroql/mvflow

Simple Android MVI architecture using Kotlin Flows

mvflow's Issues

Unit Test samples

any example to unit test counter samples?

Is it possible to combine reducer & handler?

based on an article here

tl;dr: https://dev.to/feresr/comment/1ddi3

does the ideas of MVI was at minimal was requires both reducer and handler, therefore the above discussion was indeed the actual drawback of MVI (because it's not a silver bullet)? cmiiw 🙏

Consider moving from SharedFlow to Channel

MVFlow uses a SharedFlow to handle the Effects, then launchWhenX {} in the View to collect the effects.

However this raises some good points about not using SharedFlow and instead use a Channel(Channel.BUFFERED). Because some Effects can be lost due to configuration changes. And even using launchWhen(Started/Resumed) {} is not immune to this, and he proposes a simple observer class to handle it.

Handler State Become Stale for Actions That Produce Long Running Flows

There are a couple ways I can see to fix this, neither of which is backwards compatible.

1. Pass StateFlow<State> as parameter instead of State in Handler

typealias Handler<State, Action, Mutation> = (StateFlow<State>, Action) -> Flow<Mutation>

//Flow<Action>.collectIntoHandler changes to
handler.invoke(state, action, LoggingEffectSender(logger))

//Inside handler functions the current state can be accessed using
{ state, action ->
  state.value
}

2. Pass function () -> State as parameter instead of State in handler

typealias Handler<State, Action, Mutation> = (() -> State, Action) -> Flow<Mutation>

//Flow<Action>.collectIntoHandler changes to
handler.invoke({state.value}, action, LoggingEffectSender(logger))

//Inside handler functions the current state can be accessed using
{ state, action ->
   state()
}

Example: Notice that MyState(count=1) and MyState(count=2) are printed when it should print all the way up to count=6

data class MyState(val count: Int = 1)
  sealed class MyAction {
    object Start : MyAction()
  }

  sealed class MyMutation {
    data class IncrementCount(val newCount: Int) : MyMutation()
  }

  @Test
  fun testStaleState() {
    runBlocking {
      val handler: Handler<MyState, MyAction, MyMutation> = { state, action ->
        when (action) {
          MyAction.Start -> flow {
            emit(MyMutation.IncrementCount(state.count + 1))
            kotlinx.coroutines.delay(100)
            emit(MyMutation.IncrementCount(state.count + 1))
            kotlinx.coroutines.delay(100)
            emit(MyMutation.IncrementCount(state.count + 1))
            kotlinx.coroutines.delay(100)
            emit(MyMutation.IncrementCount(state.count + 1))
            kotlinx.coroutines.delay(100)
            emit(MyMutation.IncrementCount(state.count + 1))
          }
        }
      }
      val reducer: Reducer<MyState, MyMutation> = { state, mutation ->
        when(mutation){
          is MyMutation.IncrementCount -> state.copy(count =  mutation.newCount)
        }
      }
      MVFlow(MyState(), handler, reducer, this).takeView(this, object : MVFlow.View<MyState, MyAction>{
        override fun actions(): Flow<MyAction> {
          return flowOf(MyAction.Start)
        }

        override fun render(state: MyState) {
          println(state)
        }
      })
    }
  }

Ability to allow same Flow emission

We're implementing our click events (e.g: buttonA), but unable to (re)click the buttonA unless we're resetting the events/click another events

The buttonA is just a simple showing bottom dialog, we're providing an ID to its intent then fetch API and display the data retrieved from server

Is it possible to allow same flow emission for particular/specific events? or should we implement reset state instead manually?

Best practices to send a throwable from Fragment/Activity?

MVFlow class

    sealed class Error : Action {
       object MaxChar : Error()
       object NPE : Error()
       object UPA : Error()
    }

In Activity/Fragment

private val actionsChannel = Channel<Action>()

// somewhere in the code
// e.g: 1
viewBinding.editText.doAfterTextChanged {
   if (it.length > 200) actionsChannel.offer(Action.Error.MaxChar)
}

// e.g: 2

try { 
    doSomething(null)
} catch (e: NullPointerException) {
    actionsChannel.offer(Action.Error.NPE)
}

fun doSomething(nonNull: String) {
 // do something
} 

// e.g: 3

private var lateinit abc: String

// we forgot to initialized,
// therefore will throw UninitializedPropertyAccessException: lateinit property `abc`
try { 
   doSomething(abc) 
} catch (e: UninitializedPropertyAccessException) {
   actionsChannel.offer(Action.Error.UPA)
}

Question

or is there any alternative to distinguish between throwing errors in our view (e.g: without an action), maybe using Effects #30?

Android sample app wont even sync on latest Android Studio Iguana

Can't get the sample app to compile or even Gradle sync, opened the sample_app folder in Android Studio Iguana and no matter what jdk I select I get:

BUG! exception in phase 'semantic analysis' in source unit '_BuildScript_' Unsupported class file major version 61

Is it possible to add time travel debugger?

This might be out of scope because the intention of this library is Minimalistic yet complete, but i'm curious is it possible to add time travel debug tools same like badoo/MVICore provides?

How to stop an async task launched by the handler

I have a serch that each time that you type a character it launches a request. The problem is that if I don't cancel I could have this race condition:

• Action Search "mv"
• Action Search "mvf"
• Mutation with items from "mvf"
• Mutation with items from "mv"

At the end the user sees the results of "mv" instead of "mvf".

If I can cancel the collection of the current old flow I would fix it. Maybe there is other way to avoid this problem. I tried out this one: badoo/MVICore#68 (comment) but Flow doesn't have a takeUntil.

is it possible to use MVFlow in Jetpack Compose?

the method MVFlow#takeView is requires lifecycleScope, but Jetpack Compose doesn't have one, any suggestion to implement MVFlow to use Jetpack Compose?

Ref:

1. https://developer.android.com/jetpack/compose/state
2. https://developer.android.com/jetpack/compose/mental-model

Migrate from jcenter

https://jeroenmols.com/blog/2021/02/04/migratingjcenter/#published-artifacts-to-bintrayjcenter