Android Firestore嵌套获取使用回调在初始调用时获取空结果

下面是我的设想： 我在他们自己的类中分别调用了三个firestore。所有三个调用都嵌套在彼此的回调中，在最后一个回调中，我完成了所有工作。当我触发此堆栈时，我的管理对象将已经存在，而我的用户列表和书籍列表将在该堆栈侦听更新时创建。如果数据库中不存在数据，并且我们创建了一个条目，那么回调不会报告一本书（但是我会得到Admin和User对象）。但是，如果我们重新打开应用程序，并且数据库中已经存在数据，那么回调会报告一些情况。在此之后，每当我添加用户/书籍时，列表都会正确更新

注意：这些是实时侦听器，因此一旦添加了用户/书籍，我们就应该看到更新

以下是我的课程：

public class FirebaseGetThisAdmin {

    //firebase objects
    private FirebaseAuth mAuth;
    private FirebaseFirestore mDbase;

    private Activity activity;

    private Admin admin;
    private String adminID;

    //default constructor
    public FirebaseGetThisAdmin() {
    }

    public FirebaseGetThisAdmin(Activity activity) {
        this.activity = activity;
    }

    public interface FirestoreCallback {
        void onCallback(Admin admin);
    }

    public void readDataRTUpdate(final FirestoreCallback firestoreCallback) {

        //firebase new instances
        mAuth = FirebaseAuth.getInstance();
        mDbase = FirebaseFirestore.getInstance();

        //get admin email address and user name from Auth and set textInput fields to them
        if (mAuth.getCurrentUser() != null) {
            adminID = mAuth.getUid();
        }

        final DocumentReference docRef = mDbase.collection("admins").document(adminID);
        docRef.addSnapshotListener(activity, 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()) {
                    admin = new Admin();
                    admin = snapshot.toObject(Admin.class);
                    //pass variables to the callback
                    firestoreCallback.onCallback(admin);
                    Log.d(TAG, source + " data: " + snapshot.getData());
                } else {
                    Log.d(TAG, source + " data: null");
                }
            }
        });
    }
} 

 public class FirebaseGetUsers {

    //firebase objects
    private FirebaseAuth mAuth;
    private FirebaseFirestore mDbase;

    private Activity activity;

    private String adminID;

    //default constructor
    public FirebaseGetUsers() {
    }

    public FirebaseGetUsers(Activity activity) {
        this.activity = activity;

        //firebase new instances
        mAuth = FirebaseAuth.getInstance();
        mDbase = FirebaseFirestore.getInstance();

        if (mAuth.getCurrentUser() != null) {
            adminID = mAuth.getUid();
        }
    }

    public interface FirestoreCallback {
        void onCallback(List<User> users);
    }

    public void readDataRTUpdate(final FirestoreCallback firestoreCallback) {
        mDbase.collection("admins").document(adminID).collection("users")
                .addSnapshotListener(activity, new EventListener<QuerySnapshot>() {
                    @Override
                    public void onEvent(@Nullable QuerySnapshot value,
                                        @Nullable FirebaseFirestoreException e) {
                        if (e != null) {
                            Log.w(TAG, "Listen failed.", e);
                            return;
                        }
                        if (value != null) {
                            int i = 0;
                            List<User> users = new ArrayList<>();
                            for (QueryDocumentSnapshot document : value) {
                                users.add(document.toObject(User.class));
                                Log.d(TAG, "User: " + users.get(i).toString());
                                i++;
                            }
                            firestoreCallback.onCallback(users);
                            Log.d(TAG, "Document updated.");
                        }
                        else {
                            Log.d(TAG, "No such document");
                        }
                    }
                });
    }
}

公共类FirebaseGetThisAdmin{
//firebase对象
私人消防队；
私有Firebase Firestore mDbase；
私人活动；
私人行政；
私有字符串adminID；
//默认构造函数
公共FirebaseGetThisAdmin（）{
}
公共FirebaseGetThisAdmin（活动）{
这个。活动=活动；
}
公共接口FirestoreCallback{
void onCallback（管理员）；
}
public void readDataRTUpdate（最终FirestoreCallback FirestoreCallback）{
//firebase新实例
mAuth=FirebaseAuth.getInstance（）；
mDbase=FirebaseFirestore.getInstance（）；
//从Auth获取管理员电子邮件地址和用户名，并为其设置textInput字段
if（mAuth.getCurrentUser（）！=null）{
adminID=mAuth.getUid（）；
}
最终文档参考docRef=mDbase.collection（“管理员”）.document（adminID）；
docRef.addSnapshotListener（活动，新的EventListener（）{
@凌驾
public void onEvent（@Nullable DocumentSnapshot快照，
@可为空的FireBaseFireStore异常（e）{
如果（e！=null）{
Log.w（标记“侦听失败”，e）；
返回；
}
String source=snapshot！=null&&snapshot.getMetadata（）.hasPendingWrites（）
？“本地”：“服务器”；
if（snapshot！=null&&snapshot.exists（））{
admin=newadmin（）；
admin=snapshot.toObject（admin.class）；
//将变量传递给回调函数
firestoreCallback.onCallback（admin）；
Log.d（标记，源+“数据：”+snapshot.getData（））；
}否则{
Log.d（标记，源+“数据：空”）；
}
}
});
}
} 
公共类FirebaseGetUsers{
//firebase对象
私人消防队；
私有Firebase Firestore mDbase；
私人活动；
私有字符串adminID；
//默认构造函数
公共FirebaseGetUsers（）{
}
公共FirebaseGetUsers（活动）{
这个。活动=活动；
//firebase新实例
mAuth=FirebaseAuth.getInstance（）；
mDbase=FirebaseFirestore.getInstance（）；
if（mAuth.getCurrentUser（）！=null）{
adminID=mAuth.getUid（）；
}
}
公共接口FirestoreCallback{
void onCallback（列出用户）；
}
public void readDataRTUpdate（最终FirestoreCallback FirestoreCallback）{
mDbase.collection（“管理员”）.document（adminID.collection（“用户”）
.addSnapshotListener（活动，新的EventListener（）{
@凌驾
public void onEvent（@Nullable QuerySnapshot value，
@可为空的FireBaseFireStore异常（e）{
如果（e！=null）{
Log.w（标记“侦听失败”，e）；
返回；
}
if（值！=null）{
int i=0；
列表用户=新建ArrayList（）；
for（QueryDocumentSnapshot文档：值）{
添加（document.toObject（User.class））；
Log.d（标记“User:+users.get（i.toString（））；
i++；
}
firestoreCallback.onCallback（用户）；
Log.d（标签“文件更新”）；
}
否则{
日志d（标签“无此类文件”）；
}
}
});
}
}

下一步：

公共类FirebaseGetUsers{
//firebase对象
私人消防队；
私有Firebase Firestore mDbase；
私人活动；
私有字符串adminID；
//默认构造函数
公共FirebaseGetUsers（）{
}
公共FirebaseGetUsers（活动）{
这个。活动=活动；
//firebase新实例
mAuth=FirebaseAuth.getInstance（）；
mDbase=FirebaseFirestore.getInstance（）；
if（mAuth.getCurrentUser（）！=null）{
adminID=mAuth.getUid（）；
}
}
公共接口FirestoreCallback{
void onCallback（列出用户）；
}
public void readDataRTUpdate（最终FirestoreCallback FirestoreCallback）{
mDbase.collection（“管理员”）.document（adminID.collection（“用户”）
.addSnapshotListener（活动，新的EventListener（）{
@凌驾
public void onEvent（@Nullable QuerySnapshot value，
@可为空的FireBaseFireStore异常（e）{
如果（e！=null）{
Log.w（标记“侦听失败”，e）；
返回；
 public class FirebaseGetUsers {

    //firebase objects
    private FirebaseAuth mAuth;
    private FirebaseFirestore mDbase;

    private Activity activity;

    private String adminID;

    //default constructor
    public FirebaseGetUsers() {
    }

    public FirebaseGetUsers(Activity activity) {
        this.activity = activity;

        //firebase new instances
        mAuth = FirebaseAuth.getInstance();
        mDbase = FirebaseFirestore.getInstance();

        if (mAuth.getCurrentUser() != null) {
            adminID = mAuth.getUid();
        }
    }

    public interface FirestoreCallback {
        void onCallback(List<User> users);
    }

    public void readDataRTUpdate(final FirestoreCallback firestoreCallback) {
        mDbase.collection("admins").document(adminID).collection("users")
                .addSnapshotListener(activity, new EventListener<QuerySnapshot>() {
                    @Override
                    public void onEvent(@Nullable QuerySnapshot value,
                                        @Nullable FirebaseFirestoreException e) {
                        if (e != null) {
                            Log.w(TAG, "Listen failed.", e);
                            return;
                        }
                        if (value != null) {
                            int i = 0;
                            List<User> users = new ArrayList<>();
                            for (QueryDocumentSnapshot document : value) {
                                users.add(document.toObject(User.class));
                                Log.d(TAG, "User: " + users.get(i).toString());
                                i++;
                            }
                            firestoreCallback.onCallback(users);
                            Log.d(TAG, "Document updated.");
                        }
                        else {
                            Log.d(TAG, "No such document");
                        }
                    }
                });
    }
}

   public class FirebaseGetBooks {

    //firebase objects
    private FirebaseFirestore mDbase;

    private Activity activity;

    private String groupID;

    //default constructor
    public FirebaseGetBooks() {
    }

    public FirebaseGetBooks(Activity activity) {
        this.activity = activity;

        //firebase new instances
        mDbase = FirebaseFirestore.getInstance();

        FirebaseGetGroupID firebaseGetGroupID = new FirebaseGetGroupID(activity);
        groupID = firebaseGetGroupID.getGroupID();
    }


    public interface FirestoreCallback {
        void onCallback(List<Book> books);
    }


    public void readDataRTUpdate(final FirestoreCallback firestoreCallback) {
        mDbase.collection("books").whereEqualTo("groupID", groupID)
                .addSnapshotListener(activity, new EventListener<QuerySnapshot>() {
                    @Override
                    public void onEvent(@Nullable QuerySnapshot value,
                                        @Nullable FirebaseFirestoreException e) {
                        if (e != null) {
                            Log.w(TAG, "Listen failed.", e);
                            return;
                        }
                        if (value != null) {
                            int i = 0;
                            List<Book> books = new ArrayList<>();
                            for (QueryDocumentSnapshot document : value) {
                                books.add(document.toObject(Book.class));
                                Log.d(TAG, "Book: " + books.get(i).toString());
                                i++;
                            }
                            firestoreCallback.onCallback(books);
                            Log.d(TAG, "Document updated.");
                        }
                        else {
                            Log.d(TAG, "No such document");
                        }
                    }
                });
    }
} 

    firebaseGetUsers.readDataRTUpdate(new FirebaseGetUsers.FirestoreCallback() {
            @Override
            public void onCallback(final List<User> users) {
                firebaseGetBooks.readDataRTUpdate(new FirebaseGetBooks.FirestoreCallback() {
                    @Override
                    public void onCallback(final List<Book> books) {
                        firebaseGetThisAdmin.readDataRTUpdate(new FirebaseGetThisAdmin.FirestoreCallback() {
                            @Override
                            public void onCallback(Admin admin) {
                                //processing all code here.
                                //books are empty!!
                                System.out.println("books: " + books.toString());
                                }
                            }
                        });
                    }
                });
            }
        });