如何监听Firestore中calendar集合events数组内引用文档的变更？

问题描述 #

我在Firestore的calendar集合中，每个文档包含名为events的数组，数组内存储指向assignments集合文档的引用，用于在日历中按天读取日程信息。目前我的代码仅能监听calendar文档的变更，无法监听这些被引用的assignments文档的变更，请问是否可以实现对这些引用文档的变更监听？

文档结构 #

Calendar文档结构 #

array : events
   0: assignments/reference(docid)
   1: assignments/reference(docid)

Assignments文档结构 #

String date : dd/MM/yyyy
String eventType : Public opening
String time : HH:mm-HH:mm
String responsible : username

现有代码 #

void listenToDocumentChanges(DateTime selectedDay) {
  final formattedDate = DateFormat('yyyy-MM-dd').format(selectedDay);

  FirebaseFirestore.instance
      .collection('calendar')
      .doc(formattedDate)
      .snapshots()
      .listen((calendarDocSnapshot) async {
    try {
      state = state.copyWith(isLoading: true, hasError: false);

      if (calendarDocSnapshot.exists) {
        final data = calendarDocSnapshot.data() ?? {};
        final events = (data['events'] as List?)?.cast<dynamic>() ?? [];

        final resolvedEvents = await resolveEvents(events);

        // Update the cache with events for the selected day
        state = state.copyWith(
          eventsCache: {
            ...state.eventsCache,
            formattedDate: resolvedEvents,
          },
          isLoading: false,
        );

        print(
            'Updated cache with ${resolvedEvents.length} events for $formattedDate');
      } else {
        state = state.copyWith(
          eventsCache: {
            ...state.eventsCache,
            formattedDate: [],
          },
          isLoading: false,
        );

        print('No document exists for date: $formattedDate');
      }
    } catch (e) {
      logError('Error in listenToDocumentChanges', e);

      state = state.copyWith(
        eventsCache: {
          ...state.eventsCache,
          formattedDate: [],
        },
        isLoading: false,
        hasError: true,
      );
    }
  }, onError: (error) {
    logError('Snapshot listener error', error);

    state = state.copyWith(
      eventsCache: {
        ...state.eventsCache,
        formattedDate: [],
      },
      isLoading: false,
      hasError: true,
    );
  });
}

Future<List<Map<String, dynamic>>> resolveEvents(List<dynamic> events) async {
  try {
    final List<Map<String, dynamic>> resolvedEvents = [];
    final List<DocumentReference> references = [];

    for (var event in events) {
      if (event is DocumentReference) {
        references.add(event);
      } else if (event is Map<String, dynamic>) {
        resolvedEvents.add(event);
      }
    }

    if (references.isNotEmpty) {
      final snapshots = await Future.wait(references.map((ref) => ref.get()));
      for (var snapshot in snapshots) {
        if (snapshot.exists) {
          final data = snapshot.data() as Map<String, dynamic>?;
          if (data != null) {
            resolvedEvents.add({
              ...data,
              'reference': snapshot.reference.path,
            });
          }
        }
      }
    }

    return resolvedEvents;
  } catch (e) {
    logError('Error resolving events', e);
    return [];
  }
}

void logError(String message, dynamic error) {
  print('$message: $error');
}

解决方案 #

可以实现对引用的assignments文档变更监听，核心是为每个assignments引用添加独立的快照监听，并管理这些订阅的生命周期，避免内存泄漏。

1. 添加订阅管理变量 #

维护一个Map保存每个日期对应的assignments文档监听订阅，方便后续取消旧订阅：

// 保存每个日期对应的assignments订阅，key为格式化日期，value为订阅列表
final Map<String, List<StreamSubscription>> _assignmentSubscriptions = {};

2. 修改监听逻辑 #

更新listenToDocumentChanges方法，处理calendar文档快照时先取消旧订阅，再为新引用添加监听，在回调中实时更新缓存：

void listenToDocumentChanges(DateTime selectedDay) {
  final formattedDate = DateFormat('yyyy-MM-dd').format(selectedDay);

  // 先取消该日期下已有的assignments订阅
  _assignmentSubscriptions[formattedDate]?.forEach((sub) => sub.cancel());
  _assignmentSubscriptions.remove(formattedDate);

  FirebaseFirestore.instance
      .collection('calendar')
      .doc(formattedDate)
      .snapshots()
      .listen((calendarDocSnapshot) async {
    try {
      state = state.copyWith(isLoading: true, hasError: false);

      if (calendarDocSnapshot.exists) {
        final data = calendarDocSnapshot.data() ?? {};
        final events = (data['events'] as List?)?.cast<dynamic>() ?? [];

        // 解析初始事件数据
        final resolvedEvents = await resolveEvents(events);
        state = state.copyWith(
          eventsCache: {
            ...state.eventsCache,
            formattedDate: resolvedEvents,
          },
          isLoading: false,
        );

        // 为每个assignments引用添加监听
        final subscriptions = <StreamSubscription>[];
        for (var event in events) {
          if (event is DocumentReference) {
            final sub = event.snapshots().listen((assignmentSnapshot) {
              if (assignmentSnapshot.exists) {
                final assignmentData = assignmentSnapshot.data() as Map<String, dynamic>?;
                if (assignmentData != null) {
                  // 更新缓存中对应的事件
                  final currentEvents = List<Map<String, dynamic>>.from(state.eventsCache[formattedDate] ?? []);
                  final index = currentEvents.indexWhere((e) => e['reference'] == assignmentSnapshot.reference.path);
                  if (index != -1) {
                    currentEvents[index] = {
                      ...assignmentData,
                      'reference': assignmentSnapshot.reference.path,
                    };
                  } else {
                    // 处理新增的引用（calendar文档更新时添加的新引用）
                    currentEvents.add({
                      ...assignmentData,
                      'reference': assignmentSnapshot.reference.path,
                    });
                  }
                  state = state.copyWith(
                    eventsCache: {
                      ...state.eventsCache,
                      formattedDate: currentEvents,
                    },
                  );
                }
              } else {
                // 处理文档被删除的情况
                final currentEvents = List<Map<String, dynamic>>.from(state.eventsCache[formattedDate] ?? []);
                currentEvents.removeWhere((e) => e['reference'] == event.path);
                state = state.copyWith(
                  eventsCache: {
                    ...state.eventsCache,
                    formattedDate: currentEvents,
                  },
                );
              }
            });
            subscriptions.add(sub);
          }
        }
        // 保存该日期的订阅列表
        _assignmentSubscriptions[formattedDate] = subscriptions;

        print('Updated cache with ${resolvedEvents.length} events for $formattedDate');
      } else {
        state = state.copyWith(
          eventsCache: {
            ...state.eventsCache,
            formattedDate: [],
          },
          isLoading: false,
        );
        print('No document exists for date: $formattedDate');
      }
    } catch (e) {
      logError('Error in listenToDocumentChanges', e);
      state = state.copyWith(
        eventsCache: {
          ...state.eventsCache,
          formattedDate: [],
        },
        isLoading: false,
        hasError: true,
      );
    }
  }, onError: (error) {
    logError('Snapshot listener error', error);
    state = state.copyWith(
      eventsCache: {
        ...state.eventsCache,
        formattedDate: [],
      },
      isLoading: false,
      hasError: true,
    );
  });
}

3. 清理订阅 #

在页面销毁或不再需要监听时，取消所有订阅防止内存泄漏：

void dispose() {
  // 取消所有assignments订阅
  _assignmentSubscriptions.values.expand((subs) => subs).forEach((sub) => sub.cancel());
  _assignmentSubscriptions.clear();
  super.dispose();
}

关键说明 #

• 当calendar文档的events数组变更时，会先取消旧的assignments订阅，再添加新的订阅，确保监听最新的引用列表。
• 每个assignments文档变更时，直接更新缓存中对应的事件数据，无需重新拉取整个calendar文档。
• 必须管理订阅生命周期，在不需要时取消订阅，避免内存泄漏。

内容的提问来源于stack exchange，提问作者Ser