@stream-io/video-client 0.2.3 → 0.3.1

package/dist/src/Call.d.ts

@@ -5,7 +5,10 @@ import { AcceptCallResponse, BlockUserResponse, EndCallResponse, GetCallResponse
 import { CallConstructor, CallLeaveOptions, DebounceType, JoinCallData, PublishOptions, SubscriptionChanges } from './types';
 import { ViewportTracker } from './helpers/ViewportTracker';
 import { PermissionsContext } from './permissions';
-import { CallEventHandler, CallEventTypes, Logger } from './coordinator/connection/types';
+import { StreamClient } from './coordinator/connection/client';
+import { CallEventHandler, CallEventTypes, EventTypes, Logger } from './coordinator/connection/types';
+import { CameraManager } from './devices/CameraManager';
+import { MicrophoneManager } from './devices/MicrophoneManager';
 /**
  * An object representation of a `Call`.
  */
@@ -35,6 +38,14 @@ export declare class Call {
      * updates from the backend.
      */
     watching: boolean;
+    /**
+     * Device manager for the camera
+     */
+    readonly camera: CameraManager;
+    /**
+     * Device manager for the microhpone
+     */
+    readonly microphone: MicrophoneManager;
     /**
      * Flag telling whether this call is a "ringing" call.
      */
@@ -55,7 +66,7 @@ export declare class Call {
     private statsReporter?;
     private dropTimeout;
     private readonly clientStore;
-    private readonly streamClient;
+    readonly streamClient: StreamClient;
     private sfuClient?;
     private reconnectAttempts;
     private maxReconnectAttempts;
@@ -74,7 +85,7 @@ export declare class Call {
      * Use the [`StreamVideoClient.call`](./StreamVideoClient.md/#call)
      * method to construct a `Call` instance.
      */
-    constructor({ type, id, streamClient, metadata, members, ownCapabilities, sortParticipantsBy, clientStore, ringing, watching, }: CallConstructor);
+    constructor({ type, id, streamClient, members, ownCapabilities, sortParticipantsBy, clientStore, ringing, watching, }: CallConstructor);
     private registerEffects;
     /**
      * You can subscribe to WebSocket events provided by the API. To remove a subscription, call the `off` method.
@@ -84,7 +95,7 @@ export declare class Call {
      * @returns a function which can be called to unsubscribe from the given event(s)
      */
     on(eventName: SfuEventKinds, fn: SfuEventListener): () => void;
-    on(eventName: CallEventTypes, fn: CallEventHandler): () => void;
+    on(eventName: EventTypes, fn: CallEventHandler): () => void;
     /**
      * Remove subscription for WebSocket events that were created by the `on` method.
      * @param eventName
@@ -97,10 +108,6 @@ export declare class Call {
      * Leave the call and stop the media streams that were published by the call.
      */
     leave: ({ reject }?: CallLeaveOptions) => Promise<void>;
-    /**
-     * A getter for the call metadata.
-     */
-    get data(): import("./gen/coordinator").CallResponse | undefined;
     /**
      * A flag indicating whether the call is "ringing" type of call.
      */
@@ -253,6 +260,8 @@ export declare class Call {
      *
      *
      * @param deviceId the selected device, pass `undefined` to clear the device selection
+     *
+     * @deprecated use call.microphone.select
      */
     setAudioDevice: (deviceId?: string) => void;
     /**
@@ -261,6 +270,8 @@ export declare class Call {
      * This method only stores the selection, if you want to start publishing a media stream call the [`publishVideoStream` method](#publishvideostream) that will set `videoDeviceId` as well.
      *
      * @param deviceId the selected device, pass `undefined` to clear the device selection
+     *
+     * @deprecated use call.camera.select
      */
     setVideoDevice: (deviceId?: string) => void;
     /**
@@ -448,7 +459,6 @@ export declare class Call {
     private scheduleAutoDrop;
     /**
      * Retrieves the list of recordings for the current call or call session.
-     * Updates the call state with the returned array of CallRecording objects.
      *
      * If `callSessionId` is provided, it will return the recordings for that call session.
      * Otherwise, all recordings for the current call will be returned.
@@ -464,4 +474,6 @@ export declare class Call {
     sendCustomEvent: (payload: {
         [key: string]: any;
     }) => Promise<SendEventResponse>;
+    private initCamera;
+    private initMic;
 }

package/dist/src/StreamVideoClient.d.ts

@@ -92,7 +92,9 @@ export declare class StreamVideoClient {
         next?: string | undefined;
         prev?: string | undefined;
     }>;
-    queryUsers: () => Promise<void>;
+    /**
+     * Returns a list of available data centers available for hosting calls.
+     */
     edges: () => Promise<GetEdgesResponse>;
     /**
      * addDevice - Adds a push device for a user.

package/dist/src/devices/CameraManager.d.ts

@@ -0,0 +1,31 @@
+import { Observable } from 'rxjs';
+import { Call } from '../Call';
+import { CameraDirection, CameraManagerState } from './CameraManagerState';
+import { InputMediaDeviceManager } from './InputMediaDeviceManager';
+export declare class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
+    constructor(call: Call);
+    /**
+     * Select the camera direaction
+     * @param direction
+     */
+    selectDirection(direction: Exclude<CameraDirection, undefined>): Promise<void>;
+    /**
+     * Flips the camera direction: if it's front it will change to back, if it's back, it will change to front.
+     *
+     * Note: if there is no available camera with the desired direction, this method will do nothing.
+     * @returns
+     */
+    flip(): Promise<void>;
+    protected getDevices(): Observable<MediaDeviceInfo[]>;
+    protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
+    protected publishStream(stream: MediaStream): Promise<void>;
+    protected stopPublishStream(): Promise<void>;
+    /**
+     * Disables the video tracks of the camera
+     */
+    pause(): void;
+    /**
+     * (Re)enables the video tracks of the camera
+     */
+    resume(): void;
+}

package/dist/src/devices/CameraManagerState.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+export type CameraDirection = 'front' | 'back' | undefined;
+export declare class CameraManagerState extends InputMediaDeviceManagerState {
+    private directionSubject;
+    /**
+     * Observable that emits the preferred camera direction
+     * front - means the camera facing the user
+     * back - means the camera facing the environment
+     */
+    direction$: Observable<CameraDirection>;
+    constructor();
+    /**
+     * The preferred camera direction
+     * front - means the camera facing the user
+     * back - means the camera facing the environment
+     */
+    get direction(): CameraDirection;
+    /**
+     * @internal
+     */
+    setDirection(direction: CameraDirection): void;
+    /**
+     * @internal
+     */
+    setMediaStream(stream: MediaStream | undefined): void;
+    protected getDeviceIdFromStream(stream: MediaStream): string | undefined;
+}

package/dist/src/devices/InputMediaDeviceManager.d.ts

@@ -0,0 +1,47 @@
+import { Observable } from 'rxjs';
+import { Call } from '../Call';
+import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+export declare abstract class InputMediaDeviceManager<T extends InputMediaDeviceManagerState> {
+    protected readonly call: Call;
+    readonly state: T;
+    constructor(call: Call, state: T);
+    /**
+     * Lists the available audio/video devices
+     *
+     * Note: It prompts the user for a permission to use devices (if not already granted)
+     *
+     * @returns an Observable that will be updated if a device is connected or disconnected
+     */
+    listDevices(): Observable<MediaDeviceInfo[]>;
+    /**
+     * Starts camera/microphone
+     */
+    enable(): Promise<void>;
+    /**
+     * Stops camera/microphone
+     * @returns
+     */
+    disable(): Promise<void>;
+    /**
+     * If current device statis is disabled, it will enable the device, else it will disable it.
+     * @returns
+     */
+    toggle(): Promise<void>;
+    /**
+     * Select device
+     *
+     * Note: this method is not supported in React Native
+     *
+     * @param deviceId
+     */
+    select(deviceId: string | undefined): Promise<void>;
+    protected applySettingsToStream(): Promise<void>;
+    abstract pause(): void;
+    abstract resume(): void;
+    protected abstract getDevices(): Observable<MediaDeviceInfo[]>;
+    protected abstract getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
+    protected abstract publishStream(stream: MediaStream): Promise<void>;
+    protected abstract stopPublishStream(): Promise<void>;
+    private stopStream;
+    private startStream;
+}

package/dist/src/devices/InputMediaDeviceManagerState.d.ts

@@ -0,0 +1,69 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { RxUtils } from '../store';
+export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
+export declare abstract class InputMediaDeviceManagerState {
+    protected statusSubject: BehaviorSubject<InputDeviceStatus>;
+    protected mediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
+    protected selectedDeviceSubject: BehaviorSubject<string | undefined>;
+    /**
+     * An Observable that emits the current media stream, or `undefined` if the device is currently disabled.
+     *
+     */
+    mediaStream$: Observable<MediaStream | undefined>;
+    /**
+     * An Observable that emits the currently selected device
+     */
+    selectedDevice$: Observable<string | undefined>;
+    /**
+     * An Observable that emits the device status
+     */
+    status$: Observable<InputDeviceStatus>;
+    constructor();
+    /**
+     * The device status
+     */
+    get status(): InputDeviceStatus;
+    /**
+     * The currently selected device
+     */
+    get selectedDevice(): string | undefined;
+    /**
+     * The current media stream, or `undefined` if the device is currently disabled.
+     */
+    get mediaStream(): MediaStream | undefined;
+    /**
+     * Gets the current value of an observable, or undefined if the observable has
+     * not emitted a value yet.
+     *
+     * @param observable$ the observable to get the value from.
+     */
+    getCurrentValue: <T>(observable$: Observable<T>) => T;
+    /**
+     * @internal
+     * @param status
+     */
+    setStatus(status: InputDeviceStatus): void;
+    /**
+     * @internal
+     * @param stream
+     */
+    setMediaStream(stream: MediaStream | undefined): void;
+    /**
+     * @internal
+     * @param stream
+     */
+    setDevice(deviceId: string | undefined): void;
+    /**
+     * Updates the value of the provided Subject.
+     * An `update` can either be a new value or a function which takes
+     * the current value and returns a new value.
+     *
+     * @internal
+     *
+     * @param subject the subject to update.
+     * @param update the update to apply to the subject.
+     * @return the updated value.
+     */
+    protected setCurrentValue: <T>(subject: import("rxjs").Subject<T>, update: RxUtils.Patch<T>) => T;
+    protected abstract getDeviceIdFromStream(stream: MediaStream): string | undefined;
+}

package/dist/src/devices/MicrophoneManager.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { Call } from '../Call';
+import { InputMediaDeviceManager } from './InputMediaDeviceManager';
+import { MicrophoneManagerState } from './MicrophoneManagerState';
+export declare class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+    constructor(call: Call);
+    protected getDevices(): Observable<MediaDeviceInfo[]>;
+    protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
+    protected publishStream(stream: MediaStream): Promise<void>;
+    protected stopPublishStream(): Promise<void>;
+    /**
+     * Disables the audio tracks of the microphone
+     */
+    pause(): void;
+    /**
+     * (Re)enables the audio tracks of the microphone
+     */
+    resume(): void;
+}

package/dist/src/devices/MicrophoneManagerState.d.ts

@@ -0,0 +1,4 @@
+import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+export declare class MicrophoneManagerState extends InputMediaDeviceManagerState {
+    protected getDeviceIdFromStream(stream: MediaStream): string | undefined;
+}

package/dist/src/devices/__tests__/mocks.d.ts

@@ -0,0 +1,13 @@
+import { CallingState } from '../../store';
+export declare const mockVideoDevices: MediaDeviceInfo[];
+export declare const mockAudioDevices: MediaDeviceInfo[];
+export declare const mockCall: () => {
+    state: {
+        callingState: CallingState;
+    };
+    publishVideoStream: import("@vitest/spy").Mock<any, any>;
+    publishAudioStream: import("@vitest/spy").Mock<any, any>;
+    stopPublish: import("@vitest/spy").Mock<any, any>;
+};
+export declare const mockAudioStream: () => MediaStream;
+export declare const mockVideoStream: () => MediaStream;

package/dist/src/devices/index.d.ts

@@ -1 +1,5 @@
 export * from './devices';
+export * from './InputMediaDeviceManager';
+export * from './InputMediaDeviceManagerState';
+export * from './CameraManager';
+export * from './MicrophoneManager';

package/dist/src/events/call-permissions.d.ts

@@ -1,10 +1,5 @@
-import { StreamVideoEvent } from '../coordinator/connection/types';
 import { CallState } from '../store';
 import { SfuEvent } from '../gen/video/sfu/event/events';
-/**
- * Event handler that watches for `call.permissions_updated` events
- */
-export declare const watchCallPermissionsUpdated: (state: CallState) => (event: StreamVideoEvent) => void;
 /**
  * Event handler that watches for `callGrantsUpdated` events.
  *

package/dist/src/events/call.d.ts

@@ -1,4 +1,3 @@
-import { CallState } from '../store';
 import { StreamVideoEvent } from '../coordinator/connection/types';
 import { Call } from '../Call';
 /**
@@ -15,8 +14,3 @@ export declare const watchCallRejected: (call: Call) => (event: StreamVideoEvent
  * Event handler that watches the delivery of `call.ended` Websocket event.
  */
 export declare const watchCallEnded: (call: Call) => (event: StreamVideoEvent) => Promise<void>;
-/**
- * An event handler which listens to `call.updated` events
- * and updates the given call state accordingly.
- */
-export declare const watchCallUpdated: (state: CallState) => (event: StreamVideoEvent) => void;

package/dist/src/events/index.d.ts

@@ -1,11 +1,5 @@
-export * from './backstage';
 export * from './call';
 export * from './call-permissions';
 export * from './internal';
-export * from './members';
 export * from './participant';
-export * from './reactions';
-export * from './recording';
 export * from './speaker';
-export * from './sessions';
-export * from './moderation';

package/dist/src/rtc/Dispatcher.d.ts

@@ -1,7 +1,7 @@
-import { CallEventTypes } from '../coordinator/connection/types';
+import { EventTypes } from '../coordinator/connection/types';
 import type { SfuEvent } from '../gen/video/sfu/event/events';
 export type SfuEventKinds = NonNullable<SfuEvent['eventPayload']['oneofKind']>;
-export declare const isSfuEvent: (eventName: SfuEventKinds | CallEventTypes) => eventName is SfuEventKinds;
+export declare const isSfuEvent: (eventName: SfuEventKinds | EventTypes) => eventName is SfuEventKinds;
 export type SfuEventListener = (event: SfuEvent) => void;
 export declare class Dispatcher {
     private subscribers;

package/dist/src/rtc/Publisher.d.ts

@@ -20,7 +20,6 @@ export type PublisherOpts = {
 export declare class Publisher {
     private pc;
     private readonly state;
-    private readonly dispatcher;
     private readonly transceiverRegistry;
     /**
      * An array maintaining the order how transceivers were added to the peer connection.