@stream-io/video-react-sdk 0.3.46 → 0.4.0

package/src/core/hooks/useVideoPublisher.ts

@@ -1,177 +0,0 @@
-import { useCallback, useEffect, useRef } from 'react';
-import { map } from 'rxjs/operators';
-import {
-  CallingState,
-  getVideoStream,
-  OwnCapability,
-  SfuModels,
-  VideoSettingsCameraFacingEnum,
-  watchForAddedDefaultVideoDevice,
-  watchForDisconnectedVideoDevice,
-} from '@stream-io/video-client';
-import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
-import { useDebugPreferredVideoCodec } from '../../components/Debug/useIsDebugMode';
-import { useHasBrowserPermissions } from './useDevices';
-
-/**
- * @internal
- */
-export type VideoPublisherInit = {
-  initialVideoMuted?: boolean;
-  videoDeviceId?: string;
-};
-
-/**
- * @internal
- * @category Device Management
- */
-export const useVideoPublisher = ({
-  initialVideoMuted,
-  videoDeviceId,
-}: VideoPublisherInit) => {
-  const call = useCall();
-  const {
-    useCallState,
-    useCallCallingState,
-    useLocalParticipant,
-    useCallSettings,
-  } = useCallStateHooks();
-  const callState = useCallState();
-  const callingState = useCallCallingState();
-  const participant = useLocalParticipant();
-  const hasBrowserPermissionVideoInput = useHasBrowserPermissions(
-    'camera' as PermissionName,
-  );
-  const { localParticipant$ } = callState;
-
-  const preferredCodec = useDebugPreferredVideoCodec();
-  const isPublishingVideo = participant?.publishedTracks.includes(
-    SfuModels.TrackType.VIDEO,
-  );
-
-  const settings = useCallSettings();
-  const videoSettings = settings?.video;
-  const targetResolution = videoSettings?.target_resolution;
-  const publishVideoStream = useCallback(async () => {
-    if (!call) return;
-    if (!call.permissionsContext.hasPermission(OwnCapability.SEND_VIDEO)) {
-      throw new Error(`No permission to publish video`);
-    }
-    try {
-      const videoStream = await getVideoStream({
-        deviceId: videoDeviceId,
-        width: targetResolution?.width,
-        height: targetResolution?.height,
-        facingMode: toFacingMode(videoSettings?.camera_facing),
-      });
-      await call.publishVideoStream(videoStream, { preferredCodec });
-    } catch (e) {
-      console.log('Failed to publish video stream', e);
-    }
-  }, [
-    call,
-    preferredCodec,
-    targetResolution?.height,
-    targetResolution?.width,
-    videoDeviceId,
-    videoSettings?.camera_facing,
-  ]);
-
-  const lastVideoDeviceId = useRef(videoDeviceId);
-  useEffect(() => {
-    if (
-      callingState === CallingState.JOINED &&
-      videoDeviceId !== lastVideoDeviceId.current
-    ) {
-      lastVideoDeviceId.current = videoDeviceId;
-      publishVideoStream().catch((e) => {
-        console.error('Failed to publish video stream', e);
-      });
-    }
-  }, [publishVideoStream, videoDeviceId, callingState]);
-
-  const initialPublishRun = useRef(false);
-  useEffect(() => {
-    if (
-      callingState === CallingState.JOINED &&
-      !initialPublishRun.current &&
-      !initialVideoMuted
-    ) {
-      // automatic publishing should happen only when joining the call
-      // from the lobby, and the video is not muted
-      publishVideoStream().catch((e) => {
-        console.error('Failed to publish video stream', e);
-      });
-      initialPublishRun.current = true;
-    }
-  }, [callingState, initialVideoMuted, publishVideoStream]);
-
-  useEffect(() => {
-    if (!localParticipant$ || !hasBrowserPermissionVideoInput) return;
-    const subscription = watchForDisconnectedVideoDevice(
-      localParticipant$.pipe(map((p) => p?.videoDeviceId)),
-    ).subscribe(async () => {
-      if (!call) return;
-      call.setVideoDevice(undefined);
-      await call.stopPublish(SfuModels.TrackType.VIDEO);
-    });
-    return () => {
-      subscription.unsubscribe();
-    };
-  }, [hasBrowserPermissionVideoInput, localParticipant$, call]);
-
-  useEffect(() => {
-    if (!participant?.videoStream || !call || !isPublishingVideo) return;
-
-    const [track] = participant.videoStream.getVideoTracks();
-    const selectedVideoDeviceId = track.getSettings().deviceId;
-
-    const republishDefaultDevice = watchForAddedDefaultVideoDevice().subscribe(
-      async () => {
-        if (
-          !(
-            call &&
-            participant.videoStream &&
-            selectedVideoDeviceId === 'default'
-          )
-        )
-          return;
-        // We need to stop the original track first in order
-        // we can retrieve the new default device stream
-        track.stop();
-        const videoStream = await getVideoStream({
-          deviceId: 'default',
-        });
-        await call.publishVideoStream(videoStream);
-      },
-    );
-
-    const handleTrackEnded = async () => {
-      if (selectedVideoDeviceId === videoDeviceId) {
-        const videoStream = await getVideoStream({
-          deviceId: videoDeviceId,
-        });
-        await call.publishVideoStream(videoStream);
-      }
-    };
-
-    track.addEventListener('ended', handleTrackEnded);
-    return () => {
-      track.removeEventListener('ended', handleTrackEnded);
-      republishDefaultDevice.unsubscribe();
-    };
-  }, [videoDeviceId, call, participant?.videoStream, isPublishingVideo]);
-
-  return publishVideoStream;
-};
-
-const toFacingMode = (value: VideoSettingsCameraFacingEnum | undefined) => {
-  switch (value) {
-    case VideoSettingsCameraFacingEnum.FRONT:
-      return 'user';
-    case VideoSettingsCameraFacingEnum.BACK:
-      return 'environment';
-    default:
-      return undefined;
-  }
-};

package/src/hooks/useToggleAudioMuteState.ts

@@ -1,34 +0,0 @@
-import { useCallback, useRef } from 'react';
-import { useCallStateHooks } from '@stream-io/video-react-bindings';
-import { OwnCapability, SfuModels } from '@stream-io/video-client';
-
-import { useMediaDevices } from '../core';
-import { useRequestPermission } from './useRequestPermission';
-
-export const useToggleAudioMuteState = () => {
-  const { publishAudioStream, stopPublishingAudio } = useMediaDevices();
-  const { useLocalParticipant } = useCallStateHooks();
-  const localParticipant = useLocalParticipant();
-
-  const { isAwaitingPermission, requestPermission } = useRequestPermission(
-    OwnCapability.SEND_AUDIO,
-  );
-
-  // to keep the toggle function as stable as possible
-  const isAudioMutedReference = useRef(false);
-
-  isAudioMutedReference.current = !localParticipant?.publishedTracks.includes(
-    SfuModels.TrackType.AUDIO,
-  );
-
-  const toggleAudioMuteState = useCallback(async () => {
-    if (isAudioMutedReference.current) {
-      const canPublish = await requestPermission();
-      if (canPublish) return publishAudioStream();
-    }
-
-    if (!isAudioMutedReference.current) await stopPublishingAudio();
-  }, [publishAudioStream, requestPermission, stopPublishingAudio]);
-
-  return { toggleAudioMuteState, isAwaitingPermission };
-};

package/src/hooks/useToggleScreenShare.ts

@@ -1,43 +0,0 @@
-import { useCallback, useRef } from 'react';
-import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
-import {
-  getScreenShareStream,
-  OwnCapability,
-  SfuModels,
-} from '@stream-io/video-client';
-import { useRequestPermission } from './useRequestPermission';
-
-export const useToggleScreenShare = () => {
-  const { useLocalParticipant } = useCallStateHooks();
-  const localParticipant = useLocalParticipant();
-  const call = useCall();
-  const isScreenSharingReference = useRef(false);
-  const { isAwaitingPermission, requestPermission } = useRequestPermission(
-    OwnCapability.SCREENSHARE,
-  );
-
-  const isScreenSharing = !!localParticipant?.publishedTracks.includes(
-    SfuModels.TrackType.SCREEN_SHARE,
-  );
-
-  isScreenSharingReference.current = isScreenSharing;
-
-  const toggleScreenShare = useCallback(async () => {
-    if (!isScreenSharingReference.current) {
-      const canPublish = await requestPermission();
-      if (!canPublish) return;
-
-      const stream = await getScreenShareStream().catch((e) => {
-        console.log(`Can't share screen: ${e}`);
-      });
-
-      if (stream) {
-        return call?.publishScreenShareStream(stream);
-      }
-    }
-
-    await call?.stopPublish(SfuModels.TrackType.SCREEN_SHARE);
-  }, [call, requestPermission]);
-
-  return { toggleScreenShare, isAwaitingPermission, isScreenSharing };
-};

package/src/hooks/useToggleVideoMuteState.ts

@@ -1,34 +0,0 @@
-import { useCallback, useRef } from 'react';
-import { useCallStateHooks } from '@stream-io/video-react-bindings';
-import { OwnCapability, SfuModels } from '@stream-io/video-client';
-
-import { useMediaDevices } from '../core';
-import { useRequestPermission } from './useRequestPermission';
-
-export const useToggleVideoMuteState = () => {
-  const { publishVideoStream, stopPublishingVideo } = useMediaDevices();
-  const { useLocalParticipant } = useCallStateHooks();
-  const localParticipant = useLocalParticipant();
-
-  const { isAwaitingPermission, requestPermission } = useRequestPermission(
-    OwnCapability.SEND_VIDEO,
-  );
-
-  // to keep the toggle function as stable as possible
-  const isVideoMutedReference = useRef(false);
-
-  isVideoMutedReference.current = !localParticipant?.publishedTracks.includes(
-    SfuModels.TrackType.VIDEO,
-  );
-
-  const toggleVideoMuteState = useCallback(async () => {
-    if (isVideoMutedReference.current) {
-      const canPublish = await requestPermission();
-      if (canPublish) return publishVideoStream();
-    }
-
-    if (!isVideoMutedReference.current) await stopPublishingVideo();
-  }, [publishVideoStream, requestPermission, stopPublishingVideo]);
-
-  return { toggleVideoMuteState, isAwaitingPermission };
-};