在没有 Mosby 的情况下在 Android 中实现 MVI 架构

Question

我正在尝试在 Android 中实现 MVI 架构，但不想使用 Mosby 库。我想先学习基础知识。

我正在构建一个示例应用程序，当我按下按钮时，textview 中的文本会发生变化（最初文本是其他内容）。这是 MainActivity 和 MainPresenter 的代码。

class MainActivity : AppCompatActivity(), MainContract.View {

    lateinit var mPresenter: MainContract.Presenter
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mPresenter = MainPresenter()
        mPresenter.attachPresenter(this)
        bind()
    }

    @SuppressLint("CheckResult")
    private fun bind() {
        mPresenter.states().subscribe({ state ->
            render(state)
        }, {
            Log.e("error", "Error is: ", it)
            it.printStackTrace()
        })
        mPresenter.addIntents(intents())
    }

    override fun intents(): Observable<MainIntent> {
        return Observable.merge(
            initialIntent(),
            clickIntent()
        )
    }

    override fun render(state: MainViewState) {
        btn_show.isEnabled = state.isEnabledButton
        helloWorldTextView.text = state.message
        loadingIndicator.visibility = if (state.isLoading) View.VISIBLE else View.GONE
    }

    private fun initialIntent(): Observable<MainIntent.InitialIntent> = Observable.just(MainIntent.InitialIntent)

    private fun clickIntent(): Observable<MainIntent.ClickIntent> {
        return btn_show.clicks().map { MainIntent.ClickIntent("Eureka") }
    }


}



class MainPresenter : MainContract.Presenter {

    private val intentsSubject: PublishSubject<MainIntent> = PublishSubject.create()

    override fun states(): Observable<MainViewState> {
        return statesObservable
    }

    private lateinit var view: MainContract.View

    override fun attachPresenter(view: MainContract.View) {
        this.view = view
    }

    @SuppressLint("CheckResult")
    override fun addIntents(intents: Observable<MainIntent>) {
        intents.subscribe(intentsSubject)
    }

    private val reducer =
        BiFunction { previousState: MainViewState, result: MainResult ->
            when (result) {
                is MainResult.InitialResult.InFlight -> previousState.copy(
                    isLoading = true,
                    message = "Initial Result",
                    isEnabledButton = false
                )
                is MainResult.InitialResult.Success -> previousState.copy(
                    isLoading = true,
                    message = "Initial Success",
                    isEnabledButton = true
                )
                is MainResult.InitialResult.Error -> previousState.copy(
                    isLoading = false,
                    message = "Error Initially",
                    isEnabledButton = true
                )

                is MainResult.ClickedResult.Success -> previousState.copy(
                    isLoading = false,
                    message = System.currentTimeMillis().toString(),
                    isEnabledButton = true
                )
                is MainResult.ClickedResult.Error -> previousState.copy(
                    isLoading = false,
                    message = "Error Clicked",
                    isEnabledButton = true
                )
                is MainResult.ClickedResult.InFlight -> previousState.copy(
                    isLoading = true,
                    message = "Clicked In Flight",
                    isEnabledButton = false
                )
            }
        }

    private fun actionFromIntent(intent: MainIntent): MainAction {
        if (intent is MainIntent.InitialIntent) {
            return MainAction.InitialAction
        } else if (intent is MainIntent.ClickIntent) {
            return MainAction.ClickedAction("Hello")
        } else {
            return MainAction.InitialAction
        }
    }

    private var actionProcessor: ObservableTransformer<MainAction, MainResult> = ObservableTransformer { actions ->
        actions.publish { shared ->
            Observable.merge<MainResult>(
                shared.ofType(MainAction.InitialAction::class.java).compose(initialActionProcessor),
                shared.ofType(MainAction.ClickedAction::class.java).compose(clickActionProcessor)
            )
        }
    }

    private val initialActionProcessor =
        ObservableTransformer<MainAction.InitialAction, MainResult.InitialResult> { action: Observable<MainAction.InitialAction> ->
            action.switchMap {
                Observable.just("hello initially")
                    .map { MainResult.InitialResult.Success(it) }
                    .cast(MainResult.InitialResult::class.java)
                    .onErrorReturn { MainResult.InitialResult.Error(it.message!!) }
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .startWith { MainResult.InitialResult.InFlight }
            }
        }

    private val clickActionProcessor =
        ObservableTransformer<MainAction.ClickedAction, MainResult.ClickedResult> { action: Observable<MainAction.ClickedAction> ->
            Observable.just("Click").map { message ->
                MainResult.ClickedResult.Success(message)
            }.cast(MainResult.ClickedResult::class.java)
                .onErrorReturn { MainResult.ClickedResult.Error("Error") }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .startWith { MainResult.ClickedResult.InFlight }
        }

    private val statesObservable: Observable<MainViewState> = compose()

    private fun compose(): Observable<MainViewState> {
        return intentsSubject
            .map {
                actionFromIntent(it)
            }
            .compose(actionProcessor)
            .scan(MainViewState.idle(), reducer)
            .distinctUntilChanged()
            .replay(1)
            .autoConnect(0)
    }


}

问题是只有 Inital 事件被触发，没有别的。代码不响应点击，render 最初只调用一次。

此外，如果我从 actionProcessors 代码中删除 startWith{}，则代码会响应点击，但只会响应一次。之后，什么都没有发生。

有人看到代码有问题吗？一段时间以来，我一直在努力解决这个问题。

Answer 1

我之前的回复：

这不是您问题的直接答案。但是，如果您实施以下内容，您可能不会遇到您实际询问的问题，并且您将获得更简单的 MVI 解决方案。

您可能会尝试合并 https://speakerdeck.com/jakewharton/the-state-of-managing-state-with-rxjava-devoxx-us-2017、http://hannesdorfmann.com/android/mosby3-mvi-1 和 https://medium.com/@oldergod/managing-state-with-rxjava-b0798a6c5757 想法。

看看这里：https://proandroiddev.com/taming-state-in-android-with-elm-architecture-and-kotlin-part-1-566caae0f706 - 它更简单。第 1 部分和第 2 部分应该足够了。

我尝试了第一种方法，但被最初的复杂性所排斥。在第二种方法中，您没有 Action、Intent、Result，而是 Msg。推理起来更简单。

还有新的 MVI 课程 - 但尚未检查。

目前的做法：

我试过提到 Elm Architecture，但它并不完整。至少有2个问题：

1. 某一时刻只有一个请求可以通过队列。一些 RxJava 应该做的伎俩（groupBy有2个流：ui，背景 可能）。
2. 并行请求会更新相同的状态，因此您应该区分 DataStates 和 UiState。 UI 不同部分的状态也不同。

在编写实际修复程序之前，我们意识到这不是 ATM 的方式：宣布的 Composables 可以完成 MVI 技巧：将数据平稳而精确地转换到 UI 的特定部分。

免责声明：版主删除了我的实际答案。更重要的是，我对评论的回答被删减了，这使它看起来未完成。这就是为什么这个帖子再次出现的原因。亲爱的版主，看完后可以删除免责声明，谢谢:)