@stream-io/video-client 0.1.11 → 0.2.0

package/src/gen/coordinator/index.ts

@@ -317,6 +317,25 @@ export interface BroadcastSettings {
    */
   hls: HLSSettings;
 }
+/**
+ *
+ * @export
+ * @interface BroadcastSettingsRequest
+ */
+export interface BroadcastSettingsRequest {
+  /**
+   *
+   * @type {boolean}
+   * @memberof BroadcastSettingsRequest
+   */
+  enabled?: boolean;
+  /**
+   *
+   * @type {HLSSettingsRequest}
+   * @memberof BroadcastSettingsRequest
+   */
+  hls?: HLSSettingsRequest;
+}
 /**
  * This event is sent when a user accepts a notification to join a call.
  * @export
@@ -1340,6 +1359,12 @@ export interface CallSettingsRequest {
    * @memberof CallSettingsRequest
    */
   backstage?: BackstageSettingsRequest;
+  /**
+   *
+   * @type {BroadcastSettingsRequest}
+   * @memberof CallSettingsRequest
+   */
+  broadcasting?: BroadcastSettingsRequest;
   /**
    *
    * @type {GeofenceSettingsRequest}
@@ -2413,6 +2438,31 @@ export interface HLSSettings {
    */
   quality_tracks: Array<string>;
 }
+/**
+ *
+ * @export
+ * @interface HLSSettingsRequest
+ */
+export interface HLSSettingsRequest {
+  /**
+   *
+   * @type {boolean}
+   * @memberof HLSSettingsRequest
+   */
+  auto_on?: boolean;
+  /**
+   *
+   * @type {boolean}
+   * @memberof HLSSettingsRequest
+   */
+  enabled?: boolean;
+  /**
+   *
+   * @type {Array<string>}
+   * @memberof HLSSettingsRequest
+   */
+  quality_tracks?: Array<string>;
+}
 /**
  *
  * @export
@@ -2836,6 +2886,7 @@ export const OwnCapability = {
   JOIN_CALL: 'join-call',
   JOIN_ENDED_CALL: 'join-ended-call',
   MUTE_USERS: 'mute-users',
+  PIN_FOR_EVERYONE: 'pin-for-everyone',
   READ_CALL: 'read-call',
   REMOVE_CALL_MEMBER: 'remove-call-member',
   SCREENSHARE: 'screenshare',
@@ -2959,6 +3010,38 @@ export interface PermissionRequestEvent {
    */
   user: UserResponse;
 }
+/**
+ *
+ * @export
+ * @interface PinRequest
+ */
+export interface PinRequest {
+  /**
+   *
+   * @type {string}
+   * @memberof PinRequest
+   */
+  session_id: string;
+  /**
+   *
+   * @type {string}
+   * @memberof PinRequest
+   */
+  user_id: string;
+}
+/**
+ *
+ * @export
+ * @interface PinResponse
+ */
+export interface PinResponse {
+  /**
+   * Duration of the request in human-readable format
+   * @type {string}
+   * @memberof PinResponse
+   */
+  duration: string;
+}
 /**
  *
  * @export
@@ -3774,6 +3857,38 @@ export interface UnblockedUserEvent {
    */
   user: UserResponse;
 }
+/**
+ *
+ * @export
+ * @interface UnpinRequest
+ */
+export interface UnpinRequest {
+  /**
+   *
+   * @type {string}
+   * @memberof UnpinRequest
+   */
+  session_id: string;
+  /**
+   *
+   * @type {string}
+   * @memberof UnpinRequest
+   */
+  user_id: string;
+}
+/**
+ *
+ * @export
+ * @interface UnpinResponse
+ */
+export interface UnpinResponse {
+  /**
+   * Duration of the request in human-readable format
+   * @type {string}
+   * @memberof UnpinResponse
+   */
+  duration: string;
+}
 /**
  *
  * @export

package/src/gen/video/sfu/event/events.ts

@@ -28,6 +28,7 @@ import {
   Participant,
   ParticipantCount,
   PeerType,
+  Pin,
   TrackInfo,
   TrackType,
   TrackUnpublishReason,
@@ -218,10 +219,31 @@ export interface SfuEvent {
          */
         iceRestart: ICERestart;
       }
+    | {
+        oneofKind: 'pinsUpdated';
+        /**
+         * PinsChanged is sent the list of pins in the call changes. This event contains the entire list of pins.
+         *
+         * @generated from protobuf field: stream.video.sfu.event.PinsChanged pins_updated = 22;
+         */
+        pinsUpdated: PinsChanged;
+      }
     | {
         oneofKind: undefined;
       };
 }
+/**
+ * @generated from protobuf message stream.video.sfu.event.PinsChanged
+ */
+export interface PinsChanged {
+  /**
+   * the list of pins in the call.
+   * Pins are ordered in descending order (most important first).
+   *
+   * @generated from protobuf field: repeated stream.video.sfu.models.Pin pins = 1;
+   */
+  pins: Pin[];
+}
 /**
  * @generated from protobuf message stream.video.sfu.event.Error
  */
@@ -844,6 +866,13 @@ class SfuEvent$Type extends MessageType<SfuEvent> {
         oneof: 'eventPayload',
         T: () => ICERestart,
       },
+      {
+        no: 22,
+        name: 'pins_updated',
+        kind: 'message',
+        oneof: 'eventPayload',
+        T: () => PinsChanged,
+      },
     ]);
   }
   create(value?: PartialMessage<SfuEvent>): SfuEvent {
@@ -1055,6 +1084,17 @@ class SfuEvent$Type extends MessageType<SfuEvent> {
             ),
           };
           break;
+        case /* stream.video.sfu.event.PinsChanged pins_updated */ 22:
+          message.eventPayload = {
+            oneofKind: 'pinsUpdated',
+            pinsUpdated: PinsChanged.internalBinaryRead(
+              reader,
+              reader.uint32(),
+              options,
+              (message.eventPayload as any).pinsUpdated,
+            ),
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === 'throw')
@@ -1198,6 +1238,13 @@ class SfuEvent$Type extends MessageType<SfuEvent> {
         writer.tag(21, WireType.LengthDelimited).fork(),
         options,
       ).join();
+    /* stream.video.sfu.event.PinsChanged pins_updated = 22; */
+    if (message.eventPayload.oneofKind === 'pinsUpdated')
+      PinsChanged.internalBinaryWrite(
+        message.eventPayload.pinsUpdated,
+        writer.tag(22, WireType.LengthDelimited).fork(),
+        options,
+      ).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(
@@ -1213,6 +1260,90 @@ class SfuEvent$Type extends MessageType<SfuEvent> {
  */
 export const SfuEvent = new SfuEvent$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class PinsChanged$Type extends MessageType<PinsChanged> {
+  constructor() {
+    super('stream.video.sfu.event.PinsChanged', [
+      {
+        no: 1,
+        name: 'pins',
+        kind: 'message',
+        repeat: 1 /*RepeatType.PACKED*/,
+        T: () => Pin,
+      },
+    ]);
+  }
+  create(value?: PartialMessage<PinsChanged>): PinsChanged {
+    const message = { pins: [] };
+    globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+      enumerable: false,
+      value: this,
+    });
+    if (value !== undefined)
+      reflectionMergePartial<PinsChanged>(this, message, value);
+    return message;
+  }
+  internalBinaryRead(
+    reader: IBinaryReader,
+    length: number,
+    options: BinaryReadOptions,
+    target?: PinsChanged,
+  ): PinsChanged {
+    let message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated stream.video.sfu.models.Pin pins */ 1:
+          message.pins.push(
+            Pin.internalBinaryRead(reader, reader.uint32(), options),
+          );
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === 'throw')
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d,
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(
+    message: PinsChanged,
+    writer: IBinaryWriter,
+    options: BinaryWriteOptions,
+  ): IBinaryWriter {
+    /* repeated stream.video.sfu.models.Pin pins = 1; */
+    for (let i = 0; i < message.pins.length; i++)
+      Pin.internalBinaryWrite(
+        message.pins[i],
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options,
+      ).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer,
+      );
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.event.PinsChanged
+ */
+export const PinsChanged = new PinsChanged$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class Error$Type extends MessageType<Error> {
   constructor() {
     super('stream.video.sfu.event.Error', [

package/src/gen/video/sfu/models/models.ts

@@ -48,6 +48,13 @@ export interface CallState {
    * @generated from protobuf field: stream.video.sfu.models.ParticipantCount participant_count = 3;
    */
   participantCount?: ParticipantCount;
+  /**
+   * the list of pins in the call.
+   * Pins are ordered in descending order (most important first).
+   *
+   * @generated from protobuf field: repeated stream.video.sfu.models.Pin pins = 4;
+   */
+  pins: Pin[];
 }
 /**
  * @generated from protobuf message stream.video.sfu.models.ParticipantCount
@@ -67,6 +74,23 @@ export interface ParticipantCount {
    */
   anonymous: number;
 }
+/**
+ * @generated from protobuf message stream.video.sfu.models.Pin
+ */
+export interface Pin {
+  /**
+   * the user to pin
+   *
+   * @generated from protobuf field: string user_id = 1;
+   */
+  userId: string;
+  /**
+   * the user sesion_id to pin, if not provided, applies to all sessions
+   *
+   * @generated from protobuf field: string session_id = 2;
+   */
+  sessionId: string;
+}
 /**
  * those who are online in the call
  *
@@ -695,10 +719,17 @@ class CallState$Type extends MessageType<CallState> {
         kind: 'message',
         T: () => ParticipantCount,
       },
+      {
+        no: 4,
+        name: 'pins',
+        kind: 'message',
+        repeat: 1 /*RepeatType.PACKED*/,
+        T: () => Pin,
+      },
     ]);
   }
   create(value?: PartialMessage<CallState>): CallState {
-    const message = { participants: [] };
+    const message = { participants: [], pins: [] };
     globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
       enumerable: false,
       value: this,
@@ -739,6 +770,11 @@ class CallState$Type extends MessageType<CallState> {
             message.participantCount,
           );
           break;
+        case /* repeated stream.video.sfu.models.Pin pins */ 4:
+          message.pins.push(
+            Pin.internalBinaryRead(reader, reader.uint32(), options),
+          );
+          break;
         default:
           let u = options.readUnknownField;
           if (u === 'throw')
@@ -784,6 +820,13 @@ class CallState$Type extends MessageType<CallState> {
         writer.tag(3, WireType.LengthDelimited).fork(),
         options,
       ).join();
+    /* repeated stream.video.sfu.models.Pin pins = 4; */
+    for (let i = 0; i < message.pins.length; i++)
+      Pin.internalBinaryWrite(
+        message.pins[i],
+        writer.tag(4, WireType.LengthDelimited).fork(),
+        options,
+      ).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(
@@ -878,6 +921,84 @@ class ParticipantCount$Type extends MessageType<ParticipantCount> {
  */
 export const ParticipantCount = new ParticipantCount$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class Pin$Type extends MessageType<Pin> {
+  constructor() {
+    super('stream.video.sfu.models.Pin', [
+      { no: 1, name: 'user_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+    ]);
+  }
+  create(value?: PartialMessage<Pin>): Pin {
+    const message = { userId: '', sessionId: '' };
+    globalThis.Object.defineProperty(message, MESSAGE_TYPE, {
+      enumerable: false,
+      value: this,
+    });
+    if (value !== undefined) reflectionMergePartial<Pin>(this, message, value);
+    return message;
+  }
+  internalBinaryRead(
+    reader: IBinaryReader,
+    length: number,
+    options: BinaryReadOptions,
+    target?: Pin,
+  ): Pin {
+    let message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string user_id */ 1:
+          message.userId = reader.string();
+          break;
+        case /* string session_id */ 2:
+          message.sessionId = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === 'throw')
+            throw new globalThis.Error(
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
+            );
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(
+              this.typeName,
+              message,
+              fieldNo,
+              wireType,
+              d,
+            );
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(
+    message: Pin,
+    writer: IBinaryWriter,
+    options: BinaryWriteOptions,
+  ): IBinaryWriter {
+    /* string user_id = 1; */
+    if (message.userId !== '')
+      writer.tag(1, WireType.LengthDelimited).string(message.userId);
+    /* string session_id = 2; */
+    if (message.sessionId !== '')
+      writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(
+        this.typeName,
+        message,
+        writer,
+      );
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.Pin
+ */
+export const Pin = new Pin$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class Participant$Type extends MessageType<Participant> {
   constructor() {
     super('stream.video.sfu.models.Participant', [

package/src/rtc/Dispatcher.ts

@@ -22,6 +22,7 @@ const sfuEventKinds: { [key in SfuEventKinds]: undefined } = {
   callGrantsUpdated: undefined,
   goAway: undefined,
   iceRestart: undefined,
+  pinsUpdated: undefined,
 };
 
 export const isSfuEvent = (

package/src/rtc/flows/join.ts

@@ -112,15 +112,9 @@ export const reconcileParticipantLocalState = (
 ) => {
   if (!source) return target;
 
-  target.audioStream = source.audioStream;
-  target.videoStream = source.videoStream;
-  target.screenShareStream = source.screenShareStream;
+  // copy everything from source to target
+  Object.assign(target, source);
 
-  target.videoDimension = source.videoDimension;
-  target.screenShareDimension = source.screenShareDimension;
-  target.pinnedAt = source.pinnedAt;
-  target.reaction = source.reaction;
-  target.viewportVisibilityState = source.viewportVisibilityState;
   if (
     isStreamVideoLocalParticipant(source) &&
     isStreamVideoLocalParticipant(target)

package/src/sorting/__tests__/participant-data.ts

@@ -92,7 +92,10 @@ export const participants = (): StreamVideoParticipant[] => [
     isDominantSpeaker: false,
     audioLevel: 0,
     image: '',
-    pinnedAt: Date.now(),
+    pin: {
+      isLocalPin: true,
+      pinnedAt: Date.now(),
+    },
     roles: [],
     viewportVisibilityState: VisibilityState.VISIBLE,
   },

package/src/sorting/participants.ts

@@ -69,13 +69,15 @@ export const publishingAudio: Comparator<StreamVideoParticipant> = (a, b) => {
  * @param b the second participant.
  */
 export const pinned: Comparator<StreamVideoParticipant> = (a, b) => {
-  if (a.pinnedAt && b.pinnedAt) {
-    if (a.pinnedAt > b.pinnedAt) return -1;
-    if (a.pinnedAt < b.pinnedAt) return 1;
+  if (a.pin && b.pin) {
+    if (!a.pin.isLocalPin && b.pin.isLocalPin) return -1;
+    if (a.pin.isLocalPin && !b.pin.isLocalPin) return 1;
+    if (a.pin.pinnedAt > b.pin.pinnedAt) return -1;
+    if (a.pin.pinnedAt < b.pin.pinnedAt) return 1;
   }
 
-  if (a.pinnedAt && !b.pinnedAt) return -1;
-  if (!a.pinnedAt && b.pinnedAt) return 1;
+  if (a.pin && !b.pin) return -1;
+  if (!a.pin && b.pin) return 1;
 
   return 0;
 };

package/src/store/CallState.ts

@@ -16,7 +16,7 @@ import {
   MemberResponse,
   OwnCapability,
 } from '../gen/coordinator';
-import { TrackType } from '../gen/video/sfu/models/models';
+import { Pin, TrackType } from '../gen/video/sfu/models/models';
 import { Comparator } from '../sorting';
 import * as SortingPreset from '../sorting/presets';
 import { getLogger } from '../logger';
@@ -287,7 +287,7 @@ export class CallState {
     );
 
     this.pinnedParticipants$ = this.participants$.pipe(
-      map((participants) => participants.filter((p) => p.pinnedAt)),
+      map((participants) => participants.filter((p) => !!p.pin)),
     );
 
     this.dominantSpeaker$ = this.participants$.pipe(
@@ -678,4 +678,45 @@ export class CallState {
       }),
     );
   };
+
+  /**
+   * Updates the participant pinned state with server side pinning data.
+   *
+   * @param pins the latest pins from the server.
+   */
+  setServerSidePins = (pins: Pin[]) => {
+    const pinsLookup = pins.reduce<{ [sessionId: string]: number | undefined }>(
+      (lookup, pin) => {
+        lookup[pin.sessionId] = Date.now();
+        return lookup;
+      },
+      {},
+    );
+
+    return this.setParticipants((participants) =>
+      participants.map((participant) => {
+        const serverSidePinnedAt = pinsLookup[participant.sessionId];
+        // the participant is newly pinned
+        if (serverSidePinnedAt) {
+          return {
+            ...participant,
+            pin: {
+              isLocalPin: false,
+              pinnedAt: serverSidePinnedAt,
+            },
+          };
+        }
+        // the participant is no longer pinned server side
+        // we need to reset the pin
+        if (participant.pin && !participant.pin.isLocalPin) {
+          return {
+            ...participant,
+            pin: undefined,
+          };
+        }
+        // no changes to be applied
+        return participant;
+      }),
+    );
+  };
 }