livekit-client 0.17.2 → 0.17.3

package/src/proto/livekit_rtc.ts

@@ -152,6 +152,8 @@ export interface SignalResponse {
   subscriptionPermissionUpdate?: SubscriptionPermissionUpdate | undefined;
   /** update the token the client was using, to prevent an active client from using an expired token */
   refreshToken: string | undefined;
+  /** server initiated track unpublish */
+  trackUnpublished?: TrackUnpublishedResponse | undefined;
 }
 
 export interface AddTrackRequest {
@@ -202,6 +204,10 @@ export interface TrackPublishedResponse {
   track?: TrackInfo;
 }
 
+export interface TrackUnpublishedResponse {
+  trackSid: string;
+}
+
 export interface SessionDescription {
   /** "answer" | "offer" | "pranswer" | "rollback" */
   type: string;
@@ -738,6 +744,12 @@ export const SignalResponse = {
     if (message.refreshToken !== undefined) {
       writer.uint32(130).string(message.refreshToken);
     }
+    if (message.trackUnpublished !== undefined) {
+      TrackUnpublishedResponse.encode(
+        message.trackUnpublished,
+        writer.uint32(138).fork()
+      ).ldelim();
+    }
     return writer;
   },
 
@@ -809,6 +821,12 @@ export const SignalResponse = {
         case 16:
           message.refreshToken = reader.string();
           break;
+        case 17:
+          message.trackUnpublished = TrackUnpublishedResponse.decode(
+            reader,
+            reader.uint32()
+          );
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -922,6 +940,16 @@ export const SignalResponse = {
     } else {
       message.refreshToken = undefined;
     }
+    if (
+      object.trackUnpublished !== undefined &&
+      object.trackUnpublished !== null
+    ) {
+      message.trackUnpublished = TrackUnpublishedResponse.fromJSON(
+        object.trackUnpublished
+      );
+    } else {
+      message.trackUnpublished = undefined;
+    }
     return message;
   },
 
@@ -985,6 +1013,10 @@ export const SignalResponse = {
         : undefined);
     message.refreshToken !== undefined &&
       (obj.refreshToken = message.refreshToken);
+    message.trackUnpublished !== undefined &&
+      (obj.trackUnpublished = message.trackUnpublished
+        ? TrackUnpublishedResponse.toJSON(message.trackUnpublished)
+        : undefined);
     return obj;
   },
 
@@ -1089,6 +1121,16 @@ export const SignalResponse = {
       message.subscriptionPermissionUpdate = undefined;
     }
     message.refreshToken = object.refreshToken ?? undefined;
+    if (
+      object.trackUnpublished !== undefined &&
+      object.trackUnpublished !== null
+    ) {
+      message.trackUnpublished = TrackUnpublishedResponse.fromPartial(
+        object.trackUnpublished
+      );
+    } else {
+      message.trackUnpublished = undefined;
+    }
     return message;
   },
 };
@@ -1729,6 +1771,71 @@ export const TrackPublishedResponse = {
   },
 };
 
+const baseTrackUnpublishedResponse: object = { trackSid: "" };
+
+export const TrackUnpublishedResponse = {
+  encode(
+    message: TrackUnpublishedResponse,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.trackSid !== "") {
+      writer.uint32(10).string(message.trackSid);
+    }
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): TrackUnpublishedResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = {
+      ...baseTrackUnpublishedResponse,
+    } as TrackUnpublishedResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.trackSid = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TrackUnpublishedResponse {
+    const message = {
+      ...baseTrackUnpublishedResponse,
+    } as TrackUnpublishedResponse;
+    if (object.trackSid !== undefined && object.trackSid !== null) {
+      message.trackSid = String(object.trackSid);
+    } else {
+      message.trackSid = "";
+    }
+    return message;
+  },
+
+  toJSON(message: TrackUnpublishedResponse): unknown {
+    const obj: any = {};
+    message.trackSid !== undefined && (obj.trackSid = message.trackSid);
+    return obj;
+  },
+
+  fromPartial(
+    object: DeepPartial<TrackUnpublishedResponse>
+  ): TrackUnpublishedResponse {
+    const message = {
+      ...baseTrackUnpublishedResponse,
+    } as TrackUnpublishedResponse;
+    message.trackSid = object.trackSid ?? "";
+    return message;
+  },
+};
+
 const baseSessionDescription: object = { type: "", sdp: "" };
 
 export const SessionDescription = {

package/src/room/Room.ts

@@ -5,7 +5,7 @@ import log from '../logger';
 import { RoomConnectOptions, RoomOptions } from '../options';
 import {
   DataPacket_Kind, ParticipantInfo,
-  ParticipantInfo_State, Room as RoomModel, SpeakerInfo, UserPacket,
+  ParticipantInfo_State, ParticipantPermission, Room as RoomModel, SpeakerInfo, UserPacket,
 } from '../proto/livekit_models';
 import {
   ConnectionQualityUpdate,
@@ -211,12 +211,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.state = RoomState.Connected;
       this.emit(RoomEvent.StateChanged, this.state);
       const pi = joinResponse.participant!;
-      this.localParticipant = new LocalParticipant(
-        pi.sid,
-        pi.identity,
-        this.engine,
-        this.options,
-      );
+
+      this.localParticipant.sid = pi.sid;
+      this.localParticipant.identity = pi.identity;
 
       this.localParticipant.updateInfo(pi);
       // forward metadata changed for the local participant
@@ -244,7 +241,15 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         })
         .on(ParticipantEvent.MediaDevicesError, (e: Error) => {
           this.emit(RoomEvent.MediaDevicesError, e);
-        });
+        })
+        .on(ParticipantEvent.ParticipantPermissionsChanged,
+          (prevPermissions: ParticipantPermission) => {
+            this.emit(
+              RoomEvent.ParticipantPermissionsChanged,
+              prevPermissions,
+              this.localParticipant,
+            );
+          });
 
       // populate remote participants, these should not trigger new events
       joinResponse.otherParticipants.forEach((info) => {
@@ -802,7 +807,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       })
       .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
         this.emit(RoomEvent.ConnectionQualityChanged, quality, participant);
-      });
+      })
+      .on(ParticipantEvent.ParticipantPermissionsChanged,
+        (prevPermissions: ParticipantPermission) => {
+          this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, participant);
+        });
     return participant;
   }
 
@@ -907,6 +916,10 @@ export type RoomEventCallbacks = {
     metadata: string | undefined,
     participant: RemoteParticipant | LocalParticipant
   ) => void,
+  participantPermissionsChanged: (
+    prevPermissions: ParticipantPermission,
+    participant: RemoteParticipant | LocalParticipant
+  ) => void,
   activeSpeakersChanged: (speakers: Array<Participant>) => void,
   roomMetadataChanged: (metadata: string) => void,
   dataReceived: (

package/src/room/events.ts

@@ -225,6 +225,12 @@ export enum RoomEvent {
    * args: (error: Error)
    */
   MediaDevicesError = 'mediaDevicesError',
+
+  /**
+   * A participant's permission has changed. Currently only fired on LocalParticipant.
+   * args: (prevPermissions: [[ParticipantPermission]], participant: [[Participant]])
+   */
+  ParticipantPermissionsChanged = 'participantPermissionsChanged',
 }
 
 export enum ParticipantEvent {
@@ -370,6 +376,12 @@ export enum ParticipantEvent {
   // fired only on LocalParticipant
   /** @internal */
   MediaDevicesError = 'mediaDevicesError',
+
+  /**
+   * A participant's permission has changed. Currently only fired on LocalParticipant.
+   * args: (prevPermissions: [[ParticipantPermission]])
+   */
+  ParticipantPermissionsChanged = 'participantPermissionsChanged',
 }
 
 /** @internal */

package/src/room/participant/LocalParticipant.ts

@@ -1,10 +1,11 @@
 import log from '../../logger';
 import { RoomOptions } from '../../options';
 import {
-  DataPacket, DataPacket_Kind,
+  DataPacket, DataPacket_Kind, ParticipantPermission,
 } from '../../proto/livekit_models';
 import {
-  AddTrackRequest, DataChannelInfo, SubscribedQualityUpdate, TrackPublishedResponse,
+  AddTrackRequest, DataChannelInfo,
+  SubscribedQualityUpdate, TrackPublishedResponse, TrackUnpublishedResponse,
 } from '../../proto/livekit_rtc';
 import {
   TrackInvalidError,
@@ -71,6 +72,8 @@ export default class LocalParticipant extends Participant {
     };
 
     this.engine.client.onSubscribedQualityUpdate = this.handleSubscribedQualityUpdate;
+
+    this.engine.client.onLocalTrackUnpublished = this.handleLocalTrackUnpublished;
   }
 
   get lastCameraError(): Error | undefined {
@@ -120,6 +123,16 @@ export default class LocalParticipant extends Participant {
     return this.setTrackEnabled(Track.Source.ScreenShare, enabled);
   }
 
+  /** @internal */
+  setPermissions(permissions: ParticipantPermission): boolean {
+    const prevPermissions = this.permissions;
+    const changed = super.setPermissions(permissions);
+    if (changed && prevPermissions) {
+      this.emit(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions);
+    }
+    return changed;
+  }
+
   /**
    * Enable or disable publishing for a track by source. This serves as a simple
    * way to manage the common tracks (camera, mic, or screen share)
@@ -620,6 +633,16 @@ export default class LocalParticipant extends Participant {
     pub.videoTrack?.setPublishingLayers(update.subscribedQualities);
   };
 
+  private handleLocalTrackUnpublished = (unpublished: TrackUnpublishedResponse) => {
+    const track = this.tracks.get(unpublished.trackSid);
+    if (!track) {
+      log.warn('handleLocalTrackUnpublished',
+        'received unpublished event for unknown track', unpublished.trackSid);
+      return;
+    }
+    this.unpublishTrack(track.track!);
+  };
+
   private onTrackUnpublish = (track: LocalTrack) => {
     this.unpublishTrack(track);
   };

package/src/room/participant/Participant.ts

@@ -1,6 +1,8 @@
 import { EventEmitter } from 'events';
 import type TypedEmitter from 'typed-emitter';
-import { ConnectionQuality as ProtoQuality, DataPacket_Kind, ParticipantInfo } from '../../proto/livekit_models';
+import {
+  ConnectionQuality as ProtoQuality, DataPacket_Kind, ParticipantInfo, ParticipantPermission,
+} from '../../proto/livekit_models';
 import { ParticipantEvent, TrackEvent } from '../events';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
@@ -60,6 +62,8 @@ export default class Participant extends (
 
   lastSpokeAt?: Date | undefined;
 
+  permissions?: ParticipantPermission;
+
   private _connectionQuality: ConnectionQuality = ConnectionQuality.Unknown;
 
   /** @internal */
@@ -153,13 +157,16 @@ export default class Participant extends (
     this.sid = info.sid;
     this.name = info.name;
     this.setMetadata(info.metadata);
+    if (info.permission) {
+      this.setPermissions(info.permission);
+    }
     // set this last so setMetadata can detect changes
     this.participantInfo = info;
   }
 
   /** @internal */
   setMetadata(md: string) {
-    const changed = !this.participantInfo || this.participantInfo.metadata !== md;
+    const changed = this.metadata !== md;
     const prevMetadata = this.metadata;
     this.metadata = md;
 
@@ -169,6 +176,18 @@ export default class Participant extends (
     }
   }
 
+  /** @internal */
+  setPermissions(permissions: ParticipantPermission): boolean {
+    const changed = permissions.canPublish !== this.permissions?.canPublish
+      || permissions.canSubscribe !== this.permissions?.canSubscribe
+      || permissions.canPublishData !== this.permissions?.canPublishData
+      || permissions.hidden !== this.permissions?.hidden
+      || permissions.recorder !== this.permissions?.recorder;
+    this.permissions = permissions;
+
+    return changed;
+  }
+
   /** @internal */
   setIsSpeaking(speaking: boolean) {
     if (speaking === this.isSpeaking) {
@@ -246,4 +265,5 @@ export type ParticipantEventCallbacks = {
     status: TrackPublication.SubscriptionStatus
   ) => void,
   mediaDevicesError: (error: Error) => void,
+  participantPermissionsChanged: (prevPermissions: ParticipantPermission) => void,
 };

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.17.2';
-export const protocolVersion = 6;
+export const version = '0.17.3';
+export const protocolVersion = 7;