allMembers function

Future<void> allMembers(
  1. AllMembersOptions options
)

Manages all members and updates the UI.

This function updates the participants list by filtering out banned or suspended members, updates request lists, manages connections, and reorders streams if necessary. It also handles waiting room participants, sets up connections for active participants, and updates UI states like screen share and host switches as needed.

Example Usage:

final options = AllMembersOptions(
  members: [
    Participant(name: 'Alice', audioID: 'audio1', videoID: 'video1', isBanned: false, isSuspended: false),
    Participant(name: 'Bob', audioID: 'audio2', videoID: 'video2', isBanned: false, isSuspended: false),
  ],
  requests: [Request(id: 'req1', name: 'Alice'), Request(id: 'req2', name: 'Bob')],
  coHost: 'Alice',
  coHostRes: [CoHostResponsibility(id: 'res1', task: 'manage')],
  parameters: AllMembersParameters(
    participantsAll: [],
    participants: [],
    dispActiveNames: ['Alice', 'Bob'],
    requestList: [],
    coHost: 'Alice',
    coHostResponsibility: [],
    lockScreen: false,
    firstAll: false,
    membersReceived: false,
    roomRecvIPs: ['192.000.1.1'],
    deferScreenReceived: true,
    screenId: 'screen123',
    shareScreenStarted: false,
    meetingDisplayType: 'all',
    hostFirstSwitch: false,
    waitingRoomList: [WaitingRoomParticipant(name: 'Charlie')],
    islevel: '2',
    socket: socketInstance,
    updateParticipantsAll: (updatedList) => print('Participants all updated: $updatedList'),
    updateParticipants: (filteredList) => print('Filtered participants updated: $filteredList'),
    updateRequestList: (updatedRequests) => print('Requests updated: $updatedRequests'),
    updateCoHost: (newCoHost) => print('Co-host updated: $newCoHost'),
    updateCoHostResponsibility: (responsibilities) => print('Co-host responsibilities updated: $responsibilities'),
    updateFirstAll: (isFirstAll) => print('First all updated: $isFirstAll'),
    updateMembersReceived: (received) => print('Members received updated: $received'),
    updateDeferScreenReceived: (defer) => print('Defer screen received updated: $defer'),
    updateShareScreenStarted: (started) => print('Share screen started updated: $started'),
    updateHostFirstSwitch: (switched) => print('Host first switch updated: $switched'),
    updateConsumeSockets: (sockets) => print('Consume sockets updated: $sockets'),
    updateRoomRecvIPs: (ips) => print('Room receive IPs updated: $ips'),
    updateIsLoadingModalVisible: (visible) => print('Loading modal visibility updated: $visible'),
    updateTotalReqWait: (total) => print('Total request wait count updated: $total'),
    onScreenChanges: (params) async => print('Screen changes detected'),
    connectIps: (connectOptions) async => print('Connected to IPs with options: $connectOptions'),
    connectLocalIps: (connectOptions) async => print('Connected to local IPs with options: $connectOptions'),
    sleep: (ms) async => print('Sleeping for $ms milliseconds'),
    reorderStreams: (options) async => print('Reordered streams with options: $options'),
  ),
  consumeSockets: [ConsumeSocket(id: 'socket1')],
  apiUserName: 'user123',
  apiKey: 'key123',
  apiToken: 'token123',
);

await allMembers(options);

In this example:

  • The function processes members like Alice and Bob, filtering them, managing requests, and updating the list based on ban or suspend status.
  • It configures waiting room participants, manages co-host assignments, and handles IP connections with connectIps, updating relevant states in the UI.

Implementation

Future<void> allMembers(AllMembersOptions options) async {
  final params = options.parameters;

  params.updateParticipantsAll(
    options.members
        .map((member) => Participant(
            name: member.name,
            isBanned: member.isBanned,
            isSuspended: member.isSuspended,
            audioID: member.audioID,
            videoID: member.videoID))
        .toList(),
  );

  params.updateParticipants(
    options.members
        .where((participant) =>
            !participant.isBanned! && !participant.isSuspended!)
        .toList(),
  );

  if (params.dispActiveNames.isNotEmpty) {
    final missingNames = params.dispActiveNames
        .where((name) => !params.participants.any((p) => p.name == name))
        .toList();
    if (missingNames.isNotEmpty) {
      final optionsReorder = ReorderStreamsOptions(
        screenChanged: true,
        parameters: params,
      );
      await params.reorderStreams(
        optionsReorder,
      );
    }
  }

  bool onLocal = false;
  if (params.roomRecvIPs.length == 1 && params.roomRecvIPs[0] == 'none') {
    onLocal = true;
  }

  if (!params.membersReceived && !onLocal) {
    if (params.roomRecvIPs.isEmpty) {
      Timer.periodic(const Duration(milliseconds: 10), (timer) async {
        if (params.roomRecvIPs.isNotEmpty) {
          if (params.roomRecvIPs.length == 1 &&
              params.roomRecvIPs[0] == 'none') {
            onLocal = true;
          }
          timer.cancel();
          if (!onLocal) {
            await _handleConnections(options, params);
          }
        }
      });
    } else {
      await _handleConnections(options, params);
    }
  }

  if (onLocal && !params.membersReceived) {
    final optionsLocal = ConnectLocalIpsOptions(
      socket: params.socket,
      parameters: params,
    );
    if (params.connectLocalIps != null) {
      await params.connectLocalIps!(
        optionsLocal,
      );
    }

    await params.sleep(SleepOptions(ms: 50));
    params.updateIsLoadingModalVisible(false);
  }

  final updatedRequests = options.requests
      .where((req) => params.participants.any((p) => p.id == req.id))
      .toList();
  params.updateRequestList(updatedRequests);
  params.updateTotalReqWait(
      updatedRequests.length + params.waitingRoomList.length);
  params.updateCoHost(options.coHost);
  params.updateCoHostResponsibility(options.coHostRes);

  if (!params.lockScreen && !params.firstAll) {
    final optionsChanges = OnScreenChangesOptions(
      parameters: params,
    );
    await params.onScreenChanges(
      optionsChanges,
    );
    if (params.meetingDisplayType != 'all') params.updateFirstAll(true);
  } else if (params.islevel == '2' && !params.hostFirstSwitch) {
    final optionsChanges = OnScreenChangesOptions(
      parameters: params,
    );
    await params.onScreenChanges(
      optionsChanges,
    );
    params.updateHostFirstSwitch(true);
  }
}