Android如何在两个异步进程完成执行时触发一个进程

Question

我是 Android 后台任务的新手。我正在使用 Firestore 执行以下任务：

1. 阅读文档。 https://firebase.google.com/docs/firestore/query-data/get-data

   DBInstance.collection("restaurants")
               .get()
               .addOnCompleteListener(task -> {
                   if (task.isSuccessful()) {
   
                       for (QueryDocumentSnapshot document : Objects.requireNonNull(task.getResult())) {
   
                        // some other code
   
                       }
                   } else {
                       Log.d(TAG, "Error getting documents: ", task.getException());
                   }
   
   
               });
   

2. 收听另一个文档的实时更新。 https://firebase.google.com/docs/firestore/query-data/listen

   final DocumentReference docRef = DBInstance.collection("users").document(FirebaseAuth.getInstance().getCurrentUser().getUid());
       docRef.addSnapshotListener(new EventListener<DocumentSnapshot>() {
           @Override
           public void onEvent(@Nullable DocumentSnapshot snapshot,
                               @Nullable FirebaseFirestoreException e) {
               if (e != null) {
                   Log.w(TAG, "Listen failed.", e);
                   return;
               }
   
               String source = snapshot != null && snapshot.getMetadata().hasPendingWrites()
                       ? "Local" : "Server";
   
               if (snapshot != null && snapshot.exists()) {
                   Log.d(TAG, source + " data: " + snapshot.getData());
   
                   // some other code is run
   
               } else {
                   Log.i(TAG,"no snapshot found");
               }
           }
       });
   

由于这些是异步进程，因此它们是同时执行的（大致）。

我想在 1. 完成和 2. 返回非空快照时触发一个独立的方法。因此，当上面的some other code cmets 已经完成。

所以，我本质上想要一些后台进程处于空闲状态/侦听上述两个条件并执行任务/调用更新某些 UI 功能的方法。

我已经简要了解了BroadcastReciever。这相关吗？或者我可以创建一个在后台线程中运行的自定义侦听器吗？任何建议都会有所帮助，因为我不确定要搜索什么才能找到我想要的。

似乎有效的解决方案（Nehal 部分建议）

这与上面的代码相同，但空白处填写

DBInstance.collection("restaurants")
            .get()
            .addOnCompleteListener(task -> {
                if (task.isSuccessful()) {

                    for (QueryDocumentSnapshot document : Objects.requireNonNull(task.getResult())) {

                     restaurantsLoaded = true;
                     updateUI();

                    }
                } else {
                    Log.d(TAG, "Error getting documents: ", task.getException());
                    restaurantsLoaded = false;
                }


            });


    final DocumentReference docRef = DBInstance.collection("users").document(FirebaseAuth.getInstance().getCurrentUser().getUid());
docRef.addSnapshotListener(new EventListener<DocumentSnapshot>() {
    @Override
    public void onEvent(@Nullable DocumentSnapshot snapshot,
                        @Nullable FirebaseFirestoreException e) {
        if (e != null) {
            Log.w(TAG, "Listen failed.", e);
            return;
        }

        String source = snapshot != null && snapshot.getMetadata().hasPendingWrites()
                ? "Local" : "Server";

        if (snapshot != null && snapshot.exists()) {
            Log.d(TAG, source + " data: " + snapshot.getData());

            usersSnapshotTriggered = true;
            udpateUI();

        } else {
            Log.i(TAG,"no snapshot found");
        }
    }
});


public void updateUI(){
    if(usersSnapshotTriggered && restaurantsLoaded){
        // perform the updates
    }
}

Answer 1

您可以尝试以下解决方案： 声明一个全局 int 变量，在两个 firebase 监听器中递增该变量并从两个监听器调用 someMethod()。

private int count=0;

DBInstance.collection("restaurants")
            .get()
            .addOnCompleteListener(task -> {
                if (task.isSuccessful()) {

                    for (QueryDocumentSnapshot document : Objects.requireNonNull(task.getResult())) {

                     // some other code

                    }
                    count++;
                    someMethod();
                } else {
                    Log.d(TAG, "Error getting documents: ", task.getException());
                }


            });


final DocumentReference docRef = DBInstance.collection("users").document(FirebaseAuth.getInstance().getCurrentUser().getUid());
    docRef.addSnapshotListener(new EventListener<DocumentSnapshot>() {
        @Override
        public void onEvent(@Nullable DocumentSnapshot snapshot,
                            @Nullable FirebaseFirestoreException e) {
            if (e != null) {
                Log.w(TAG, "Listen failed.", e);
                return;
            }

            String source = snapshot != null && snapshot.getMetadata().hasPendingWrites()
                    ? "Local" : "Server";

            if (snapshot != null && snapshot.exists()) {
                Log.d(TAG, source + " data: " + snapshot.getData());

                // some other code is run
                    count++;
                    someMethod();
                    //Note : this method will call as many times as there is change in this data , so you have to handle according to your requirement
            } else {
                Log.i(TAG,"no snapshot found");
            }
        }
    });


private void someMethod(){
    if(count>=2){
       //execute your code
   }
}

希望这会有所帮助！

Answer 2

我想在1.和2.都完成后触发一个独立的方法

在您的第一个示例中，通过添加一个完整的侦听器，您将始终能够知道操作何时完成。如果task.isSuccessful() 返回true，您肯定知道操作已完成。除此之外，您还可以调用getResult() 来获取属于您的restaurants 集合的元素。此外，以下代码行：

DBInstance.collection("restaurants")
        .get()

返回一个Task<QuerySnapshot> 对象。如果您有两个不同的查询，您可以将两个 Task 对象传递给 Tasks 的 whenAllSuccess() 方法，正如我在以下帖子中的回答中所述：

• Firestore - Merging two queries locally

通过这种方式，您将能够知道两个操作何时完成。但是，当使用第二种方案时，您无法知道从数据库中获取数据何时完成，因为Cloud Firestore 是一个实时数据库，可能永远无法完成获取数据。这就是为什么被称为实时数据库的原因，因为在任何时候都可以更改数据库，可以添加或删除项目。

要部分了解您是否拥有特定集合中的所有数据的唯一方法是对其执行单值类型查询。即便如此，在调用该侦听器后数据可能会发生变化，因此您真正拥有的只是某个特定时刻的snapshot。

作为结论，您唯一的解决方案是使用 whenAllSuccess() 并传递两个甚至更多 Task 对象。

我已经简要了解了 BroadcastReciever。这相关吗？

不，不是。根据文档，BroadcastReceiver 类是：

接收和处理 Context.sendBroadcast(Intent) 发送的广播意图的代码基类。

所以，事实并非如此。

或者我可以创建一个在后台线程中运行的自定义侦听器吗？

Cloud Firestore 客户端已在后台线程中运行所有网络操作。这意味着所有操作都不会阻塞您的主线程。将它放在后台线程中不会带来任何额外的好处。