@stream-io/video-client 0.0.1-alpha.7

package/src/Batcher.ts

@@ -0,0 +1,43 @@
+export class Batcher<BatchItemType> {
+  private batch: Array<BatchItemType>;
+  private timeoutId: NodeJS.Timeout | undefined;
+
+  constructor(
+    private readonly timeoutInterval: number,
+    private readonly requestFunction: (data: Array<BatchItemType>) => void,
+  ) {
+    this.batch = [];
+  }
+
+  private scheduleTimeout = () => {
+    this.timeoutId = setTimeout(() => {
+      try {
+        if (!this.batch.length) return;
+        this.requestFunction(this.batch);
+        this.clearBatch();
+      } catch (error) {
+        console.error(error);
+      }
+    }, this.timeoutInterval);
+  };
+
+  private clearTimeout = () => {
+    clearTimeout(this.timeoutId);
+    this.timeoutId = undefined;
+  };
+
+  public clearBatch = () => {
+    this.batch = [];
+    this.clearTimeout();
+  };
+
+  public addToBatch = (item: BatchItemType) => {
+    this.batch.push(item);
+    if (!this.timeoutId) this.scheduleTimeout();
+  };
+
+  public removeFromBatch = (item: BatchItemType) => {
+    const itemIndex = this.batch.indexOf(item);
+    if (itemIndex > -1) this.batch.splice(itemIndex, 1);
+  };
+}

package/src/CallDropScheduler.ts

@@ -0,0 +1,192 @@
+import { StreamVideoWriteableStateStore } from './store';
+import { CallConfig } from './config/types';
+import { Observable, pairwise, startWith, Subscription } from 'rxjs';
+import { CallMetadata } from './rtc/CallMetadata';
+
+type CallCID = string;
+type DropFunction = (callCid: CallCID) => Promise<void>;
+
+export class CallDropScheduler {
+  private autoCallDropSchedule: Record<CallCID, ReturnType<typeof setTimeout>>;
+  private storeSubscriptions: { [key in keyof CallConfig]?: Subscription } & {
+    cancelDropOnPendingCallRemoval?: Subscription;
+    cancelDropOnCallAccepted?: Subscription;
+  };
+  private pairwisePendingCalls$: Observable<CallMetadata[][]>;
+  private pairwiseIncomingCalls$: Observable<CallMetadata[][]>;
+  private pairwiseOutgoingCalls$: Observable<CallMetadata[][]>;
+  constructor(
+    private store: StreamVideoWriteableStateStore,
+    private callConfig: CallConfig,
+    private reject: DropFunction,
+    private cancel: DropFunction,
+  ) {
+    this.pairwisePendingCalls$ = store.pendingCallsSubject.pipe(
+      startWith([]),
+      pairwise(),
+    );
+    this.pairwiseIncomingCalls$ = store.incomingCalls$.pipe(
+      startWith([]),
+      pairwise(),
+    );
+    this.pairwiseOutgoingCalls$ = store.outgoingCalls$.pipe(
+      startWith([]),
+      pairwise(),
+    );
+
+    this.autoCallDropSchedule = {};
+    this.storeSubscriptions = {};
+
+    this.startAutoRejectWhenInCall();
+    this.scheduleRejectAfterTimeout();
+    this.scheduleCancelAfterTimeout();
+    this.startCancellingDrops();
+  }
+
+  private static getLatestCall = (
+    from: CallMetadata[],
+    compareTo: CallMetadata[],
+  ) => {
+    return from > compareTo ? from.slice(-1)[0] : undefined;
+  };
+  private startAutoRejectWhenInCall = () => {
+    if (!this.callConfig.autoRejectWhenInCall) return;
+
+    this.storeSubscriptions.autoRejectWhenInCall =
+      this.pairwiseIncomingCalls$.subscribe(
+        async ([prevCalls, currentCalls]) => {
+          const newIncomingCall = CallDropScheduler.getLatestCall(
+            currentCalls,
+            prevCalls,
+          );
+
+          if (!newIncomingCall) return;
+
+          const activeCall = this.store.getCurrentValue(
+            this.store.activeCallSubject,
+          );
+
+          if (activeCall && newIncomingCall?.call.cid) {
+            await this.reject(newIncomingCall.call.cid);
+          }
+        },
+      );
+  };
+
+  private scheduleRejectAfterTimeout = () => {
+    const { autoRejectTimeoutInMs } = this.callConfig;
+    if (typeof autoRejectTimeoutInMs !== 'number' || autoRejectTimeoutInMs < 0)
+      return;
+
+    this.storeSubscriptions.autoRejectTimeoutInMs =
+      this.pairwiseIncomingCalls$.subscribe(([prevCalls, currentCalls]) => {
+        const newIncomingCall = CallDropScheduler.getLatestCall(
+          currentCalls,
+          prevCalls,
+        );
+        if (!newIncomingCall?.call.cid) return;
+
+        const activeCall = this.store.getCurrentValue(
+          this.store.activeCallSubject,
+        );
+        const incomingCallRejectedImmediately =
+          activeCall && this.callConfig.autoRejectWhenInCall;
+        if (incomingCallRejectedImmediately) return;
+
+        this.scheduleReject(newIncomingCall.call.cid);
+      });
+  };
+
+  private scheduleCancelAfterTimeout = () => {
+    const { autoCancelTimeoutInMs } = this.callConfig;
+    if (typeof autoCancelTimeoutInMs !== 'number' || autoCancelTimeoutInMs < 0)
+      return;
+
+    this.storeSubscriptions.autoCancelTimeoutInMs =
+      this.pairwiseOutgoingCalls$.subscribe(([prevCalls, currentCalls]) => {
+        const newOutgoingCall = CallDropScheduler.getLatestCall(
+          currentCalls,
+          prevCalls,
+        );
+
+        if (!newOutgoingCall?.call.cid) return;
+        this.scheduleCancel(newOutgoingCall.call.cid);
+      });
+  };
+
+  private startCancellingDrops = () => {
+    this.storeSubscriptions.cancelDropOnPendingCallRemoval =
+      this.pairwisePendingCalls$.subscribe(([prevCalls, currentCalls]) => {
+        const removedCall = CallDropScheduler.getLatestCall(
+          prevCalls,
+          currentCalls,
+        );
+
+        if (removedCall?.call.cid) {
+          this.cancelDrop(removedCall?.call.cid);
+        }
+      });
+
+    this.storeSubscriptions.cancelDropOnCallAccepted =
+      this.store.acceptedCallSubject.subscribe((acceptedCall) => {
+        if (acceptedCall?.call_cid) {
+          this.cancelDrop(acceptedCall.call_cid);
+        }
+      });
+  };
+
+  /**
+   * Schedules automatic call cancellation.
+   * The cancellation is intended for the scenarios, when the call has been rejected
+   * or not accepted by all the call members.
+   * @param {string} callCid
+   */
+  private scheduleCancel = (callCid: string) => {
+    const timeout = this.callConfig.autoCancelTimeoutInMs;
+    if (!timeout) return;
+    this.autoCallDropSchedule[callCid] = setTimeout(() => {
+      console.log('Automatic call cancellation after timeout', timeout);
+      this.cancel(callCid);
+    }, timeout);
+  };
+
+  /**
+   * Schedules automatic call rejection.
+   * @param {string} callCid
+   */
+  private scheduleReject = (callCid: string) => {
+    const timeout = this.callConfig.autoRejectTimeoutInMs;
+    if (!timeout) return;
+    this.autoCallDropSchedule[callCid] = setTimeout(() => {
+      console.log('Automatic call rejection after timeout', timeout);
+      this.reject(callCid);
+    }, timeout);
+  };
+
+  /**
+   * Cancels the automatic call drop (rejection of an incoming call / cancellation of an outgoing call).
+   * Indented for the scenario, when:
+   * - an incoming call has been cancelled
+   * - an outgoing call has been accepted by at least one member
+   * - an outgoing call has been rejected / left by all the members resp. participants
+   * - a call has been cancelled / rejected / accepted manually before the cancellation timeout expires.
+   */
+  private cancelDrop = (callCid: string) => {
+    const { [callCid]: timeoutRef, ...rest } = this.autoCallDropSchedule;
+    if (timeoutRef !== undefined) {
+      console.log(`Cancelling automatic call drop, [callCID: ${callCid}]`);
+      clearTimeout(timeoutRef);
+      this.autoCallDropSchedule = rest;
+    }
+  };
+
+  cleanUp = () => {
+    Object.values(this.autoCallDropSchedule).forEach((timeoutRef) =>
+      clearTimeout(timeoutRef),
+    );
+    this.autoCallDropSchedule = {};
+    Object.values(this.storeSubscriptions).forEach((subscription) =>
+      subscription.unsubscribe(),
+    );
+  };
+}

package/src/StreamSfuClient.ts

@@ -0,0 +1,185 @@
+import { SignalServerClient } from './gen/video/sfu/signal_rpc/signal.client';
+import { createSignalClient, withHeaders } from './rpc';
+import { createWebSocketSignalChannel } from './rtc/signal';
+import { JoinRequest, SfuRequest } from './gen/video/sfu/event/events';
+import { Dispatcher } from './rtc/Dispatcher';
+import { v4 as uuidv4 } from 'uuid';
+import { IceTrickleBuffer } from './rtc/IceTrickleBuffer';
+import {
+  SendAnswerRequest,
+  SetPublisherRequest,
+  TrackSubscriptionDetails,
+  UpdateMuteStatesRequest,
+} from './gen/video/sfu/signal_rpc/signal';
+import { ICETrickle, TrackType } from './gen/video/sfu/models/models';
+
+const hostnameFromUrl = (url: string) => {
+  try {
+    return new URL(url).hostname;
+  } catch (e) {
+    console.warn(`Invalid URL. Can't extract hostname from it.`, e);
+    return url;
+  }
+};
+
+const toURL = (url: string) => {
+  try {
+    return new URL(url);
+  } catch (e) {
+    return null;
+  }
+};
+
+export class StreamSfuClient {
+  readonly dispatcher = new Dispatcher();
+  readonly iceTrickleBuffer = new IceTrickleBuffer();
+  // we generate uuid session id client side
+  readonly sessionId: string;
+  private readonly rpc: SignalServerClient;
+  // Current JWT token
+  private readonly token: string;
+  signalReady: Promise<WebSocket>;
+  private keepAliveInterval?: NodeJS.Timeout;
+
+  constructor(url: string, token: string) {
+    this.sessionId = uuidv4();
+    this.token = token;
+    this.rpc = createSignalClient({
+      baseUrl: url,
+      interceptors: [
+        withHeaders({
+          Authorization: `Bearer ${token}`,
+        }),
+      ],
+    });
+
+    // FIXME: OL: this should come from the coordinator API
+    const sfuHost = hostnameFromUrl(url);
+    let wsEndpoint = `ws://${sfuHost}:3031/ws`;
+    if (!['localhost', '127.0.0.1'].includes(sfuHost)) {
+      const sfuUrl = toURL(url);
+      if (sfuUrl) {
+        sfuUrl.protocol = 'wss:';
+        sfuUrl.pathname = '/ws';
+        wsEndpoint = sfuUrl.toString();
+      }
+    }
+
+    // Special handling for the ICETrickle kind of events.
+    // These events might be triggered by the SFU before the initial RTC
+    // connection is established. In that case, those events (ICE candidates)
+    // need to be buffered and later added to the appropriate PeerConnection
+    // once the remoteDescription is known and set.
+    this.dispatcher.on('iceTrickle', (e) => {
+      if (e.eventPayload.oneofKind !== 'iceTrickle') return;
+      const { iceTrickle } = e.eventPayload;
+      this.iceTrickleBuffer.push(iceTrickle);
+    });
+
+    this.signalReady = createWebSocketSignalChannel({
+      endpoint: wsEndpoint,
+      onMessage: (message) => {
+        this.dispatcher.dispatch(message);
+      },
+    });
+  }
+
+  close = () => {
+    this.signalReady.then((ws) => {
+      this.signalReady = Promise.reject('Connection closed');
+      // TODO OL: re-connect flow
+      ws.close(1000, 'Requested signal connection close');
+
+      this.dispatcher.offAll();
+      clearInterval(this.keepAliveInterval);
+    });
+  };
+
+  updateSubscriptions = async (subscriptions: TrackSubscriptionDetails[]) => {
+    return this.rpc.updateSubscriptions({
+      sessionId: this.sessionId,
+      tracks: subscriptions,
+    });
+  };
+
+  setPublisher = async (data: Omit<SetPublisherRequest, 'sessionId'>) => {
+    return this.rpc.setPublisher({
+      ...data,
+      sessionId: this.sessionId,
+    });
+  };
+
+  sendAnswer = async (data: Omit<SendAnswerRequest, 'sessionId'>) => {
+    return this.rpc.sendAnswer({
+      ...data,
+      sessionId: this.sessionId,
+    });
+  };
+
+  iceTrickle = async (data: Omit<ICETrickle, 'sessionId'>) => {
+    return this.rpc.iceTrickle({
+      ...data,
+      sessionId: this.sessionId,
+    });
+  };
+
+  updateMuteState = async (trackType: TrackType, muted: boolean) => {
+    return this.updateMuteStates({
+      muteStates: [
+        {
+          trackType,
+          muted,
+        },
+      ],
+    });
+  };
+
+  updateMuteStates = async (
+    data: Omit<UpdateMuteStatesRequest, 'sessionId'>,
+  ) => {
+    return this.rpc.updateMuteStates({
+      ...data,
+      sessionId: this.sessionId,
+    });
+  };
+
+  join = async (data: Omit<JoinRequest, 'sessionId' | 'token'>) => {
+    const joinRequest = JoinRequest.create({
+      ...data,
+      sessionId: this.sessionId,
+      token: this.token,
+    });
+    return this.send(
+      SfuRequest.create({
+        requestPayload: {
+          oneofKind: 'joinRequest',
+          joinRequest,
+        },
+      }),
+    );
+  };
+
+  send = (message: SfuRequest) => {
+    return this.signalReady.then((signal) => {
+      signal.send(SfuRequest.toBinary(message));
+    });
+  };
+
+  // FIXME: make this private
+  async keepAlive() {
+    await this.signalReady;
+    console.log('Registering healthcheck for SFU');
+    this.keepAliveInterval = setInterval(() => {
+      const message = SfuRequest.create({
+        requestPayload: {
+          oneofKind: 'healthCheckRequest',
+          healthCheckRequest: {
+            sessionId: this.sessionId,
+          },
+        },
+      });
+      console.log('Sending healthCheckRequest to SFU', message);
+      this.send(message);
+    }, 27000);
+  }
+}