问具有cubit和Firebase API的无限滚动

EN

async getTasksByFilter(filters: Array<IFilter>): Promise<Array<ITask>> {
    let tasksUser: Array<ITask> = [];
    let collectionQuerry: Query<DocumentData> = this.db.collection(
        this.taskCollection,
    );
    let query = collectionQuerry;
    return new Promise((resolve, reject) => {
        filters.forEach(entry => {
            switch (entry.searchType) {
                case 'where':
                    query = query.where(
                        entry.field,
                        entry.condition as WhereFilterOp,
                        entry.value,
                    );
                    break;
                default:
                    break;
            }
        });
        query
            .orderBy('createdAt', 'asc')
            .get()
            .then(query => {
                if (query.docs.length > 0) {
                    query.docs.forEach(doc => {
                        let task: ITask = this.transformDate(doc.data());
                        tasksUser.push(task);
                    });
                }
                return resolve(tasksUser);
            })
            .catch(error => {
                return reject(error);
            });
    });
} 

Future<List<Task>> getUserTasks(String _extension, Filter filters) async {
    final Response response =
    await client.post(Uri.parse("$BASE_URL$_extension"),
      headers: <String, String>{
        'Content-Type': 'application/json; charset=UTF-8',
      },
      body: jsonEncode(filters.toJson()),
    );

    Iterable l = jsonDecode(response.body);
    List<Task> tasks = List<Task>.from(l.map((model) => Task.fromJson(model)));

    return tasks;
  }

BlocConsumer<TaskListCubit, TaskListState>(
              listenWhen: (previous, current) =>
              current is FatalErrorTaskListState,
              listener: (context, state) {
                if (state is FatalErrorTaskListState) {
                  showDialog(
                    context: context,
                    builder: (BuildContext context) {
                      return AlertDialog(
                        title: Text(state.title ?? 'Error'),
                        content: Text(state.message ?? 'Error'),
                        actions: <Widget>[
                          TextButton(
                            child: const Text('Ok'),
                            onPressed: () {
                              Navigator.of(context).pop();
                            },
                          ),
                        ],
                      );
                    },
                  );
                }
              },
              builder: (context, state) {
                if (state is InitTaskListState ||
                    state is LoadingTaskListState) {
                  return const ProgressView(message: 'Loading tasks');
                }
                if (state is LoadedTaskListState) {
                  final tasks = state.tasks;
                  return taskList(context, cubit, state, tasks);
                }
                return const Text('Unknown error');
              },
            )

  TabBarView taskList(BuildContext context, TaskListCubit cubit,
      LoadedTaskListState state, List<Task> tasks) {
    return TabBarView(
      physics: const NeverScrollableScrollPhysics(),
      children: List<Widget>.generate(
        cubit.tabNames.length,
        (int index) {
          if (index == state.tabIndex) {
            return Center(
              child: tasks.isEmpty
                  ? setEmptyListText(state.tabName)
                  : Column(
                      children: [
                        Expanded(
                          child: ListView.builder(
                            itemBuilder: (context, index) {
                              final task = tasks[index];
                              return TaskCard(
                                task,
                                state.tabName,
                                state.tabType,
                                cubit,
                                onClick: () {
                                  push(
                                    context,
                                    TaskDetailsContainer(task, state.tabType),
                                  );
                                },
                              );
                            },
                            itemCount: tasks.length,
                          ),
                        ),
                      ],
                    ),
            );
          } else {
            return const Text('');
          }
        },
      ),
    );
  }