Call and Participant State

var clientState = streamVideo.state;
var callState = call.state;
var participants = call.state.value.callParticipants;

StreamBuilder<CallState>(
  stream: call.state.valueStream, // Subscribe to state changes
  builder: (context, snapshot) {
    final state = snapshot.data;
    if (state.isRecording) {
      return CallRecordingUI();
    } else {
      return RegularCallUI();
    }
  },
),

Stream<bool> isRecordingStream = call.partialState((state) => state.isRecording);

Stream<({bool isBackstage, DateTime? endedAt})> partialStateStream =
    call.partialState((state) => (isBackstage: state.isBackstage, endedAt: state.endedAt));

PartialCallStateBuilder(
  call: call,
  selector: (state) => state.isRecording,
  builder: (context, isRecording) =>
      isRecording ? CallRecordingUI() : RegularCallUI(),
);

// Get the local participant
var localParticipant = call.state.value.localParticipant;

// Get all participants except yourself
var otherParticipants = call.state.value.otherParticipants;

// Get participants who are currently speaking
var activeSpeakers = call.state.value.activeSpeakers;

// Get members who are being called but haven't answered
var ringingMembers = call.state.value.ringingMembers;

// Check if you created the call
var createdByMe = call.state.value.createdByMe;

// Example of using call status
PartialCallStateBuilder(
  call: call,
  selector: (state) => state.status,
  builder: (context, status) {
    if (status.isConnecting) {
      return ConnectingUI();
    } else if (status.isConnected) {
      return ConnectedCallUI();
    } else if (status.isReconnecting) {
      return ReconnectingUI(attempt: status.attempt);
    }
    return DefaultCallUI();
  },
);

// Listen to call status changes and handle disconnection
PartialCallStateBuilder(
  call: call,
  selector: (state) => state.status,
  builder: (context, status) {
    if (status.isDisconnected) {
      final disconnectedStatus = status as CallStatusDisconnected;
      final reason = disconnectedStatus.reason;
      
      return DisconnectedCallUI(reason: reason);
    }
    
    // Handle other statuses...
    return RegularCallUI();
  },
);

// In StreamCallContainer
StreamCallContainer(
  call: call,
  onCallDisconnected: (CallDisconnectedProperties properties) {
    final reason = properties.reason;
    final call = properties.call;
    
    // Handle the disconnection
    _handleCallDisconnected(reason);
    
    // Navigate away or show appropriate UI
    Navigator.of(context).pushReplacementNamed('/home');
  },
);

// In LivestreamPlayer
LivestreamPlayer(
  call: call,
  onCallDisconnected: (CallDisconnectedProperties properties) {
    final reason = properties.reason;
    
    // Handle livestream disconnection
    if (reason is DisconnectReasonEnded) {
      _showStreamEndedDialog();
    } else {
      // Handle other disconnection reasons
    }
  },
);

// Complete example with pattern matching
void _handleCallDisconnected(DisconnectReason reason) {
  switch (reason) {
    case DisconnectReasonSfuError(error: final sfuError):
      if (sfuError.code == SfuErrorCode.callParticipantLimitReached) {
        // Handle participant limit reached
        _showDialog(
          title: 'Call Full',
          message: 'This call has reached its participant limit. Please try again later.',
          actions: [
            TextButton(
              onPressed: () => Navigator.of(context).pop(),
              child: Text('OK'),
            ),
          ],
        );
      } 
      break;
    // Handle other disconnect reasons...
  }
}

var participants = call.state.value.callParticipants;
var localParticipant = call.state.value.localParticipant;

for (final participant in call.state.value.callParticipants) {
  if (participant.isDominantSpeaker) {
    setState(() => dominantSpeaker = participant);
  }
}

// Access specific tracks
var videoTrack = participant.videoTrack;
var audioTrack = participant.audioTrack;
var screenShareTrack = participant.screenShareTrack;

// Check if tracks are enabled
var isVideoEnabled = participant.isVideoEnabled;
var isAudioEnabled = participant.isAudioEnabled;
var isScreenShareEnabled = participant.isScreenShareEnabled;

// Listen to changes in speaking participants
PartialCallStateBuilder(
  call: call,
  selector: (state) => state.activeSpeakers,
  builder: (context, activeSpeakers) {
    return Column(
      children: activeSpeakers.map((participant) => 
        Text('${participant.name} is speaking')
      ).toList(),
    );
  },
);

// Listen to dominant speaker changes
PartialCallStateBuilder(
  call: call,
  selector: (state) => state.callParticipants
      .where((p) => p.isDominantSpeaker)
      .firstOrNull,
  builder: (context, dominantSpeaker) {
    return dominantSpeaker != null
        ? Text('Dominant speaker: ${dominantSpeaker.name}')
        : const SizedBox.shrink();
  },
);

// Client state is available in the client object
var clientState = StreamVideo.instance.state;