syncState static method

Map<String, List<Presence>> syncState(Map<String, List<Presence>> currentState, Map<String, dynamic> newState, [ PresenceOnJoinCallback? onJoin, PresenceOnLeaveCallback? onLeave, ])

Used to sync the list of presences on the server with the client's state.

An optional onJoin and onLeave callback can be provided to react to changes in the client's local presences across disconnects and reconnects with the server.

Implementation

static Map<String, List<Presence>> syncState(
  Map<String, List<Presence>> currentState,
  Map<String, dynamic> newState, [
  PresenceOnJoinCallback? onJoin,
  PresenceOnLeaveCallback? onLeave,
]) {
  final state = _cloneDeep(currentState);
  final transformedState = _transformState(newState);
  final joins = <String, dynamic>{};
  final leaves = <String, dynamic>{};

  _map(state, (key, presence) {
    if (!transformedState.containsKey(key)) {
      leaves[key] = presence;
    }
  });

  _map(transformedState, (key, newPresences) {
    final currentPresences = state[key];

    if (currentPresences != null) {
      final newPresenceRefs =
          (newPresences as List).map((m) => m.presenceRef as String).toList();
      final curPresenceRefs =
          currentPresences.map((m) => m.presenceRef).toList();
      final joinedPresences = newPresences
          .where((m) => !curPresenceRefs.contains(m.presenceRef))
          .toList() as List<Presence>;
      final leftPresences = currentPresences
          .where((m) => !newPresenceRefs.contains(m.presenceRef))
          .toList();

      if (joinedPresences.isNotEmpty) {
        joins[key] = joinedPresences;
      }

      if (leftPresences.isNotEmpty) {
        leaves[key] = leftPresences;
      }
    } else {
      joins[key] = newPresences;
    }
  });

  return syncDiff(state, {'joins': joins, 'leaves': leaves}, onJoin, onLeave);
}