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

package/src/events/internal.ts

@@ -0,0 +1,47 @@
+import { Dispatcher } from '../rtc/Dispatcher';
+import { Call } from '../rtc/Call';
+import { StreamVideoWriteableStateStore } from '../store';
+import { StreamVideoParticipantPatches } from '../rtc/types';
+
+/**
+ * An event responder which handles the `changePublishQuality` event.
+ */
+export const watchChangePublishQuality = (
+  dispatcher: Dispatcher,
+  call: Call,
+) => {
+  return dispatcher.on('changePublishQuality', (e) => {
+    if (e.eventPayload.oneofKind !== 'changePublishQuality') return;
+    const { videoSenders } = e.eventPayload.changePublishQuality;
+    videoSenders.forEach((videoSender) => {
+      const { layers } = videoSender;
+      call.updatePublishQuality(
+        layers.filter((l) => l.active).map((l) => l.name),
+      );
+    });
+  });
+};
+
+export const watchConnectionQualityChanged = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+) => {
+  return dispatcher.on('connectionQualityChanged', (e) => {
+    if (e.eventPayload.oneofKind !== 'connectionQualityChanged') return;
+    const { connectionQualityChanged } = e.eventPayload;
+    const { connectionQualityUpdates } = connectionQualityChanged;
+    if (!connectionQualityUpdates) return;
+    store.updateParticipants(
+      connectionQualityUpdates.reduce<StreamVideoParticipantPatches>(
+        (patches, update) => {
+          const { sessionId, connectionQuality } = update;
+          patches[sessionId] = {
+            connectionQuality,
+          };
+          return patches;
+        },
+        {},
+      ),
+    );
+  });
+};

package/src/events/participant.ts

@@ -0,0 +1,97 @@
+import { Batcher } from '../Batcher';
+import { Dispatcher } from '../rtc/Dispatcher';
+import { StreamVideoWriteableStateStore } from '../store';
+
+/**
+ * An event responder which handles the `participantJoined` event.
+ */
+export const watchParticipantJoined = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+  userBatcher: Batcher<string>,
+) => {
+  return dispatcher.on('participantJoined', (e) => {
+    if (e.eventPayload.oneofKind !== 'participantJoined') return;
+    const { participant } = e.eventPayload.participantJoined;
+    if (!participant) return;
+
+    const activeCall = store.getCurrentValue(store.activeCallSubject);
+
+    // FIXME: this part is being repeated in call.join event as well
+    const { users } = activeCall!.data;
+    const userData = users[participant.userId];
+    if (!userData) userBatcher.addToBatch(participant.userId);
+
+    store.setCurrentValue(store.participantsSubject, (currentParticipants) => [
+      ...currentParticipants,
+      {
+        ...participant,
+        user: userData,
+      },
+    ]);
+  });
+};
+
+/**
+ * An event responder which handles the `participantLeft` event.
+ */
+export const watchParticipantLeft = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+) => {
+  return dispatcher.on('participantLeft', (e) => {
+    if (e.eventPayload.oneofKind !== 'participantLeft') return;
+    const { participant, callCid } = e.eventPayload.participantLeft;
+    if (!participant) return;
+
+    const activeCall = store.getCurrentValue(store.activeCallSubject);
+    if (callCid !== activeCall?.data.call.cid) {
+      console.warn('Received participantLeft notification for a unknown call');
+      return;
+    }
+
+    store.setCurrentValue(store.participantsSubject, (participants) =>
+      participants.filter((p) => p.sessionId !== participant.sessionId),
+    );
+  });
+};
+
+/**
+ * An event responder which handles the `trackPublished` event.
+ * The SFU will send this event when a participant publishes a track.
+ */
+export const watchTrackPublished = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+) => {
+  return dispatcher.on('trackPublished', (e) => {
+    if (e.eventPayload.oneofKind !== 'trackPublished') return;
+    const {
+      trackPublished: { type, sessionId },
+    } = e.eventPayload;
+    store.updateParticipant(sessionId, (p) => ({
+      publishedTracks: [...p.publishedTracks, type].filter(unique),
+    }));
+  });
+};
+
+/**
+ * An event responder which handles the `trackUnpublished` event.
+ * The SFU will send this event when a participant unpublishes a track.
+ */
+export const watchTrackUnpublished = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+) => {
+  return dispatcher.on('trackUnpublished', (e) => {
+    if (e.eventPayload.oneofKind !== 'trackUnpublished') return;
+    const {
+      trackUnpublished: { type, sessionId },
+    } = e.eventPayload;
+    store.updateParticipant(sessionId, (p) => ({
+      publishedTracks: p.publishedTracks.filter((t) => t !== type),
+    }));
+  });
+};
+
+const unique = <T>(v: T, i: number, arr: T[]) => arr.indexOf(v) === i;

package/src/events/speaker.ts

@@ -0,0 +1,62 @@
+import { Dispatcher } from '../rtc/Dispatcher';
+import { StreamVideoWriteableStateStore } from '../store';
+import { StreamVideoParticipantPatches } from '../rtc/types';
+
+/**
+ * Watches for `dominantSpeakerChanged` events.
+ */
+export const watchDominantSpeakerChanged = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+) => {
+  return dispatcher.on('dominantSpeakerChanged', (e) => {
+    if (e.eventPayload.oneofKind !== 'dominantSpeakerChanged') return;
+    const {
+      dominantSpeakerChanged: { sessionId },
+    } = e.eventPayload;
+    const dominantSpeaker = store.getCurrentValue(store.dominantSpeaker$);
+    if (sessionId === dominantSpeaker?.sessionId) return;
+    store.setCurrentValue(store.participantsSubject, (participants) =>
+      participants.map((participant) => {
+        // mark the new dominant speaker
+        if (participant.sessionId === sessionId) {
+          return {
+            ...participant,
+            isDominantSpeaker: true,
+          };
+        }
+        // unmark the old dominant speaker
+        if (participant.isDominantSpeaker) {
+          return {
+            ...participant,
+            isDominantSpeaker: false,
+          };
+        }
+        return participant; // no change
+      }),
+    );
+  });
+};
+
+/**
+ * Watches for `audioLevelChanged` events.
+ */
+export const watchAudioLevelChanged = (
+  dispatcher: Dispatcher,
+  store: StreamVideoWriteableStateStore,
+) => {
+  return dispatcher.on('audioLevelChanged', (e) => {
+    if (e.eventPayload.oneofKind !== 'audioLevelChanged') return;
+
+    const { audioLevels } = e.eventPayload.audioLevelChanged;
+    store.updateParticipants(
+      audioLevels.reduce<StreamVideoParticipantPatches>((patches, current) => {
+        patches[current.sessionId] = {
+          audioLevel: current.level,
+          isSpeaking: current.isSpeaking,
+        };
+        return patches;
+      }, {}),
+    );
+  });
+};