@stream-io/video-react-sdk 0.0.1-alpha.100

package/src/components/CallControls/ToggleAudioButton.tsx

@@ -0,0 +1,123 @@
+import { useCallback, useEffect, useState } from 'react';
+import { OwnCapability, SfuModels } from '@stream-io/video-client';
+import {
+  Restricted,
+  useCall,
+  useHasPermissions,
+  useI18n,
+  useLocalParticipant,
+} from '@stream-io/video-react-bindings';
+
+import { useMediaDevices } from '../../core';
+import { DeviceSelectorAudioInput } from '../DeviceSettings';
+import { CompositeButton, IconButton } from '../Button';
+import { PermissionNotification } from '../Notification';
+
+export type ToggleAudioPreviewButtonProps = { caption?: string };
+
+export const ToggleAudioPreviewButton = ({
+  caption,
+}: ToggleAudioPreviewButtonProps) => {
+  const { initialAudioEnabled, toggleInitialAudioMuteState } =
+    useMediaDevices();
+  const { t } = useI18n();
+
+  return (
+    <CompositeButton
+      Menu={DeviceSelectorAudioInput}
+      active={!initialAudioEnabled}
+      caption={caption || t('Mic')}
+    >
+      <IconButton
+        icon={initialAudioEnabled ? 'mic' : 'mic-off'}
+        onClick={toggleInitialAudioMuteState}
+      />
+    </CompositeButton>
+  );
+};
+
+export type ToggleAudioPublishingButtonProps = {
+  caption?: string;
+};
+
+export const ToggleAudioPublishingButton = (
+  props: ToggleAudioPublishingButtonProps,
+) => {
+  const { publishAudioStream, stopPublishingAudio, setInitialAudioEnabled } =
+    useMediaDevices();
+  const localParticipant = useLocalParticipant();
+  const { t } = useI18n();
+
+  const { caption = t('Mic') } = props;
+
+  const isAudioMute = !localParticipant?.publishedTracks.includes(
+    SfuModels.TrackType.AUDIO,
+  );
+
+  const call = useCall();
+  const hasPermission = useHasPermissions(OwnCapability.SEND_AUDIO);
+  const [isAwaitingApproval, setIsAwaitingApproval] = useState(false);
+  useEffect(() => {
+    if (hasPermission) {
+      setIsAwaitingApproval(false);
+    }
+  }, [hasPermission]);
+
+  const handleClick = useCallback(async () => {
+    if (
+      !hasPermission &&
+      call &&
+      call.permissionsContext.canRequest(OwnCapability.SEND_AUDIO)
+    ) {
+      setIsAwaitingApproval(true);
+      await call
+        .requestPermissions({
+          permissions: [OwnCapability.SEND_AUDIO],
+        })
+        .catch((reason) => {
+          console.log('RequestPermissions failed', reason);
+        });
+      return;
+    }
+    if (isAudioMute) {
+      if (hasPermission) {
+        setInitialAudioEnabled(true);
+        await publishAudioStream();
+      } else {
+        console.log('Cannot publish audio stream. Insufficient permissions.');
+      }
+    } else {
+      stopPublishingAudio();
+    }
+  }, [
+    call,
+    hasPermission,
+    isAudioMute,
+    publishAudioStream,
+    setInitialAudioEnabled,
+    stopPublishingAudio,
+  ]);
+
+  return (
+    <Restricted requiredGrants={[OwnCapability.SEND_AUDIO]}>
+      <PermissionNotification
+        permission={OwnCapability.SEND_AUDIO}
+        isAwaitingApproval={isAwaitingApproval}
+        messageApproved="You can now speak."
+        messageAwaitingApproval="Awaiting for an approval to speak."
+        messageRevoked="You can no longer speak."
+      >
+        <CompositeButton
+          Menu={DeviceSelectorAudioInput}
+          active={isAudioMute}
+          caption={caption}
+        >
+          <IconButton
+            icon={isAudioMute ? 'mic-off' : 'mic'}
+            onClick={handleClick}
+          />
+        </CompositeButton>
+      </PermissionNotification>
+    </Restricted>
+  );
+};

package/src/components/CallControls/ToggleAudioOutputButton.tsx

@@ -0,0 +1,21 @@
+import { CompositeButton, IconButton } from '../Button';
+import { DeviceSelectorAudioOutput } from '../DeviceSettings';
+import { useI18n } from '@stream-io/video-react-bindings';
+
+export type ToggleAudioOutputButtonProps = { caption?: string };
+
+export const ToggleAudioOutputButton = ({
+  caption,
+}: ToggleAudioOutputButtonProps) => {
+  const { t } = useI18n();
+
+  return (
+    <CompositeButton
+      Menu={DeviceSelectorAudioOutput}
+      active
+      caption={caption || t('Speakers')}
+    >
+      <IconButton icon="speaker" />
+    </CompositeButton>
+  );
+};

package/src/components/CallControls/ToggleVideoButton.tsx

@@ -0,0 +1,116 @@
+import { useCallback, useEffect, useState } from 'react';
+import {
+  Restricted,
+  useCall,
+  useHasPermissions,
+  useLocalParticipant,
+} from '@stream-io/video-react-bindings';
+
+import { OwnCapability, SfuModels } from '@stream-io/video-client';
+import { CompositeButton, IconButton } from '../Button/';
+import { DEVICE_STATE, useMediaDevices } from '../../core';
+import { DeviceSelectorVideo } from '../DeviceSettings';
+import { PermissionNotification } from '../Notification';
+
+export type ToggleVideoPreviewButtonProps = { caption?: string };
+
+export const ToggleVideoPreviewButton = ({
+  caption = 'Video',
+}: ToggleVideoPreviewButtonProps) => {
+  const { toggleInitialVideoMuteState, initialVideoState } = useMediaDevices();
+
+  return (
+    <CompositeButton
+      Menu={DeviceSelectorVideo}
+      active={!initialVideoState.enabled}
+      caption={caption}
+    >
+      <IconButton
+        icon={initialVideoState.enabled ? 'camera' : 'camera-off'}
+        onClick={toggleInitialVideoMuteState}
+      />
+    </CompositeButton>
+  );
+};
+
+type ToggleVideoPublishingButtonProps = {
+  caption?: string;
+};
+
+export const ToggleVideoPublishingButton = ({
+  caption = 'Video',
+}: ToggleVideoPublishingButtonProps) => {
+  const { publishVideoStream, stopPublishingVideo, setInitialVideoState } =
+    useMediaDevices();
+  const localParticipant = useLocalParticipant();
+  const isVideoMute = !localParticipant?.publishedTracks.includes(
+    SfuModels.TrackType.VIDEO,
+  );
+
+  const call = useCall();
+  const hasPermission = useHasPermissions(OwnCapability.SEND_VIDEO);
+  const [isAwaitingApproval, setIsAwaitingApproval] = useState(false);
+  useEffect(() => {
+    if (hasPermission) {
+      setIsAwaitingApproval(false);
+    }
+  }, [hasPermission]);
+
+  const handleClick = useCallback(async () => {
+    if (
+      !hasPermission &&
+      call &&
+      call.permissionsContext.canRequest(OwnCapability.SEND_VIDEO)
+    ) {
+      setIsAwaitingApproval(true);
+      await call
+        .requestPermissions({
+          permissions: [OwnCapability.SEND_VIDEO],
+        })
+        .catch((reason) => {
+          console.log('RequestPermissions failed', reason);
+        });
+      return;
+    }
+    if (isVideoMute) {
+      if (hasPermission) {
+        setInitialVideoState(DEVICE_STATE.playing);
+        await publishVideoStream();
+      } else {
+        console.log('Cannot publish video. Insufficient permissions.');
+      }
+    } else {
+      stopPublishingVideo();
+    }
+  }, [
+    call,
+    hasPermission,
+    isVideoMute,
+    publishVideoStream,
+    setInitialVideoState,
+    stopPublishingVideo,
+  ]);
+
+  return (
+    <Restricted requiredGrants={[OwnCapability.SEND_VIDEO]}>
+      <PermissionNotification
+        permission={OwnCapability.SEND_VIDEO}
+        isAwaitingApproval={isAwaitingApproval}
+        messageApproved="You can now share your video."
+        messageAwaitingApproval="Awaiting for an approval to share your video."
+        messageRevoked="You can no longer share your video."
+      >
+        <CompositeButton
+          Menu={DeviceSelectorVideo}
+          active={isVideoMute}
+          caption={caption}
+        >
+          <IconButton
+            icon={isVideoMute ? 'camera-off' : 'camera'}
+            onClick={handleClick}
+          />
+        </CompositeButton>
+      </PermissionNotification>
+    </Restricted>
+  );
+};

package/src/components/CallControls/index.ts

@@ -0,0 +1,10 @@
+export * from './AcceptCallButton';
+export * from './CallControls';
+export * from './CallStatsButton';
+export * from './CancelCallButton';
+export * from './ReactionsButton';
+export * from './RecordCallButton';
+export * from './ScreenShareButton';
+export * from './ToggleAudioButton';
+export * from './ToggleAudioOutputButton';
+export * from './ToggleVideoButton';

package/src/components/CallParticipantsList/BlockedUserListing.tsx

@@ -0,0 +1,37 @@
+import { Restricted, useCall } from '@stream-io/video-react-bindings';
+import { OwnCapability } from '@stream-io/video-client';
+
+import { TextButton } from '../Button';
+
+export const BlockedUserListing = ({ data }: { data: string[] }) => {
+  if (!data.length) return null;
+
+  return (
+    <>
+      <div className="str-video__participant-listing">
+        {data.map((userId) => (
+          <BlockedUserListingItem key={userId} userId={userId} />
+        ))}
+      </div>
+    </>
+  );
+};
+
+const BlockedUserListingItem = ({ userId }: { userId: string }) => {
+  const call = useCall();
+
+  const unblockUserClickHandler = () => {
+    if (userId) call?.unblockUser(userId);
+  };
+
+  return (
+    <div className="str-video__participant-listing-item">
+      <div className="str-video__participant-listing-item__display-name">
+        {userId}
+      </div>
+      <Restricted requiredGrants={[OwnCapability.BLOCK_USERS]}>
+        <TextButton onClick={unblockUserClickHandler}>Unblock</TextButton>
+      </Restricted>
+    </div>
+  );
+};

package/src/components/CallParticipantsList/CallParticipantListHeader.tsx

@@ -0,0 +1,29 @@
+import { useParticipants } from '@stream-io/video-react-bindings';
+
+export type CallParticipantListHeaderProps = {
+  /** Click event listener function to be invoked in order to dismiss / hide the CallParticipantsList from the UI */
+  onClose: () => void;
+};
+
+export const CallParticipantListHeader = ({
+  onClose,
+}: CallParticipantListHeaderProps) => {
+  const participants = useParticipants();
+
+  return (
+    <div className="str-video__participant-list-header">
+      <div className="str-video__participant-list-header__title">
+        Participants{' '}
+        <span className="str-video__participant-list-header__title-count">
+          ({participants.length})
+        </span>
+      </div>
+      <button
+        onClick={onClose}
+        className="str-video__participant-list-header__close-button"
+      >
+        <span className="str-video__participant-list-header__close-button--icon" />
+      </button>
+    </div>
+  );
+};

package/src/components/CallParticipantsList/CallParticipantListing.tsx

@@ -0,0 +1,22 @@
+import { ComponentType } from 'react';
+import { StreamVideoParticipant } from '@stream-io/video-client';
+import { CallParticipantListingItem } from './CallParticipantListingItem';
+
+export type CallParticipantListingProps = {
+  /** Array of participant objects to be rendered */
+  data: StreamVideoParticipant[];
+  Header?: ComponentType;
+};
+
+export const CallParticipantListing = ({
+  data,
+}: CallParticipantListingProps) => (
+  <div className="str-video__participant-listing">
+    {data.map((participant) => (
+      <CallParticipantListingItem
+        key={participant.sessionId}
+        participant={participant}
+      />
+    ))}
+  </div>
+);

package/src/components/CallParticipantsList/CallParticipantListingItem.tsx

@@ -0,0 +1,273 @@
+import clsx from 'clsx';
+import { ComponentProps, ComponentType, forwardRef, useState } from 'react';
+import {
+  Restricted,
+  useCall,
+  useConnectedUser,
+} from '@stream-io/video-react-bindings';
+import {
+  OwnCapability,
+  SfuModels,
+  StreamVideoParticipant,
+} from '@stream-io/video-client';
+import { IconButton } from '../Button';
+import {
+  GenericMenu,
+  GenericMenuButtonItem,
+  MenuToggle,
+  ToggleMenuButtonProps,
+} from '../Menu';
+import { WithTooltip } from '../Tooltip';
+import { Icon } from '../Icon';
+
+type CallParticipantListingItemProps = {
+  /** Participant object be rendered */
+  participant: StreamVideoParticipant;
+  /** Custom component used to display participant's name */
+  DisplayName?: ComponentType<{ participant: StreamVideoParticipant }>;
+};
+export const CallParticipantListingItem = ({
+  participant,
+  DisplayName = DefaultDisplayName,
+}: CallParticipantListingItemProps) => {
+  const isAudioOn = participant.publishedTracks.includes(
+    SfuModels.TrackType.AUDIO,
+  );
+  const isVideoOn = participant.publishedTracks.includes(
+    SfuModels.TrackType.VIDEO,
+  );
+  const isPinned = !!participant.pinnedAt;
+
+  return (
+    <div className="str-video__participant-listing-item">
+      <DisplayName participant={participant} />
+      <div className="str-video__participant-listing-item__media-indicator-group">
+        <MediaIndicator
+          title={isAudioOn ? 'Microphone on' : 'Microphone off'}
+          className={clsx(
+            'str-video__participant-listing-item__icon',
+            `str-video__participant-listing-item__icon-${
+              isAudioOn ? 'mic' : 'mic-off'
+            }`,
+          )}
+        />
+        <MediaIndicator
+          title={isVideoOn ? 'Camera on' : 'Camera off'}
+          className={clsx(
+            'str-video__participant-listing-item__icon',
+            `str-video__participant-listing-item__icon-${
+              isVideoOn ? 'camera' : 'camera-off'
+            }`,
+          )}
+        />
+        {isPinned && (
+          <MediaIndicator
+            title={'Pinned'}
+            className={clsx(
+              'str-video__participant-listing-item__icon',
+              'str-video__participant-listing-item__icon-pinned',
+            )}
+          />
+        )}
+
+        <MenuToggle placement="bottom-end" ToggleButton={ToggleButton}>
+          <ParticipantActionsContextMenu participant={participant} />
+        </MenuToggle>
+      </div>
+    </div>
+  );
+};
+
+const MediaIndicator = (props: ComponentProps<'div'>) => (
+  <WithTooltip {...props} />
+);
+
+type DisplayNameProps = {
+  /** Participant object that provides the data from which display name can be generated */
+  participant: StreamVideoParticipant;
+};
+// todo: implement display device flag
+const DefaultDisplayName = ({ participant }: DisplayNameProps) => {
+  const connectedUser = useConnectedUser();
+
+  const meFlag = participant.userId === connectedUser?.id ? 'Me' : '';
+  const nameOrId = participant.name || participant.userId || 'Unknown';
+  let displayName;
+  if (!participant.name) {
+    displayName = meFlag || nameOrId || 'Unknown';
+  } else if (meFlag) {
+    displayName = `${nameOrId} (${meFlag})`;
+  } else {
+    displayName = nameOrId;
+  }
+
+  return (
+    <WithTooltip
+      className="str-video__participant-listing-item__display-name"
+      title={displayName}
+    >
+      {displayName}
+    </WithTooltip>
+  );
+};
+
+const ToggleButton = forwardRef<HTMLButtonElement, ToggleMenuButtonProps>(
+  (props, ref) => {
+    return <IconButton enabled={props.menuShown} icon="ellipsis" ref={ref} />;
+  },
+);
+
+export const ParticipantActionsContextMenu = ({
+  participant,
+  participantViewElement,
+}: {
+  participant: StreamVideoParticipant;
+  participantViewElement?: HTMLDivElement | null;
+}) => {
+  const [fullscreenModeOn, setFullscreenModeOn] = useState(
+    !!document.fullscreenElement,
+  );
+  const activeCall = useCall();
+
+  const blockUser = () => {
+    activeCall?.blockUser(participant.userId);
+  };
+
+  // FIXME: soft kicking does not work this way
+  // also needs to be session-based
+  // const kickUserClickHandler = () => {
+  //   getCall()?.updateCallMembers({
+  //     remove_members: [participant.userId],
+  //     disconnectRemovedMembers: true,
+  //   });
+  // };
+
+  const muteAudio = () => {
+    activeCall?.muteUser(participant.userId, 'audio');
+  };
+  const muteVideo = () => {
+    activeCall?.muteUser(participant.userId, 'video');
+  };
+  const muteScreenShare = () => {
+    activeCall?.muteUser(participant.userId, 'screenshare');
+  };
+
+  const grantPermission = (permission: string) => () => {
+    activeCall?.updateUserPermissions({
+      user_id: participant.userId,
+      grant_permissions: [permission],
+    });
+  };
+
+  const revokePermission = (permission: string) => () => {
+    activeCall?.updateUserPermissions({
+      user_id: participant.userId,
+      revoke_permissions: [permission],
+    });
+  };
+
+  const toggleParticipantPinnedAt = () => {
+    activeCall?.setParticipantPinnedAt(
+      participant.sessionId,
+      participant.pinnedAt ? undefined : Date.now(),
+    );
+  };
+
+  const toggleFullscreenMode = () => {
+    if (!fullscreenModeOn)
+      return participantViewElement
+        ?.requestFullscreen()
+        .then(() => setFullscreenModeOn(true))
+        .catch(console.error);
+
+    document
+      .exitFullscreen()
+      .catch(console.error)
+      .finally(() => setFullscreenModeOn(false));
+  };
+
+  return (
+    <GenericMenu>
+      <GenericMenuButtonItem onClick={toggleParticipantPinnedAt}>
+        <Icon icon="pin" />
+        {participant.pinnedAt ? 'Unpin' : 'Pin'}
+      </GenericMenuButtonItem>
+      <Restricted requiredGrants={[OwnCapability.BLOCK_USERS]}>
+        <GenericMenuButtonItem onClick={blockUser}>
+          <Icon icon="not-allowed" />
+          Block
+        </GenericMenuButtonItem>
+      </Restricted>
+      {/* <GenericMenuButtonItem disabled onClick={kickUserClickHandler}>
+        Kick
+      </GenericMenuButtonItem> */}
+      <Restricted requiredGrants={[OwnCapability.MUTE_USERS]}>
+        <GenericMenuButtonItem
+          disabled={
+            !participant.publishedTracks.includes(SfuModels.TrackType.VIDEO)
+          }
+          onClick={muteVideo}
+        >
+          <Icon icon="camera-off-outline" />
+          Turn off video
+        </GenericMenuButtonItem>
+        <GenericMenuButtonItem
+          disabled={
+            !participant.publishedTracks.includes(
+              SfuModels.TrackType.SCREEN_SHARE,
+            )
+          }
+          onClick={muteScreenShare}
+        >
+          <Icon icon="screen-share-off" />
+          Turn off screen share
+        </GenericMenuButtonItem>
+        <GenericMenuButtonItem
+          disabled={
+            !participant.publishedTracks.includes(SfuModels.TrackType.AUDIO)
+          }
+          onClick={muteAudio}
+        >
+          <Icon icon="no-audio" />
+          Mute audio
+        </GenericMenuButtonItem>
+      </Restricted>
+      <GenericMenuButtonItem onClick={toggleFullscreenMode}>
+        {fullscreenModeOn ? 'Leave' : 'Enter'} fullscreen
+      </GenericMenuButtonItem>
+      <Restricted requiredGrants={[OwnCapability.UPDATE_CALL_PERMISSIONS]}>
+        <GenericMenuButtonItem
+          onClick={grantPermission(OwnCapability.SEND_AUDIO)}
+        >
+          Allow audio
+        </GenericMenuButtonItem>
+        <GenericMenuButtonItem
+          onClick={grantPermission(OwnCapability.SEND_VIDEO)}
+        >
+          Allow video
+        </GenericMenuButtonItem>
+        <GenericMenuButtonItem
+          onClick={grantPermission(OwnCapability.SCREENSHARE)}
+        >
+          Allow screen sharing
+        </GenericMenuButtonItem>
+
+        <GenericMenuButtonItem
+          onClick={revokePermission(OwnCapability.SEND_AUDIO)}
+        >
+          Disable audio
+        </GenericMenuButtonItem>
+        <GenericMenuButtonItem
+          onClick={revokePermission(OwnCapability.SEND_VIDEO)}
+        >
+          Disable video
+        </GenericMenuButtonItem>
+        <GenericMenuButtonItem
+          onClick={revokePermission(OwnCapability.SCREENSHARE)}
+        >
+          Disable screen sharing
+        </GenericMenuButtonItem>
+      </Restricted>
+    </GenericMenu>
+  );
+};