export function useMediaStreamMetrics()

in src/hooks/sdk/useMediaStreamMetrics.tsx [23:98]
66 lines of code
9 McCabe index (conditional complexity)

export function useMediaStreamMetrics() {
  const audioVideo = useAudioVideo();
  const [mediaStreamMetrics, setMediaStreamMetrics] =
    useState<MediaStreamMetrics>({
      audioPacketsSentFractionLossPercent: null,
      audioPacketsReceivedFractionLossPercent: null,
      availableOutgoingBandwidth: null,
      availableIncomingBandwidth: null,
      videoStreamMetrics: {},
    });

  useEffect(() => {
    if (!audioVideo) {
      return;
    }

    const observer = {
      metricsDidReceive(clientMetricReport: ClientMetricReport): void {
        const {
          audioPacketLossPercent,
          audioPacketsReceivedFractionLoss,
          availableSendBandwidth,
          availableReceiveBandwidth,
          availableOutgoingBitrate,
          availableIncomingBitrate,
        } = clientMetricReport.getObservableMetrics();
        let videoStreamMetrics = {};
        let availableOutgoingBandwidth = 0;
        let availableIncomingBandwidth = 0;
        let audioPacketsSentFractionLossPercent = 0;
        let audioPacketsReceivedFractionLossPercent = 0;

        if (isValidMetric(audioPacketLossPercent)) {
          audioPacketsSentFractionLossPercent = Math.trunc(
            audioPacketLossPercent
          );
        }

        if (isValidMetric(audioPacketsReceivedFractionLoss)) {
          audioPacketsReceivedFractionLossPercent = Math.trunc(
            audioPacketsReceivedFractionLoss
          );
        }

        if (clientMetricReport.getObservableVideoMetrics) {
          videoStreamMetrics = clientMetricReport.getObservableVideoMetrics();
        }

        if (isValidMetric(availableSendBandwidth)) {
          availableOutgoingBandwidth = availableSendBandwidth / 1000;
        } else if (isValidMetric(availableOutgoingBitrate)) {
          availableOutgoingBandwidth = availableOutgoingBitrate / 1000;
        }

        if (isValidMetric(availableReceiveBandwidth)) {
          availableIncomingBandwidth = availableReceiveBandwidth / 1000;
        } else if (isValidMetric(availableIncomingBitrate)) {
          availableIncomingBandwidth = availableIncomingBitrate / 1000;
        }
        setMediaStreamMetrics({
          audioPacketsSentFractionLossPercent,
          audioPacketsReceivedFractionLossPercent,
          availableOutgoingBandwidth,
          availableIncomingBandwidth,
          videoStreamMetrics,
        });
      },
    };

    audioVideo.addObserver(observer);

    return () => audioVideo.removeObserver(observer);
  }, [audioVideo]);

  return mediaStreamMetrics;
}