allMembersRest function

Future<void> allMembersRest(
  1. AllMembersRestOptions options
)

Main function to handle participant updates, settings, and server connections in the room.

This function processes participant lists, handles co-host responsibilities, filters requests, manages settings, and establishes server connections for active members in the room. It updates necessary UI states, such as screen share and connection settings, and processes actions based on current participants and meeting configurations.

Example Usage:

final parameters = AllMembersParameters(
  participantsAll: [],
  participants: [],
  dispActiveNames: ['Alice', 'Bob'],
  requestList: [Request(id: 'req1', name: 'Alice')],
  coHost: 'Alice',
  coHostResponsibility: [CoHostResponsibility(id: 'manage')],
  lockScreen: false,
  firstAll: false,
  membersReceived: false,
  roomRecvIPs: ['192.000.1.1'],
  deferScreenReceived: true,
  screenId: 'screen123',
  shareScreenStarted: false,
  meetingDisplayType: 'all',
  audioSetting: 'allow',
  videoSetting: 'allow',
  screenshareSetting: 'allow',
  chatSetting: 'allow',
  socket: io.io('https://your-socket-server.com', <String, dynamic>{
  updateParticipantsAll: (list) => print('Participants all updated: $list'),
  updateParticipants: (list) => print('Filtered participants updated: $list'),
  updateRequestList: (list) => print('Request list updated: $list'),
  updateCoHost: (newCoHost) => print('Co-host updated: $newCoHost'),
  updateCoHostResponsibility: (list) => print('Co-host responsibilities updated: $list'),
  updateFirstAll: (value) => print('First all updated: $value'),
  updateMembersReceived: (value) => print('Members received updated: $value'),
  updateDeferScreenReceived: (value) => print('Defer screen received updated: $value'),
  updateShareScreenStarted: (value) => print('Share screen started updated: $value'),
  updateAudioSetting: (setting) => print('Audio setting updated: $setting'),
  updateVideoSetting: (setting) => print('Video setting updated: $setting'),
  updateScreenshareSetting: (setting) => print('Screenshare setting updated: $setting'),
  updateChatSetting: (setting) => print('Chat setting updated: $setting'),
  updateConsumeSockets: (sockets) => print('Consume sockets updated: $sockets'),
  updateRoomRecvIPs: (ips) => print('Room receive IPs updated: $ips'),
  updateIsLoadingModalVisible: (visible) => print('Loading modal visibility updated: $visible'),
  onScreenChanges: (params) async => print('Screen changes detected'),
  connectIps: (connectOptions) async => print('Connected to IPs with options: $connectOptions'),
  connectLocalIps: (connectLocalOptions) async => print('Connected to local IPs with options: $connectLocalOptions'),
  sleep: (ms) async => print('Sleeping for $ms milliseconds'),
  reorderStreams: (options) async => print('Reordered streams with options: $options'),
);

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),
  ],
  settings: ['allow', 'allow', 'allow', 'allow'],
  coHost: 'Alice',
  coHostRes: [CoHostResponsibility(id: 'manage')],
  parameters: parameters,
  consumeSockets: [
    {'socket1': io.Socket()},
    {'socket2': io.Socket()},
  ],
  apiUserName: 'user123',
  apiKey: 'key123',
  apiToken: 'token123',
);

await allMembersRest(options: options);

In this example:

  • The function updates participant lists, filters requests, and sets up co-host responsibilities.
  • It handles connection settings by checking roomRecvIPs, updating consume sockets, and handling screen share configurations as participants are processed.

Implementation

Future<void> allMembersRest(
  AllMembersRestOptions options,
) async {
  final members = options.members;
  final settings = options.settings;
  final coHost = options.coHost;
  final coHostRes = options.coHostRes;
  final parameters = options.parameters;
  final consumeSockets = options.consumeSockets;
  final apiUserName = options.apiUserName;
  final apiKey = options.apiKey;
  final apiToken = options.apiToken;

  try {
    // Extract and initialize required variables
    var participantsAll = parameters.participantsAll;
    var participants = parameters.participants;
    final dispActiveNames = parameters.dispActiveNames;
    var requestList = parameters.requestList;
    final lockScreen = parameters.lockScreen;
    var firstAll = parameters.firstAll;
    var membersReceived = parameters.membersReceived;
    final roomRecvIPs = parameters.roomRecvIPs;
    final deferScreenReceived = parameters.deferScreenReceived;
    final screenId = parameters.screenId;
    final meetingDisplayType = parameters.meetingDisplayType;

    // Processing participants
    participantsAll =
        members.where((m) => !m.isBanned! && !m.isSuspended!).toList();
    parameters.updateParticipantsAll(participantsAll);

    participants =
        members.where((m) => !m.isBanned! && !m.isSuspended!).toList();
    parameters.updateParticipants(participants);

    // Handle dispActiveNames if not empty
    if (dispActiveNames.isNotEmpty) {
      final dispActiveNames_ = dispActiveNames
          .where((name) => !participants.any((p) => p.name == name))
          .toList();
      if (dispActiveNames_.isNotEmpty && membersReceived) {
        final optionsReorder = ReorderStreamsOptions(
          add: false,
          screenChanged: true,
          parameters: parameters,
        );
        await parameters.reorderStreams(
          optionsReorder,
        );
      }
    }

    bool onLocal = false;
    if (roomRecvIPs.length == 1 && roomRecvIPs[0] == 'none') {
      onLocal = true;
    }
    // Checking roomRecvIPs and connecting to the server if not yet received
    if (!onLocal) {
      if (!membersReceived) {
        if (roomRecvIPs.isEmpty) {
          Timer.periodic(const Duration(milliseconds: 10), (timer) async {
            if (roomRecvIPs.isNotEmpty) {
              if (roomRecvIPs.length == 1 && roomRecvIPs[0] == 'none') {
                onLocal = true;
              }
              timer.cancel();
              if (!onLocal) {
                await _handleServerConnection(
                  deferScreenReceived: deferScreenReceived,
                  screenId: screenId,
                  consumeSockets: consumeSockets,
                  roomRecvIPs: roomRecvIPs,
                  apiUserName: apiUserName,
                  apiKey: apiKey,
                  apiToken: apiToken,
                  parameters: parameters,
                  connectIps: parameters.connectIps,
                );
                parameters.updateIsLoadingModalVisible(false);
              }
            }
          });
        } else {
          await _handleServerConnection(
            deferScreenReceived: deferScreenReceived,
            screenId: screenId,
            consumeSockets: consumeSockets,
            roomRecvIPs: roomRecvIPs,
            apiUserName: apiUserName,
            apiKey: apiKey,
            apiToken: apiToken,
            parameters: parameters,
            connectIps: parameters.connectIps,
          );
          parameters.updateIsLoadingModalVisible(false);
        }
      } else if (screenId.isNotEmpty && deferScreenReceived) {
        parameters.updateShareScreenStarted(true);
      }
    }

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

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

    // Filtering requests based on current participants
    final filteredRequests = requestList
        .where((req) => participants.any((p) => p.id == req.id))
        .toList();
    parameters.updateRequestList(filteredRequests);

    // Update coHost and coHostResponsibility
    parameters.updateCoHost(coHost);
    parameters.updateCoHostResponsibility(coHostRes);

    // Screen changes if necessary
    if (!lockScreen && !firstAll) {
      final optionsChanges = OnScreenChangesOptions(
        parameters: parameters,
      );
      await parameters.onScreenChanges(
        optionsChanges,
      );
      if (meetingDisplayType != 'all') {
        parameters.updateFirstAll(true);
      }
    }

    // Updating settings if members received
    bool newMembersReceived = parameters.getUpdatedAllParams().membersReceived;
    if (newMembersReceived) {
      parameters.updateAudioSetting(settings.settings[0]);
      parameters.updateVideoSetting(settings.settings[1]);
      parameters.updateScreenshareSetting(settings.settings[2]);
      parameters.updateChatSetting(settings.settings[3]);
    }
  } catch (error, s) {
    if (kDebugMode) {
      print('Errors in allMembersRest: $error $s');
    }
    rethrow;
  }
}