producerMediaPaused function

Future<void> producerMediaPaused(
  1. ProducerMediaPausedOptions options
)

Pauses the media for a producer based on specified parameters.

This function handles media pausing operations and UI updates based on the media type, participant properties, and meeting settings.

options - The ProducerMediaPausedOptions instance containing the producer's ID, media kind, name, and parameters.

Example:

final options = ProducerMediaPausedOptions(
  producerId: 'abc123',
  kind: 'audio',
  name: 'Participant1',
  parameters: ProducerMediaPausedParameters(
    activeSounds: [],
    meetingDisplayType: 'media',
    meetingVideoOptimized: false,
    participants: [Participant(name: 'Participant1', islevel: '2', muted: true, videoID: null)],
    oldSoundIds: ['Participant1'],
    shared: false,
    shareScreenStarted: false,
    updateMainWindow: false,
    hostLabel: 'Host',
    islevel: '1',
    updateActiveSounds: (sounds) => print("Active sounds updated: $sounds"),
    updateUpdateMainWindow: (update) => print("Main window updated: $update"),
    reorderStreams: (params) async => print("Reordered streams: $params"),
    prepopulateUserMedia: (params) async => print("Prepopulated user media: $params"),
    reUpdateInter: (params) async => print("Re-updated interface: $params"),
    getUpdatedAllParams: () => ProducerMediaPausedParameters(...),
  ),
);

await producerMediaPaused(options);

Implementation

Future<void> producerMediaPaused(ProducerMediaPausedOptions options) async {
  // Retrieve updated parameters if necessary
  final parameters = options.parameters.getUpdatedAllParams();

  final activeSounds = parameters.activeSounds;
  final meetingDisplayType = parameters.meetingDisplayType;
  final meetingVideoOptimized = parameters.meetingVideoOptimized;
  final participants = parameters.participants;
  final oldSoundIds = parameters.oldSoundIds;
  final shared = parameters.shared;
  final shareScreenStarted = parameters.shareScreenStarted;
  final hostLabel = parameters.hostLabel;
  final islevel = parameters.islevel;

  // Callback functions
  final updateActiveSounds = parameters.updateActiveSounds;
  final updateUpdateMainWindow = parameters.updateUpdateMainWindow;

  // mediasfu functions
  final reorderStreams = parameters.reorderStreams;
  final prepopulateUserMedia = parameters.prepopulateUserMedia;
  final reUpdateInter = parameters.reUpdateInter;

  // Iterate through participants and update UI based on media settings and participant state
  for (final participant in participants) {
    if (participant.muted!) {
      if (participant.islevel == '2' &&
          participant.videoID.isNotEmpty &&
          !shared &&
          !shareScreenStarted &&
          islevel != '2') {
        updateUpdateMainWindow(true);
        final optionsPrepopulate = PrepopulateUserMediaOptions(
          name: hostLabel,
          parameters: parameters,
        );
        await prepopulateUserMedia(optionsPrepopulate);
        updateUpdateMainWindow(false);
      }

      if (shareScreenStarted || shared) {
        if (activeSounds.contains(participant.name)) {
          activeSounds.remove(participant.name);
          updateActiveSounds(activeSounds);
        }

        final optionsReUpdate = ReUpdateInterOptions(
          name: participant.name,
          add: false,
          force: true,
          parameters: parameters,
        );
        await reUpdateInter(optionsReUpdate);
      }
    }
  }

  // Update UI based on display type and video optimization settings
  if (meetingDisplayType == 'media' ||
      (meetingDisplayType == 'video' && !meetingVideoOptimized)) {
    final participant = participants.firstWhere((p) => p.name == options.name,
        orElse: () => Participant(
            name: '', islevel: '', videoID: '', audioID: '', muted: false));
    final hasVideo = participant.videoID.isNotEmpty;

    if (!hasVideo && !(shareScreenStarted || shared)) {
      final optionsReorder = ReorderStreamsOptions(
        add: false,
        screenChanged: true,
        parameters: parameters,
      );
      await reorderStreams(
        optionsReorder,
      );
    }
  }

  // Handle audio-specific media pausing
  if (options.kind == 'audio') {
    final participant = participants.firstWhere(
      (p) => p.audioID == options.producerId || p.name == options.name,
      orElse: () => Participant(
          name: '', islevel: '', videoID: '', audioID: '', muted: false),
    );

    if (participant.name.isNotEmpty && oldSoundIds.contains(participant.name)) {
      final optionsReUpdate = ReUpdateInterOptions(
        name: participant.name,
        add: false,
        force: true,
        parameters: parameters,
      );
      await reUpdateInter(optionsReUpdate);
    }
  }
}