livekit-client 2.0.4 → 2.0.6

package/src/room/Room.ts

@@ -1,40 +1,38 @@
-import { protoInt64 } from '@bufbuild/protobuf';
-import { EventEmitter } from 'events';
-import type TypedEmitter from 'typed-emitter';
-import 'webrtc-adapter';
-import { EncryptionEvent } from '../e2ee';
-import { E2EEManager } from '../e2ee/E2eeManager';
-import log, { LoggerNames, getLogger } from '../logger';
-import type {
-  InternalRoomConnectOptions,
-  InternalRoomOptions,
-  RoomConnectOptions,
-  RoomOptions,
-} from '../options';
 import {
+  ConnectionQualityUpdate,
   DataPacket_Kind,
   DisconnectReason,
+  JoinResponse,
+  LeaveRequest,
   ParticipantInfo,
   ParticipantInfo_State,
   ParticipantPermission,
   Room as RoomModel,
   ServerInfo,
+  SimulateScenario,
   SpeakerInfo,
+  StreamStateUpdate,
   SubscriptionError,
+  SubscriptionPermissionUpdate,
+  SubscriptionResponse,
   TrackInfo,
   TrackSource,
   TrackType,
   UserPacket,
-} from '../proto/livekit_models_pb';
-import {
-  ConnectionQualityUpdate,
-  JoinResponse,
-  LeaveRequest,
-  SimulateScenario,
-  StreamStateUpdate,
-  SubscriptionPermissionUpdate,
-  SubscriptionResponse,
-} from '../proto/livekit_rtc_pb';
+  protoInt64,
+} from '@livekit/protocol';
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
+import 'webrtc-adapter';
+import { EncryptionEvent } from '../e2ee';
+import { E2EEManager } from '../e2ee/E2eeManager';
+import log, { LoggerNames, getLogger } from '../logger';
+import type {
+  InternalRoomConnectOptions,
+  InternalRoomOptions,
+  RoomConnectOptions,
+  RoomOptions,
+} from '../options';
 import { getBrowser } from '../utils/browserParser';
 import DeviceManager from './DeviceManager';
 import RTCEngine from './RTCEngine';
@@ -69,7 +67,9 @@ import {
   Mutex,
   createDummyVideoStreamTrack,
   getEmptyAudioStreamTrack,
+  isBrowserSupported,
   isCloud,
+  isReactNative,
   isWeb,
   supportsSetSinkId,
   toHttpUrl,
@@ -247,8 +247,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private get logContext() {
     return {
       room: this.name,
-      roomSid: this.roomInfo?.sid,
-      identity: this.localParticipant.identity,
+      roomID: this.roomInfo?.sid,
+      participant: this.localParticipant.identity,
+      pID: this.localParticipant.sid,
     };
   }
 
@@ -415,6 +416,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   connect = async (url: string, token: string, opts?: RoomConnectOptions): Promise<void> => {
+    if (!isBrowserSupported()) {
+      if (isReactNative()) {
+        throw Error("WebRTC isn't detected, have you called registerGlobals?");
+      } else {
+        throw Error(
+          "LiveKit doesn't seem to be supported on this browser. Try to update your browser and make sure no browser extensions are disabling webRTC.",
+        );
+      }
+    }
+
     // In case a disconnect called happened right before the connect call, make sure the disconnect is completed first by awaiting its lock
     const unlockDisconnect = await this.disconnectLock.lock();
 

package/src/room/participant/LocalParticipant.ts

@@ -1,18 +1,16 @@
-import type { InternalRoomOptions } from '../../options';
 import {
+  AddTrackRequest,
   DataPacket,
   DataPacket_Kind,
   Encryption_Type,
   ParticipantInfo,
   ParticipantPermission,
-  UserPacket,
-} from '../../proto/livekit_models_pb';
-import {
-  AddTrackRequest,
   SimulcastCodec,
   SubscribedQualityUpdate,
   TrackUnpublishedResponse,
-} from '../../proto/livekit_rtc_pb';
+  UserPacket,
+} from '@livekit/protocol';
+import type { InternalRoomOptions } from '../../options';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
 import { defaultVideoCodec } from '../defaults';

package/src/room/participant/Participant.ts

@@ -1,13 +1,13 @@
-import { EventEmitter } from 'events';
-import type TypedEmitter from 'typed-emitter';
-import log, { LoggerNames, StructuredLogger, getLogger } from '../../logger';
 import {
   DataPacket_Kind,
   ParticipantInfo,
   ParticipantPermission,
   ConnectionQuality as ProtoQuality,
   SubscriptionError,
-} from '../../proto/livekit_models_pb';
+} from '@livekit/protocol';
+import { EventEmitter } from 'events';
+import type TypedEmitter from 'typed-emitter';
+import log, { LoggerNames, StructuredLogger, getLogger } from '../../logger';
 import { ParticipantEvent, TrackEvent } from '../events';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
@@ -88,8 +88,6 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
   protected get logContext() {
     return {
       ...this.loggerOptions?.loggerContextCb?.(),
-      participantSid: this.sid,
-      participantId: this.identity,
     };
   }
 

package/src/room/participant/ParticipantTrackPermission.ts

@@ -1,4 +1,4 @@
-import { TrackPermission } from '../../proto/livekit_rtc_pb';
+import { TrackPermission } from '@livekit/protocol';
 
 export interface ParticipantTrackPermission {
   /**

package/src/room/participant/RemoteParticipant.ts

@@ -1,6 +1,10 @@
+import type {
+  ParticipantInfo,
+  SubscriptionError,
+  UpdateSubscription,
+  UpdateTrackSettings,
+} from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
-import type { ParticipantInfo, SubscriptionError } from '../../proto/livekit_models_pb';
-import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
 import { ParticipantEvent, TrackEvent } from '../events';
 import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import type RemoteTrack from '../track/RemoteTrack';
@@ -33,6 +37,14 @@ export default class RemoteParticipant extends Participant {
     return new RemoteParticipant(signalClient, pi.sid, pi.identity, pi.name, pi.metadata);
   }
 
+  protected get logContext() {
+    return {
+      ...super.logContext,
+      rpID: this.sid,
+      remoteParticipant: this.identity,
+    };
+  }
+
   /** @internal */
   constructor(
     signalClient: SignalClient,

package/src/room/track/LocalAudioTrack.ts

@@ -36,7 +36,10 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
   }
 
   async setDeviceId(deviceId: ConstrainDOMString): Promise<boolean> {
-    if (this._constraints.deviceId === deviceId) {
+    if (
+      this._constraints.deviceId === deviceId &&
+      this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)
+    ) {
       return true;
     }
     this._constraints.deviceId = deviceId;
@@ -44,7 +47,7 @@ export default class LocalAudioTrack extends LocalTrack<Track.Kind.Audio> {
       await this.restartTrack();
     }
     return (
-      this.isMuted || unwrapConstraint(deviceId) === this.mediaStreamTrack.getSettings().deviceId
+      this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId
     );
   }
 

package/src/room/track/LocalTrackPublication.ts

@@ -1,4 +1,4 @@
-import type { TrackInfo } from '../../proto/livekit_models_pb';
+import type { TrackInfo } from '@livekit/protocol';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
 import type LocalAudioTrack from './LocalAudioTrack';

package/src/room/track/LocalVideoTrack.ts

@@ -1,7 +1,11 @@
+import {
+  VideoQuality as ProtoVideoQuality,
+  SubscribedCodec,
+  SubscribedQuality,
+  VideoLayer,
+} from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import type { StructuredLogger } from '../../logger';
-import { VideoQuality as ProtoVideoQuality, VideoLayer } from '../../proto/livekit_models_pb';
-import { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc_pb';
 import { ScalabilityMode } from '../participant/publishUtils';
 import type { VideoSenderStats } from '../stats';
 import { computeBitrate, monitorFrequency } from '../stats';
@@ -424,7 +428,11 @@ async function setPublishingLayersForSender(
     }
 
     if (encodings.length !== senderEncodings.length) {
-      log.warn('cannot set publishing layers, encodings mismatch');
+      log.warn('cannot set publishing layers, encodings mismatch', {
+        ...logContext,
+        encodings,
+        senderEncodings,
+      });
       return;
     }
 

package/src/room/track/RemoteTrackPublication.ts

@@ -1,5 +1,10 @@
-import { ParticipantTracks, SubscriptionError, TrackInfo } from '../../proto/livekit_models_pb';
-import { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
+import {
+  ParticipantTracks,
+  SubscriptionError,
+  TrackInfo,
+  UpdateSubscription,
+  UpdateTrackSettings,
+} from '@livekit/protocol';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
 import type RemoteTrack from './RemoteTrack';

package/src/room/track/Track.ts

@@ -1,13 +1,13 @@
-import { EventEmitter } from 'events';
-import type TypedEventEmitter from 'typed-emitter';
-import type { SignalClient } from '../../api/SignalClient';
-import log, { LoggerNames, StructuredLogger, getLogger } from '../../logger';
 import {
   VideoQuality as ProtoQuality,
+  StreamState as ProtoStreamState,
   TrackSource,
   TrackType,
-} from '../../proto/livekit_models_pb';
-import { StreamState as ProtoStreamState } from '../../proto/livekit_rtc_pb';
+} from '@livekit/protocol';
+import { EventEmitter } from 'events';
+import type TypedEventEmitter from 'typed-emitter';
+import type { SignalClient } from '../../api/SignalClient';
+import log, { LoggerNames, StructuredLogger, getLogger } from '../../logger';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
 import { isFireFox, isSafari, isWeb } from '../utils';

package/src/room/track/TrackPublication.ts

@@ -1,9 +1,13 @@
+import { Encryption_Type } from '@livekit/protocol';
+import type {
+  SubscriptionError,
+  TrackInfo,
+  UpdateSubscription,
+  UpdateTrackSettings,
+} from '@livekit/protocol';
 import { EventEmitter } from 'events';
 import type TypedEventEmitter from 'typed-emitter';
 import log, { LoggerNames, getLogger } from '../../logger';
-import { Encryption_Type } from '../../proto/livekit_models_pb';
-import type { SubscriptionError, TrackInfo } from '../../proto/livekit_models_pb';
-import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc_pb';
 import { TrackEvent } from '../events';
 import type { LoggerOptions } from '../types';
 import LocalAudioTrack from './LocalAudioTrack';

package/src/room/track/facingMode.ts

@@ -47,7 +47,7 @@ export function facingModeFromLocalTrack(
   // 1. Try to get facingMode from track settings.
   if ('facingMode' in trackSettings) {
     const rawFacingMode = trackSettings.facingMode;
-    log.debug('rawFacingMode', { rawFacingMode });
+    log.trace('rawFacingMode', { rawFacingMode });
     if (rawFacingMode && typeof rawFacingMode === 'string' && isFacingModeValue(rawFacingMode)) {
       result = { facingMode: rawFacingMode, confidence: 'high' };
     }
@@ -55,7 +55,7 @@ export function facingModeFromLocalTrack(
 
   // 2. If we don't have a high confidence we try to get the facing mode from the device label.
   if (['low', 'medium'].includes(result.confidence)) {
-    log.debug(`Try to get facing mode from device label: (${track.label})`);
+    log.trace(`Try to get facing mode from device label: (${track.label})`);
     const labelAnalysisResult = facingModeFromDeviceLabel(track.label);
     if (labelAnalysisResult !== undefined) {
       result = labelAnalysisResult;

package/src/room/track/utils.ts

@@ -1,4 +1,4 @@
-import { TrackPublishedResponse } from '../../proto/livekit_rtc_pb';
+import { TrackPublishedResponse } from '@livekit/protocol';
 import { cloneDeep } from '../../utils/cloneDeep';
 import { isSafari, sleep } from '../utils';
 import { Track } from './Track';
@@ -214,20 +214,27 @@ export function getTrackPublicationInfo<T extends TrackPublication>(
 export function getLogContextFromTrack(track: Track | TrackPublication): Record<string, unknown> {
   if (track instanceof Track) {
     return {
-      trackSid: track.sid,
-      trackSource: track.source,
-      trackMuted: track.isMuted,
-      trackEnabled: track.mediaStreamTrack.enabled,
-      trackKind: track.kind,
+      trackID: track.sid,
+      source: track.source,
+      muted: track.isMuted,
+      enabled: track.mediaStreamTrack.enabled,
+      kind: track.kind,
+      streamID: track.mediaStreamID,
+      streamTrackID: track.mediaStreamTrack.id,
     };
   } else {
     return {
-      trackSid: track.trackSid,
-      trackName: track.trackName,
-      track: track.track ? getLogContextFromTrack(track.track) : undefined,
-      trackEnabled: track.isEnabled,
-      trackEncrypted: track.isEncrypted,
-      trackMimeType: track.mimeType,
+      trackID: track.trackSid,
+      enabled: track.isEnabled,
+      muted: track.isMuted,
+      trackInfo: {
+        mimeType: track.mimeType,
+        name: track.trackName,
+        encrypted: track.isEncrypted,
+        kind: track.kind,
+        source: track.source,
+        ...(track.track ? getLogContextFromTrack(track.track) : {}),
+      },
     };
   }
 }

package/src/room/utils.ts

@@ -1,4 +1,4 @@
-import { ClientInfo, ClientInfo_SDK } from '../proto/livekit_models_pb';
+import { ClientInfo, ClientInfo_SDK } from '@livekit/protocol';
 import type { DetectableBrowser } from '../utils/browserParser';
 import { getBrowser } from '../utils/browserParser';
 import { protocolVersion, version } from '../version';
@@ -133,6 +133,9 @@ export function supportsSetCodecPreferences(transceiver: RTCRtpTransceiver): boo
 }
 
 export function isBrowserSupported() {
+  if (typeof RTCPeerConnection === 'undefined') {
+    return false;
+  }
   return supportsTransceiver() || supportsAddTrack();
 }