时间戳

首页 > 解决方案 > 从 LiveData 触发第二个查询并合并结果（Firestore）？

android - 从 LiveData 触发第二个查询并合并结果（Firestore）？

问题描述

我有两个收藏：用户和书籍。无论用户或书籍是否更新，我都需要获取它们的结果，然后将结果合并到 LinkedHashMap 中以用作 listView 菜单。

我认为 MediatorLiveData 将是要走的路，但是如果我将用户查询和书籍查询放入，那么我会从两个 LiveData 对象之一中获得 null，因为只有一个或另一个会触发。我想也许如果其中一个触发，那么也许我在 MediatorLiveData 的每个 addSource() 中运行了一个查询，但我不确定这是否是要走的路。

我关于 MediatorLiveData 的帖子在这里： Using MediatorLiveData to merge to LiveData (Firestore) QuerySnapshot 流产生奇怪的结果

我的两个查询和 LiveData 对象如下：

//getUsers query using FirebaseQueryLiveData class
private Query getUsersQuery() {
    FirebaseAuth mAuth = FirebaseAuth.getInstance();

    adminID = mAuth.getUid();
    query = FirebaseFirestore.getInstance().collection("admins")
            .document(adminID)
            .collection("users")
    return query;
}

private FirebaseQueryLiveData usersLiveData = new FirebaseQueryLiveData(getUsersQuery());


//getBooks query using FirebaseQueryLiveData class
private Query getBooksQuery () {
    FirebaseGroupID firebaseGroupID = new FirebaseGroupID(getApplication());
    groupID = firebaseGroupID.getGroupID();
    query = FirebaseFirestore.getInstance().collection("books")
            .whereEqualTo("groupID", groupID)      
    return query;
}

private FirebaseQueryLiveData booksLiveData = new FirebaseQueryLiveData(getBooksQuery());

不知何故，当用户更新时，我也需要获取书籍的数据然后合并它们，但是如果书籍更新然后获取用户的数据并合并它们，我也需要这样做。

任何想法将不胜感激。

附加说明/观察 好的，所以我没有完全排除 MediatorLiveData 对象。当然，它允许我在同一个方法中监听两个不同的 LiveData 对象，但是，我不想直接合并它们两个，因为我需要单独对每个 liveData 对象进行操作。举个例子： usersLiveData 因为我们创建或修改用户而触发，然后我需要查询书籍，获取结果并合并用户和书籍等。

以下是我目前的 MediatorLiveData：

//MediatorLiveData merge two LiveData QuerySnapshot streams
private MediatorLiveData<QuerySnapshot> usersBooksLiveDataMerger() {
    final MediatorLiveData<QuerySnapshot> mediatorLiveData = new MediatorLiveData<>();
    mediatorLiveData.addSource(usersLiveData, new Observer<QuerySnapshot>() {
        @Override
        public void onChanged(@Nullable QuerySnapshot querySnapshot) {
            mediatorLiveData.setValue(querySnapshot);
        }
    });
    mediatorLiveData.addSource(booksLiveData, new Observer<QuerySnapshot>() {
        @Override
        public void onChanged(@Nullable QuerySnapshot querySnapshot) {
            mediatorLiveData.setValue(querySnapshot);
        }
    });
    return mediatorLiveData;
}

现在它正在返回另一个 LiveData 源的空结果。相反，我需要查询然后合并。关于如何做到这一点的任何想法？没有太多关于这件事的内容。

我尝试将查询放在使用 Transformations.map() 调用的函数中，但由于它是异步调用，因此在查询完成之前调用 return 语句。

这是我对函数的尝试：

    private class ListenUsersGetBooks implements Function<QuerySnapshot, LinkedHashMap<User, List<Book>>> {

        @Override
        public LinkedHashMap<User, List<Book>> apply(final QuerySnapshot input) {
            userBookList = new LinkedHashMap<>();
            getBooksQuery().get().addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                @Override
                public void onComplete(@NonNull Task<QuerySnapshot> task) {
                    List<User> users = input.toObjects(User.class);
                    List<Book> books = task.getResult().toObjects(Book.class);
                    Log.d(TAG, "USERLIST! " + users);
                    Log.d(TAG, "BOOKLIST! " + books);
                    for (User user : users) {
                        bookList = new ArrayList<>();
                        for (Book book : books) {
                            if (user.getUserID().equals(book.getUserID())
                                    && book.getBookAssigned()) {
                                bookList.add(book);
                            }
                            else if (user.getAllBookID().equals(book.getBookID())) {
                                bookList.add(book);
                            }
                        }
                        userBookList.put(user, bookList);
                    }
                    Log.d(TAG,"OBSERVE userBookList: " + userBookList);
                }
            });
            return userBookList;
        }
    }

标签： androidfirebasegoogle-cloud-firestoreandroid-architecture-componentsandroid-livedata

解决方案

这是您可以做的简单版本，我希望它有意义。

你与MediatorLiveData. 而不是MediatorLiveData<QuerySnapshot>您可能想要使用这样的自定义对象：

class MyResult {

  public QuerySnapshot usersSnapshot;
  public QuerySnapshot booksSnapshot;

  public MyResult() {}

  boolean isComplete() {
    return (usersSnapshot != null && booksSnapshot != null);
  }
}

然后在你的观察者中，做这样的事情：

private MediatorLiveData<MyResult> usersBooksLiveDataMerger() {
    final MediatorLiveData<MyResult> mediatorLiveData = new MediatorLiveData<>();
    mediatorLiveData.addSource(usersLiveData, new Observer<QuerySnapshot>() {
        @Override
        public void onChanged(@Nullable QuerySnapshot querySnapshot) {
            MyResult current = mediatorLiveData.getValue();
            current.usersSnapshot = querySnapshot;
            mediatorLiveData.setValue(current);
        }
    });
    mediatorLiveData.addSource(booksLiveData, new Observer<QuerySnapshot>() {
        @Override
        public void onChanged(@Nullable QuerySnapshot querySnapshot) {
            MyResult current = mediatorLiveData.getValue();
            current.booksSnapshot = querySnapshot;
            mediatorLiveData.setValue(current);
        }
    });
    return mediatorLiveData;
}

然后，当您观察组合的实时数据时：

usersBooksLiveDataMerger().observe(new Observer<MyResult>() {

    @Override
    public void onChanged(@Nullable MyResult result) {
        if (result == null || !result.isComplete()) {
          // Ignore, this means only one of the queries has fininshed
          return;
        }

        // If you get to here, you know all the queries are ready!
        // ...
    }

});

推荐阅读