Android 如何使用firestore在回收器视图中加载批量数据？

我想知道如何使用firestore在recylcer视图中加载更多数据

 Query query = FirebaseFirestore.getInstance()
            .collection("ie").limit(5);  
adapter=new InterviewAdapter(this,query);    
recyclerView.setAdapter(adapter);
recyclerView.setLayoutManager(new LinearLayoutManager(this));

适配器类如下所示：

public class InterviewAdapter extends FireStoreAdapter<InterviewAdapter.ViewHolder> {

public interface OnInterviewSelectedListener {

    void onInterviewSelected(DocumentSnapshot interview);

}

private InterviewAdapter.OnInterviewSelectedListener mListener;

public InterviewAdapter(Query query, OnInterviewSelectedListener listener) {
    super(query);
    mListener = listener;
}

@Override
public InterviewAdapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    LayoutInflater inflater = LayoutInflater.from(parent.getContext());
    return new InterviewAdapter.ViewHolder(inflater.inflate(R.layout.ie, parent, false));
}

@Override
public void onBindViewHolder(InterviewAdapter.ViewHolder holder, int position) {
    holder.bind(getSnapshot(position), mListener);
}

static class ViewHolder extends RecyclerView.ViewHolder {

    TextView title,companyName,username,views,isHired;

    public ViewHolder(View itemView) {
        super(itemView);
        title= (TextView) itemView.findViewById(R.id.title);
        companyName= (TextView) itemView.findViewById(R.id.companyName);
        username= (TextView) itemView.findViewById(R.id.username);
        views= (TextView) itemView.findViewById(R.id.views);
        isHired= (TextView) itemView.findViewById(R.id.isHired);
    }

    public void bind(final DocumentSnapshot snapshot,
                     final OnInterviewSelectedListener listener) {


        InterviewExperience experience;
        String companyName=snapshot.getString("companyName");
        boolean isHired=Boolean.valueOf(snapshot.getBoolean("isHired"));
        String username=snapshot.getString("username");
        long views=new Double(Double.valueOf(snapshot.getDouble("views"))).longValue();

        String id=snapshot.getId();


        String title=snapshot.getString("title");
        experience=new InterviewExperience(id,title,companyName,username,isHired,views,null,null);


        this.title.setText(experience.getTitle());
        this.companyName.setText("Company Name: "+experience.getCompanyName());
        this.isHired.setText("Hired: "+experience.isHired());
        this.views.setText("Views: "+experience.getViews()+"");
        this.username.setText("Created By: "+experience.getUsername());



        // Click listener
        itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (listener != null) {
                    listener.onInterviewSelected(snapshot);
                }
            }
        });
    }

}
}

public abstract class FireStoreAdapter<VH extends RecyclerView.ViewHolder>
    extends RecyclerView.Adapter<VH>
    implements EventListener<QuerySnapshot> {

private static final String TAG = "FirestoreAdapter";

private Query mQuery;
private ListenerRegistration mRegistration;

private ArrayList<DocumentSnapshot> mSnapshots = new ArrayList<>();

public FireStoreAdapter(Query query) {
    mQuery = query;
}

@Override
public void onEvent(QuerySnapshot documentSnapshots, FirebaseFirestoreException e) {
    if (e != null) {
        Log.w(TAG, "onEvent:error", e);
        onError(e);
        return;
    }

    // Dispatch the event
    Log.d(TAG, "onEvent:numChanges:" + documentSnapshots.getDocumentChanges().size());
    for (DocumentChange change : documentSnapshots.getDocumentChanges()) {
        switch (change.getType()) {
            case ADDED:
                onDocumentAdded(change);
                break;
            case MODIFIED:
                onDocumentModified(change);
                break;
            case REMOVED:
                onDocumentRemoved(change);
                break;
        }
    }

    onDataChanged();
}

public void startListening() {
    if (mQuery != null && mRegistration == null) {
        mRegistration = mQuery.addSnapshotListener(this);
    }
}

public void stopListening() {
    if (mRegistration != null) {
        mRegistration.remove();
        mRegistration = null;
    }

    mSnapshots.clear();
    notifyDataSetChanged();
}

public void setQuery(Query query) {
    // Stop listening
    stopListening();

    // Clear existing data
    mSnapshots.clear();
    notifyDataSetChanged();

    // Listen to new query
    mQuery = query;
    startListening();
}

@Override
public int getItemCount() {
    return mSnapshots.size();
}

protected DocumentSnapshot getSnapshot(int index) {
    return mSnapshots.get(index);
}

protected void onDocumentAdded(DocumentChange change) {
    mSnapshots.add(change.getNewIndex(), change.getDocument());
    notifyItemInserted(change.getNewIndex());
}

protected void onDocumentModified(DocumentChange change) {
    if (change.getOldIndex() == change.getNewIndex()) {
        // Item changed but remained in same position
        mSnapshots.set(change.getOldIndex(), change.getDocument());
        notifyItemChanged(change.getOldIndex());
    } else {
        // Item changed and changed position
        mSnapshots.remove(change.getOldIndex());
        mSnapshots.add(change.getNewIndex(), change.getDocument());
        notifyItemMoved(change.getOldIndex(), change.getNewIndex());
    }
}

protected void onDocumentRemoved(DocumentChange change) {
    mSnapshots.remove(change.getOldIndex());
    notifyItemRemoved(change.getOldIndex());
}

protected void onError(FirebaseFirestoreException e) {};

protected void onDataChanged() {}
}

private void paginate(final DocumentSnapshot last, final int limit) {
    final Query subset;
    if (last == null) {
        subset = db.collection("interviews")
                .limit(limit);
    } else {
        subset = db.collection("interviews")
                .startAfter(last)
                .limit(limit);
    }
    setQuery(subset);
}

公共类InterviewAdapter扩展FireStoreAdapter{
InterviewSelectedListener上的公共界面{
已选择的访谈无效（文档快照访谈）；
}
private InterviewAdapter.OnInterviewSelectedListener MLListener；
公共访谈适配器（查询，OnInterviewSelectedListener）{
超级（查询）；
mListener=监听器；
}
@凌驾
public InterviewAdapter.ViewHolder onCreateViewHolder（视图组父级，int-viewType）{
LayoutInflater充气器=LayoutInflater.from（parent.getContext（））；
返回新的InterviewAdapter.ViewHolder（充气器充气（R.layout.ie，parent，false））；
}
@凌驾
公共无效onBindViewHolder（InterviewAdapter.ViewHolder，int位置）{
holder.bind（获取快照（位置），mListener）；
}
静态类ViewHolder扩展了RecyclerView.ViewHolder{
文本视图标题、公司名称、用户名、视图、isHired；
公共视图持有者（视图项视图）{
超级（项目视图）；
title=（TextView）itemView.findViewById（R.id.title）；
companyName=（TextView）itemView.findViewById（R.id.companyName）；
username=（TextView）itemView.findViewById（R.id.username）；
views=（TextView）itemView.findViewById（R.id.views）；
isHired=（TextView）itemView.findViewById（R.id.isHired）；
}
公共无效绑定（最终文档快照、，
最终OnInterviewSelectedListener（监听器）{
面试经验；
String companyName=snapshot.getString（“companyName”）；
boolean isHired=boolean.valueOf（snapshot.getBoolean（“isHired”）；
字符串username=snapshot.getString（“用户名”）；
长视图=新的Double（Double.valueOf（snapshot.getDouble（“视图”））.longValue（）；
String id=snapshot.getId（）；
String title=snapshot.getString（“title”）；
经验=新的面试经验（id、标题、公司名称、用户名、isHired、视图、null、null）；
this.title.setText（experience.getTitle（））；
this.companyName.setText（“公司名称：+experience.getCompanyName（））；
this.isHired.setText（“雇用：+experience.isHired（））；
this.views.setText（“视图：+experience.getViews（）+”）；
this.username.setText（“创建人：”+experience.getUsername（））；
//单击侦听器
itemView.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
if（侦听器！=null）{
listener.onInterviewSelected（快照）；
}
}
});
}
}
}
公共抽象类FireStoreAdapter
扩展RecyclerView.Adapter
实现EventListener{
私有静态最终字符串标记=“FirestoreAdapter”；
私有查询；
私人听众登记；
private ArrayList mSnapshots=new ArrayList（）；
公共FireStoreAdapter（查询）{
mQuery=query；
}
@凌驾
public void OneEvent（QuerySnapshot文档快照，FireBaseFireStore异常e）{
如果（e！=null）{
Log.w（标记“onEvent:error”，e）；
onError（e）；
返回；
}
//发送事件
Log.d（标记“onEvent:numChanges:”+documentSnapshots.getDocumentChanges（）.size（））；
对于（DocumentChange:documentSnapshots.getDocumentChanges（））{
开关（change.getType（））{
案件补充：
OnDocuments已添加（更改）；
打破
案例修改：
onDocumentModified（变更）；
打破
已删除的案例：
OnDocument已删除（更改）；
打破
}
}
onDataChanged（）；
}
公营机构{
if（mQuery！=null&&mRegistration==null）{
mRegistration=mQuery.addSnapshotListener（此）；
}
}
公营部门{
如果（mRegistration！=null）{
mrregistration.remove（）；
mRegistration=null；
}
mSnapshots.clear（）；
notifyDataSetChanged（）；
}
公共void setQuery（查询）{
//别再听了
停止倾听（）；
//清除现有数据
mSnapshots.clear（）；
notifyDataSetChanged（）；
//听新的查询
mQuery=query；
惊人的倾听（）；
}
@凌驾
public int getItemCount（）{
返回mSnapshots.size（）；
}
受保护的文档快照getSnapshot（int索引）{
返回mSnapshots.get（索引）；
}
已添加受保护的文档无效（文档更改）{
添加（change.getNewIndex（），change.getDocument（））；
notifyItemInserted（change.getNewIndex（））；
}
受保护的文档无效已修改（文档更改）{
if（change.getoldinex（）==change.getNewIndex（））{
//项目已更改，但仍处于相同位置
mSnapshots.set（change.getOldIndex（），change.getDocument（））；
notifyItemChanged（change.getOldIndex（））；
}否则{
//项目变更和变更位置
mSnapshots.remove（change.getOldIndex（））；
添加（change.getNewIndex（），change.getDocument（））；
notifyItemMoved（change.getOldIndex（），change.getNewIndex（））；
}
}
已删除文档上的受保护无效（文档更改）{
mSnapshots.remove（change.getOldIndex（））；
notifyItemRemoved（change.getOldIndex（））；
}
受保护的无效onError（FirebaseFirestoreException e）{}；
受保护的无效onDataChanged（）{}
}

我使用了Firestore文档示例中给出的Firestore适配器代码。有人知道如何使用查询对象加载更多数据吗

---

当用户滚动到列表末尾时，如何在“回收器”视图中加载接下来的5项？

您可以使用

Query

等

方法，使用指定的
DocumentSnapshot
对
查询的结果进行分页

如果我认为您的收藏名为“访谈”，您可以像这样向
FireStoreAdapter
添加一个方法
final List<DocumentChange> changes = documentSnapshots.getDocumentChanges();
final DocumentSnapshot lastDocument = changes.get(changes.size() - 1).getDocument();

paginate(lastDocument, 5);