livekit-client 0.17.1 → 0.17.4

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/RTCEngine.ts

@@ -16,7 +16,7 @@ import {
 import { ConnectionError, TrackInvalidError, UnexpectedConnectionState } from './errors';
 import { EngineEvent } from './events';
 import PCTransport from './PCTransport';
-import { isFireFox, sleep } from './utils';
+import { isFireFox, isWeb, sleep } from './utils';
 
 const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
@@ -112,7 +112,10 @@ export default class RTCEngine extends (
     if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
       this.publisher.pc.getSenders().forEach((sender) => {
         try {
-          this.publisher?.pc.removeTrack(sender);
+          // TODO: react-native-webrtc doesn't have removeTrack yet.
+          if (this.publisher?.pc.removeTrack) {
+            this.publisher?.pc.removeTrack(sender);
+          }
         } catch (e) {
           log.warn('could not removeTrack', e);
         }
@@ -171,6 +174,11 @@ export default class RTCEngine extends (
       this.rtcConfig.iceServers = rtcIceServers;
     }
 
+    // @ts-ignore
+    this.rtcConfig.sdpSemantics = 'unified-plan';
+    // @ts-ignore
+    this.rtcConfig.continualGatheringPolicy = 'gather_continually';
+
     this.publisher = new PCTransport(this.rtcConfig);
     this.subscriber = new PCTransport(this.rtcConfig);
 
@@ -221,10 +229,18 @@ export default class RTCEngine extends (
       }
     };
 
-    this.subscriber.pc.ontrack = (ev: RTCTrackEvent) => {
-      this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
-    };
-
+    if (isWeb()) {
+      this.subscriber.pc.ontrack = (ev: RTCTrackEvent) => {
+        this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
+      };
+    } else {
+      // TODO: react-native-webrtc doesn't have ontrack yet, replace when ready.
+      // @ts-ignore
+      this.subscriber.pc.onaddstream = (ev: { stream: MediaStream }) => {
+        const track = ev.stream.getTracks()[0];
+        this.emit(EngineEvent.MediaTrackAdded, track, ev.stream);
+      };
+    }
     // data channels
     this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
       // will drop older packets that arrive
@@ -628,7 +644,7 @@ export type EngineEventCallbacks = {
   mediaTrackAdded: (
     track: MediaStreamTrack,
     streams: MediaStream,
-    receiver: RTCRtpReceiver
+    receiver?: RTCRtpReceiver
   ) => void,
   activeSpeakersUpdate: (speakers: Array<SpeakerInfo>) => void,
   dataPacketReceived: (userPacket: UserPacket, kind: DataPacket_Kind) => void,

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,
@@ -30,7 +30,7 @@ import { Track } from './track/Track';
 import { TrackPublication } from './track/TrackPublication';
 import { AdaptiveStreamSettings, RemoteTrack } from './track/types';
 import { getNewAudioContext } from './track/utils';
-import { unpackStreamId } from './utils';
+import { isWeb, unpackStreamId } from './utils';
 
 export enum RoomState {
   Disconnected = 'disconnected',
@@ -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) => {
@@ -271,8 +276,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         clearTimeout(connectTimeout);
 
         // also hook unload event
-        window.addEventListener('beforeunload', this.onBeforeUnload);
-        navigator.mediaDevices.addEventListener('devicechange', this.handleDeviceChange);
+        if (isWeb()) {
+          window.addEventListener('beforeunload', this.onBeforeUnload);
+          navigator.mediaDevices.addEventListener('devicechange', this.handleDeviceChange);
+        }
 
         resolve(this);
       });
@@ -521,8 +528,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.audioContext.close();
       this.audioContext = undefined;
     }
-    window.removeEventListener('beforeunload', this.onBeforeUnload);
-    navigator.mediaDevices.removeEventListener('devicechange', this.handleDeviceChange);
+    if (isWeb()) {
+      window.removeEventListener('beforeunload', this.onBeforeUnload);
+      navigator.mediaDevices.removeEventListener('devicechange', this.handleDeviceChange);
+    }
     this.state = RoomState.Disconnected;
     this.emit(RoomEvent.Disconnected);
     this.emit(RoomEvent.StateChanged, this.state);
@@ -532,7 +541,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // handle changes to participant state, and send events
     participantInfos.forEach((info) => {
       if (info.sid === this.localParticipant.sid
-          || info.identity === this.localParticipant.identity) {
+        || info.identity === this.localParticipant.identity) {
         this.localParticipant.updateInfo(info);
         return;
       }
@@ -798,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;
   }
 
@@ -903,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,
@@ -24,6 +25,7 @@ import {
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
+import { isFireFox } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
 import { computeVideoEncodings, mediaTrackToLocalTrack } from './publishUtils';
@@ -70,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 {
@@ -119,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)
@@ -259,6 +273,7 @@ export default class LocalParticipant extends Participant {
       } else if (track.kind === Track.Kind.Audio) {
         track.source = Track.Source.Microphone;
       }
+      track.mediaStream = stream;
       return track;
     });
   }
@@ -358,6 +373,12 @@ export default class LocalParticipant extends Participant {
       track.stopOnMute = true;
     }
 
+    if (track.source === Track.Source.ScreenShare && isFireFox()) {
+      // Firefox does not work well with simulcasted screen share
+      // we frequently get no data on layer 0 when enabled
+      opts.simulcast = false;
+    }
+
     // handle track actions
     track.on(TrackEvent.Muted, this.onTrackMuted);
     track.on(TrackEvent.Unmuted, this.onTrackUnmuted);
@@ -612,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/room/track/LocalTrack.ts

@@ -111,6 +111,7 @@ export default class LocalTrack extends Track {
       attachToElement(newTrack, el);
     });
 
+    this.mediaStream = mediaStream;
     this.constraints = constraints;
     return this;
   }

package/src/room/track/RemoteTrack.ts

@@ -32,6 +32,7 @@ export default abstract class RemoteTrack extends Track {
     // this is needed to determine when the track is finished
     // we send each track down in its own MediaStream, so we can assume the
     // current track is the only one that can be removed.
+    this.mediaStream = stream;
     stream.onremovetrack = () => {
       this.receiver = undefined;
       this._currentBitrate = 0;

package/src/room/track/Track.ts

@@ -3,7 +3,7 @@ import type TypedEventEmitter from 'typed-emitter';
 import { TrackSource, TrackType } from '../../proto/livekit_models';
 import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc';
 import { TrackEvent } from '../events';
-import { isFireFox, isSafari } from '../utils';
+import { isFireFox, isSafari, isWeb } from '../utils';
 
 // keep old audio elements when detached, we would re-use them since on iOS
 // Safari tracks which audio elements have been "blessed" by the user.
@@ -12,6 +12,8 @@ const recycledElements: Array<HTMLAudioElement> = [];
 export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEventCallbacks>) {
   kind: Track.Kind;
 
+  mediaStream?: MediaStream;
+
   mediaStreamTrack: MediaStreamTrack;
 
   attachedElements: HTMLMediaElement[] = [];
@@ -34,8 +36,12 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
     this.kind = kind;
     this.mediaStreamTrack = mediaTrack;
     this.source = Track.Source.Unknown;
-    this.isInBackground = document.visibilityState === 'hidden';
-    document.addEventListener('visibilitychange', this.appVisibilityChangedListener);
+    if (isWeb()) {
+      this.isInBackground = document.visibilityState === 'hidden';
+      document.addEventListener('visibilitychange', this.appVisibilityChangedListener);
+    } else {
+      this.isInBackground = false;
+    }
   }
 
   /** current receive bits per second */
@@ -133,7 +139,9 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
 
   stop() {
     this.mediaStreamTrack.stop();
-    document.removeEventListener('visibilitychange', this.appVisibilityChangedListener);
+    if (isWeb()) {
+      document.removeEventListener('visibilitychange', this.appVisibilityChangedListener);
+    }
   }
 
   protected enable() {

package/src/room/track/create.ts

@@ -47,6 +47,7 @@ export async function createLocalTracks(
     } else if (track.kind === Track.Kind.Audio) {
       track.source = Track.Source.Microphone;
     }
+    track.mediaStream = stream;
     return track;
   });
 }

package/src/room/utils.ts

@@ -27,6 +27,10 @@ export function isMobile(): boolean {
   return /Tablet|iPad|Mobile|Android|BlackBerry/.test(navigator.userAgent);
 }
 
+export function isWeb(): boolean {
+  return typeof document !== 'undefined';
+}
+
 function roDispatchCallback(entries: ResizeObserverEntry[]) {
   for (const entry of entries) {
     (entry.target as ObservableMediaElement).handleResize(entry);

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.17.1';
-export const protocolVersion = 6;
+export const version = '0.17.4';
+export const protocolVersion = 7;