如何一个接一个地组合两个实时数据？

Question

我有下一个用例:用户登录表格,输入姓名,电子邮件和密码,点击注册按钮.之后系统需要检查电子邮件是否被采用并基于该显示错误消息或创建新用户...

我试图使用Room,ViewModel和LiveData来做到这一点.这是我尝试学习这些组件的一些项目,我没有远程api,我会将所有内容存储在本地数据库中

所以我有这些课程:

• RegisterActivity
• RegisterViewModel
• 用户
• UsersDAO
• UsersRepository
• UsersRegistrationService

所以我的想法是将有一个监听器附加到注册按钮,它将调用RegisterViewModel::register()方法.

class RegisterViewModel extends ViewModel {

    //...

    public void register() {
        validationErrorMessage.setValue(null);
        if(!validateInput())
            return;
        registrationService.performRegistration(name.get(), email.get(), password.get());
    }

    //...

}

所以这是基本的想法,我也想performRegistration回到我新建的用户.

最困扰我的是我不知道如何performRegistration在服务中实现功能

class UsersRegistrationService {
    private UsersRepository usersRepo;

    //...

    public LiveData<RegistrationResponse<Parent>>  performRegistration(String name, String email, String password) {
         // 1. check if email exists using repository
         // 2. if user exists return RegistrationResponse.error("Email is taken") 
         // 3. if user does not exists create new user and return RegistrationResponse(newUser)
    }
}

据我了解,进入的方法UsersRepository应返回LiveData,因为UsersDAO返回LiveData

@Dao
abstract class UsersDAO { 
    @Query("SELECT * FROM users WHERE email = :email LIMIT 1")
    abstract LiveData<User> getUserByEmail(String email);
}

class UsersRepository {
    //...
    public LiveData<User> findUserByEmail(String email) {
        return this.usersDAO.getUserByEmail(email);
    }
}

所以我的问题是如何实现performRegistration()函数以及如何将值传递回视图模型,然后如何将活动从RegisterActivity更改为MainActivity ...

Answer 1

在MediatorLiveData的帮助下,您可以组合来自多个来源的结果.这里有一个如何组合两个来源的例子:

class CombinedLiveData<T, K, S>(source1: LiveData<T>, source2: LiveData<K>, private val combine: (data1: T?, data2: K?) -> S) : MediatorLiveData<S>() {

private var data1: T? = null
private var data2: K? = null

init {
    super.addSource(source1) {
        data1 = it
        value = combine(data1, data2)
    }
    super.addSource(source2) {
        data2 = it
        value = combine(data1, data2)
    }
}

override fun <T : Any?> addSource(source: LiveData<T>, onChanged: Observer<T>) {
    throw UnsupportedOperationException()
}

override fun <T : Any?> removeSource(toRemote: LiveData<T>) {
    throw UnsupportedOperationException()
}
}

这里是上面的要点,如果它在未来更新:https: //gist.github.com/guness/0a96d80bc1fb969fa70a5448aa34c215

Answer 2

一种方法是为此使用流。

val profile = MutableLiveData<ProfileData>()
val user = MutableLiveData<CurrentUser>()

val titleFlow = profile.asFlow().combine(user.asFlow()){ profile, user ->
    "${profile.job} ${user.name}"
}

然后是你的片段/活动：

viewLifecycleOwner.lifecycleScope.launch { 
    viewModel.titleFlow.collectLatest { title ->
        Log.d(">>", title)
    }
}

这种方法的一个优点是，titleFlow只有当两个实时数据都发出至少一个值时才会发出值。这个交互式图表将帮助您理解这一点https://rxmarbles.com/#combineLatest

替代语法：

val titleFlow = combine(profile.asFlow(), user.asFlow()){ profile, user ->
    "${profile.job} ${user.name}"
}

Answer 3

Jose Alcérreca 可能对此给出了最好的答案：

fun blogpostBoilerplateExample(newUser: String): LiveData<UserDataResult> {

    val liveData1 = userOnlineDataSource.getOnlineTime(newUser)
    val liveData2 = userCheckinsDataSource.getCheckins(newUser)

    val result = MediatorLiveData<UserDataResult>()

    result.addSource(liveData1) { value ->
        result.value = combineLatestData(liveData1, liveData2)
    }
    result.addSource(liveData2) { value ->
        result.value = combineLatestData(liveData1, liveData2)
    }
    return result
}

Answer 4

没有自定义类

MediatorLiveData<Pair<Foo?, Bar?>>().apply {
    addSource(fooLiveData) { value = it to value?.second }
    addSource(barLiveData) { value = value?.first to it }
}.observe(this) { pair ->
    // TODO
}

Answer 5

您可以使用我的帮助方法：

val profile = MutableLiveData<ProfileData>()

val user = MutableLiveData<CurrentUser>()

val title = profile.combineWith(user) { profile, user ->
    "${profile.job} ${user.name}"
}

fun <T, K, R> LiveData<T>.combineWith(
    liveData: LiveData<K>,
    block: (T?, K?) -> R
): LiveData<R> {
    val result = MediatorLiveData<R>()
    result.addSource(this) {
        result.value = block.invoke(this.value, liveData.value)
    }
    result.addSource(liveData) {
        result.value = block.invoke(this.value, liveData.value)
    }
    return result
}

Answer 6

您可以定义一个方法，使用 MediatorLiveData 组合多个 LiveData，然后将组合结果公开为元组。

public class CombinedLiveData2<A, B> extends MediatorLiveData<Pair<A, B>> {
    private A a;
    private B b;

    public CombinedLiveData2(LiveData<A> ld1, LiveData<B> ld2) {
        setValue(Pair.create(a, b));

        addSource(ld1, (a) -> { 
             if(a != null) {
                this.a = a;
             } 
             setValue(Pair.create(a, b)); 
        });

        addSource(ld2, (b) -> { 
            if(b != null) {
                this.b = b;
            } 
            setValue(Pair.create(a, b));
        });
    }
}

如果您需要更多值，那么您可以创建 aCombinedLiveData3<A,B,C>并公开 aTriple<A,B,C>而不是 Pair 等。就像/sf/answers/3800507231/中一样。

编辑：嘿看，我什至为你制作了一个库，可以实现从 2 到 16 的数量：https://github.com/Zhuinden/livedata-combinetuple-kt

Answer 7

我根据@guness 的回答采取了一种方法。我发现限制为两个LiveData并不好。如果我们想用3呢？我们需要为每种情况创建不同的类。因此，我创建了一个处理无限数量的LiveDatas 的类。

/**
  * CombinedLiveData is a helper class to combine results from multiple LiveData sources.
  * @param liveDatas Variable number of LiveData arguments.
  * @param combine   Function reference that will be used to combine all LiveData data results.
  * @param R         The type of data returned after combining all LiveData data.
  * Usage:
  * CombinedLiveData<SomeType>(
  *     getLiveData1(),
  *     getLiveData2(),
  *     ... ,
  *     getLiveDataN()
  * ) { datas: List<Any?> ->
  *     // Use datas[0], datas[1], ..., datas[N] to return a SomeType value
  * }
  */
 class CombinedLiveData<R>(vararg liveDatas: LiveData<*>,
                           private val combine: (datas: List<Any?>) -> R) : MediatorLiveData<R>() {

      private val datas: MutableList<Any?> = MutableList(liveDatas.size) { null }

      init {
         for(i in liveDatas.indices){
             super.addSource(liveDatas[i]) {
                 datas[i] = it
                 value = combine(datas)
             }
         }
     }
 }