1

在 Android 中网络操作通常是在ViewModel. 这确保即使重新创建Activityor时Fragment（例如当设备旋转时），网络调用也会继续进行并且不会被取消。

现在将网络请求的结果从ViewModel视图（Activity/ Fragment）提交。您有一个反应组件，例如 a LiveDataorObservable来设置它的值。喜欢：

val resultLiveData = MutableLiveData<Result>()

fun doNetworkRequest() {
    repository.requestSomeResult()  // Assume this returns Arrow's IO
        .unsafeRunAsync { eitherResult ->
            eitherResult.fold({ error ->
                // Handle Error
            }, { result ->
                resultLiveData.value = result
            })
        }
}

我想知道是否有一种方法可以val resultLiveData = MutableLiveData<Result>()不依赖于特定的实现，例如返回 a之类的LiveData东西。higher kindKind<F, Result>

有没有办法我可以做：

val result = Kind<F, Result>()

fun doNetworkRequest() {
    repository.requestSomeResult()  // Assume this returns Arrow's IO
        .unsafeRunAsync { eitherResult ->
            eitherResult.fold({ error ->
                // Handle Error
            }, { result ->
                resultLiveData.sendValue(result) // Or however it should be done
            })
        }
}

所以我可以Kind<F, Result>稍后用我想要的实现来定义？

4

1 回答 1

3

谢谢这个问题！这是我最近一直在做的事情。关于这点需要提几点：

在接下来的几天里，我们将为 Arrow 发布一个 KotlinX 集成模块。我将允许你在 CoroutineScope 中定义你的 IO 任务。IE：

yourIOTask().unsafeRunScoped(scope) { cb -> }

如果提供的范围被取消，这将确保您的 IO 任务被取消。这意味着您可以doNetworkRequest使用视图模型范围来确定本示例中的“视图模型”操作的范围，并且您将确保这些操作能够在配置更改后继续存在，并在视图模型发布时被取消。

话虽如此，如果我们观察 Android ViewModel 目前是如何工作的，您仍然需要一个“中间层缓存”来交付结果，正如您所提到的，以确保始终交付这些结果，并且一旦视图开始观察我得到了最新鲜的数据。通过使用此机制以及上一段中提到的范围，您可以确保您的长期运行的任务将始终交付结果，无论它们是在配置更改之前、期间或之后完成的。

从这个意义上说，如果您想继续使用 Android ViewModel，您可以使用箭头进行编码，例如：

interface ViewStateCache<ViewState> {

  val cacheScope: CoroutineScope

  fun observeViewState(observer: LifecycleOwner, renderingScope: CoroutineScope, render: (ViewState) -> IO<Unit>): IO<Unit>

  fun updateViewState(transform: (ViewState) -> ViewState): IO<ViewState>
}

我们可以使用这个契约来确保以纯粹的方式使用 ViewModel。所有 ViewModel 都可以实现这个契约，比如：

class ViewModelViewStateCache<ViewState>(initialState: ViewState) : ViewModel(), ViewStateCache<ViewState> {

  override val cacheScope: CoroutineScope = viewModelScope

  private val _viewState = MutableLiveData<ViewState>(initialState)
  private val viewState: LiveData<ViewState> = _viewState

  override fun updateViewState(transform: (ViewState) -> ViewState) =
    IO {
      val transformedState = transform(viewState.value!!)
      _viewState.postValue(transformedState)
      transformedState
    }

  override fun observeViewState(observer: LifecycleOwner, renderingScope: CoroutineScope, render: (ViewState) -> IO<Unit>) =
    IO {
      viewState.observe(observer, Observer<ViewState> { viewState ->
        viewState?.let { render(it).unsafeRunScoped(renderingScope) {} }
      })
    }
}

这样，您就可以有效地拥有一个使用 Android ViewModel 实现的视图状态缓存。这是一个实现细节，所以你可以注入它。您的程序将针对接口工作。

在这里，ViewModel仅用作向 传递结果的缓存，并且通过将其用于观察和更新视图状态的操作包装到IO.

有了这样的东西，您可以拥有对您的表示和线程协调逻辑进行编码的纯函数，并将结果传递到上述缓存，例如：

fun doNetworkRequest(): IO<Unit> = IO.fx {
      !viewStateCache.updateViewState { Loading }
      !repository.requestSomeResult().redeemWith(
        ft = {
          viewStateCache.updateViewState { ErrorViewState(ServerError) }
        },
        fe = { error ->
          viewStateCache.updateViewState { ErrorViewState(error) }
        },
        fb = { data ->
          viewStateCache.updateViewState { SuccessfulViewState(data) }
        }
      )
    }

这些函数不需要存在于视图模型中，而是使用缓存作为委托来传递结果，因此它可以作为实现细节注入。

您还需要在创建视图后立即开始观察视图状态缓存，这与您已经对视图模型所做的类似。请注意，我们有意将范围公开为缓存合同的一部分，以便您可以从外部访问它。

这是一个如何包装当前 ViewModel api 以继续使用它们并确保它们的配置更改支持的示例，主要用于逐步迁移到 Arrow。

这种方法更像是一种方便的方法，可能需要一些改进，但应该可以。我们目前正在探索 Android 常见问题，例如配置更改，以便通过扩展或类似的集成库为那些提供无缝体验。

希望这足够有用，如果没有，请告诉我

于 2020-03-26T12:21:51.177 回答