livekit-client 0.18.4 → 1.0.0

package/src/room/participant/publishUtils.ts

@@ -75,9 +75,10 @@ export function computeVideoEncodings(
     videoEncoding = options?.screenShareEncoding;
   }
   const useSimulcast = options?.simulcast;
+  const scalabilityMode = options?.scalabilityMode;
 
-  if ((!videoEncoding && !useSimulcast) || !width || !height) {
-    // when we aren't simulcasting, will need to return a single encoding without
+  if ((!videoEncoding && !useSimulcast && !scalabilityMode) || !width || !height) {
+    // when we aren't simulcasting or svc, will need to return a single encoding without
     // capping bandwidth. we always require a encoding for dynacast
     return [{}];
   }
@@ -88,15 +89,43 @@ export function computeVideoEncodings(
     log.debug('using video encoding', videoEncoding);
   }
 
-  if (!useSimulcast) {
-    return [videoEncoding];
-  }
   const original = new VideoPreset(
     width,
     height,
     videoEncoding.maxBitrate,
     videoEncoding.maxFramerate,
   );
+
+  log.debug(`scalabilityMode ${scalabilityMode}`);
+  if (scalabilityMode) {
+    const encodings: RTCRtpEncodingParameters[] = [];
+    // svc use first encoding as the original, so we sort encoding from high to low
+    switch (scalabilityMode) {
+      case 'L3T3':
+        for (let i = 0; i < 3; i += 1) {
+          encodings.push({
+            rid: videoRids[2 - i],
+            scaleResolutionDownBy: 2 ** i,
+            maxBitrate: videoEncoding ? videoEncoding.maxBitrate / 2 ** i : 0,
+            /* @ts-ignore */
+            maxFramerate: original.encoding.maxFramerate,
+            /* @ts-ignore */
+            scalabilityMode: 'L3T3',
+          });
+        }
+        log.debug('encodings', encodings);
+        return encodings;
+
+      default:
+        // TODO : support other scalability modes
+        throw new Error(`unsupported scalabilityMode: ${scalabilityMode}`);
+    }
+  }
+
+  if (!useSimulcast) {
+    return [videoEncoding];
+  }
+
   let presets: Array<VideoPreset> = [];
   if (isScreenShare) {
     presets =

package/src/room/track/LocalAudioTrack.ts

@@ -34,7 +34,7 @@ export default class LocalAudioTrack extends LocalTrack {
     if (this.source === Track.Source.Microphone && this.stopOnMute) {
       log.debug('stopping mic track');
       // also stop the track, so that microphone indicator is turned off
-      this.mediaStreamTrack.stop();
+      this._mediaStreamTrack.stop();
     }
     await super.mute();
     return this;
@@ -83,7 +83,7 @@ export default class LocalAudioTrack extends LocalTrack {
     try {
       stats = await this.getSenderStats();
     } catch (e) {
-      log.error('could not get audio sender stats', e);
+      log.error('could not get audio sender stats', { error: e });
       return;
     }
 

package/src/room/track/LocalTrack.ts

@@ -21,14 +21,14 @@ export default class LocalTrack extends Track {
     constraints?: MediaTrackConstraints,
   ) {
     super(mediaTrack, kind);
-    this.mediaStreamTrack.addEventListener('ended', this.handleEnded);
+    this._mediaStreamTrack.addEventListener('ended', this.handleEnded);
     this.constraints = constraints ?? mediaTrack.getConstraints();
     this.reacquireTrack = false;
     this.wasMuted = false;
   }
 
   get id(): string {
-    return this.mediaStreamTrack.id;
+    return this._mediaStreamTrack.id;
   }
 
   get dimensions(): Track.Dimensions | undefined {
@@ -36,7 +36,7 @@ export default class LocalTrack extends Track {
       return undefined;
     }
 
-    const { width, height } = this.mediaStreamTrack.getSettings();
+    const { width, height } = this._mediaStreamTrack.getSettings();
     if (width && height) {
       return {
         width,
@@ -60,7 +60,7 @@ export default class LocalTrack extends Track {
     if (this.source === Track.Source.ScreenShare) {
       return;
     }
-    const { deviceId, groupId } = this.mediaStreamTrack.getSettings();
+    const { deviceId, groupId } = this._mediaStreamTrack.getSettings();
     const kind = this.kind === Track.Kind.Audio ? 'audioinput' : 'videoinput';
 
     return DeviceManager.getInstance().normalizeDeviceId(kind, deviceId, groupId);
@@ -83,19 +83,19 @@ export default class LocalTrack extends Track {
 
     // detach
     this.attachedElements.forEach((el) => {
-      detachTrack(this.mediaStreamTrack, el);
+      detachTrack(this._mediaStreamTrack, el);
     });
-    this.mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
     // on Safari, the old audio track must be stopped before attempting to acquire
     // the new track, otherwise the new track will stop with
     // 'A MediaStreamTrack ended due to a capture failure`
-    this.mediaStreamTrack.stop();
+    this._mediaStreamTrack.stop();
 
     track.addEventListener('ended', this.handleEnded);
     log.debug('replace MediaStreamTrack');
 
     await this.sender.replaceTrack(track);
-    this.mediaStreamTrack = track;
+    this._mediaStreamTrack = track;
 
     this.attachedElements.forEach((el) => {
       attachToElement(track, el);
@@ -127,13 +127,13 @@ export default class LocalTrack extends Track {
 
     // detach
     this.attachedElements.forEach((el) => {
-      detachTrack(this.mediaStreamTrack, el);
+      detachTrack(this._mediaStreamTrack, el);
     });
-    this.mediaStreamTrack.removeEventListener('ended', this.handleEnded);
+    this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
     // on Safari, the old audio track must be stopped before attempting to acquire
     // the new track, otherwise the new track will stop with
     // 'A MediaStreamTrack ended due to a capture failure`
-    this.mediaStreamTrack.stop();
+    this._mediaStreamTrack.stop();
 
     // create new track and attach
     const mediaStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
@@ -142,7 +142,7 @@ export default class LocalTrack extends Track {
     log.debug('re-acquired MediaStreamTrack');
 
     await this.sender.replaceTrack(newTrack);
-    this.mediaStreamTrack = newTrack;
+    this._mediaStreamTrack = newTrack;
 
     this.attachedElements.forEach((el) => {
       attachToElement(newTrack, el);
@@ -159,15 +159,15 @@ export default class LocalTrack extends Track {
     }
 
     this.isMuted = muted;
-    this.mediaStreamTrack.enabled = !muted;
+    this._mediaStreamTrack.enabled = !muted;
     this.emit(muted ? TrackEvent.Muted : TrackEvent.Unmuted, this);
   }
 
   protected get needsReAcquisition(): boolean {
     return (
-      this.mediaStreamTrack.readyState !== 'live' ||
-      this.mediaStreamTrack.muted ||
-      !this.mediaStreamTrack.enabled ||
+      this._mediaStreamTrack.readyState !== 'live' ||
+      this._mediaStreamTrack.muted ||
+      !this._mediaStreamTrack.enabled ||
       this.reacquireTrack
     );
   }
@@ -224,6 +224,6 @@ export default class LocalTrack extends Track {
     this._isUpstreamPaused = false;
     this.emit(TrackEvent.UpstreamResumed, this);
 
-    await this.sender.replaceTrack(this.mediaStreamTrack);
+    await this.sender.replaceTrack(this._mediaStreamTrack);
   }
 }

package/src/room/track/LocalVideoTrack.ts

@@ -44,7 +44,7 @@ export default class LocalVideoTrack extends LocalTrack {
 
   stop() {
     this.sender = undefined;
-    this.mediaStreamTrack.getConstraints();
+    this._mediaStreamTrack.getConstraints();
     super.stop();
   }
 
@@ -52,7 +52,7 @@ export default class LocalVideoTrack extends LocalTrack {
     if (this.source === Track.Source.Camera) {
       log.debug('stopping camera track');
       // also stop the track, so that camera indicator is turned off
-      this.mediaStreamTrack.stop();
+      this._mediaStreamTrack.stop();
     }
     await super.mute();
     return this;
@@ -243,7 +243,7 @@ export default class LocalVideoTrack extends LocalTrack {
     await super.handleAppVisibilityChanged();
     if (!isMobile()) return;
     if (this.isInBackground && this.source === Track.Source.Camera) {
-      this.mediaStreamTrack.enabled = false;
+      this._mediaStreamTrack.enabled = false;
     }
   }
 }

package/src/room/track/RemoteVideoTrack.ts

@@ -10,6 +10,7 @@ import {
 import RemoteTrack from './RemoteTrack';
 import { attachToElement, detachTrack, Track } from './Track';
 import { AdaptiveStreamSettings } from './types';
+import log from '../../logger';
 
 const REACTION_DELAY = 100;
 
@@ -27,6 +28,8 @@ export default class RemoteVideoTrack extends RemoteTrack {
 
   private lastDimensions?: Track.Dimensions;
 
+  private hasUsedAttach: boolean = false;
+
   constructor(
     mediaTrack: MediaStreamTrack,
     sid: string,
@@ -44,6 +47,15 @@ export default class RemoteVideoTrack extends RemoteTrack {
     return this.adaptiveStreamSettings !== undefined;
   }
 
+  get mediaStreamTrack() {
+    if (this.isAdaptiveStream && !this.hasUsedAttach) {
+      log.warn(
+        'When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start',
+      );
+    }
+    return this._mediaStreamTrack;
+  }
+
   /** @internal */
   setMuted(muted: boolean) {
     super.setMuted(muted);
@@ -51,9 +63,9 @@ export default class RemoteVideoTrack extends RemoteTrack {
     this.attachedElements.forEach((element) => {
       // detach or attach
       if (muted) {
-        detachTrack(this.mediaStreamTrack, element);
+        detachTrack(this._mediaStreamTrack, element);
       } else {
-        attachToElement(this.mediaStreamTrack, element);
+        attachToElement(this._mediaStreamTrack, element);
       }
     });
   }
@@ -89,6 +101,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
       // the tab comes into focus for the first time.
       this.debouncedHandleResize();
     }
+    this.hasUsedAttach = true;
     return element;
   }
 

package/src/room/track/Track.ts

@@ -12,29 +12,32 @@ const recycledElements: Array<HTMLAudioElement> = [];
 export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEventCallbacks>) {
   kind: Track.Kind;
 
-  mediaStream?: MediaStream;
-
-  mediaStreamTrack: MediaStreamTrack;
-
   attachedElements: HTMLMediaElement[] = [];
 
   isMuted: boolean = false;
 
   source: Track.Source;
 
-  protected isInBackground: boolean;
-
   /**
    * sid is set after track is published to server, or if it's a remote track
    */
   sid?: Track.SID;
 
+  /**
+   * @internal
+   */
+  mediaStream?: MediaStream;
+
+  protected _mediaStreamTrack: MediaStreamTrack;
+
+  protected isInBackground: boolean;
+
   protected _currentBitrate: number = 0;
 
   protected constructor(mediaTrack: MediaStreamTrack, kind: Track.Kind) {
     super();
     this.kind = kind;
-    this.mediaStreamTrack = mediaTrack;
+    this._mediaStreamTrack = mediaTrack;
     this.source = Track.Source.Unknown;
     if (isWeb()) {
       this.isInBackground = document.visibilityState === 'hidden';
@@ -49,6 +52,10 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
     return this._currentBitrate;
   }
 
+  get mediaStreamTrack() {
+    return this._mediaStreamTrack;
+  }
+
   /**
    * creates a new HTMLAudioElement or HTMLVideoElement, attaches to it, and returns it
    */
@@ -87,7 +94,7 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
     // even if we believe it's already attached to the element, it's possible
     // the element's srcObject was set to something else out of band.
     // we'll want to re-attach it in that case
-    attachToElement(this.mediaStreamTrack, element);
+    attachToElement(this._mediaStreamTrack, element);
 
     if (element instanceof HTMLAudioElement) {
       // manually play audio to detect audio playback status
@@ -118,7 +125,7 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
   detach(element?: HTMLMediaElement): HTMLMediaElement | HTMLMediaElement[] {
     // detach from a single element
     if (element) {
-      detachTrack(this.mediaStreamTrack, element);
+      detachTrack(this._mediaStreamTrack, element);
       const idx = this.attachedElements.indexOf(element);
       if (idx >= 0) {
         this.attachedElements.splice(idx, 1);
@@ -130,7 +137,7 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
 
     const detached: HTMLMediaElement[] = [];
     this.attachedElements.forEach((elm) => {
-      detachTrack(this.mediaStreamTrack, elm);
+      detachTrack(this._mediaStreamTrack, elm);
       detached.push(elm);
       this.recycleElement(elm);
       this.emit(TrackEvent.ElementDetached, elm);
@@ -142,18 +149,18 @@ export class Track extends (EventEmitter as new () => TypedEventEmitter<TrackEve
   }
 
   stop() {
-    this.mediaStreamTrack.stop();
+    this._mediaStreamTrack.stop();
     if (isWeb()) {
       document.removeEventListener('visibilitychange', this.appVisibilityChangedListener);
     }
   }
 
   protected enable() {
-    this.mediaStreamTrack.enabled = true;
+    this._mediaStreamTrack.enabled = true;
   }
 
   protected disable() {
-    this.mediaStreamTrack.enabled = false;
+    this._mediaStreamTrack.enabled = false;
   }
 
   private recycleElement(element: HTMLMediaElement) {

package/src/room/track/create.ts

@@ -89,7 +89,7 @@ export async function createLocalScreenTracks(
     options = {};
   }
   if (options.resolution === undefined) {
-    options.resolution = VideoPresets.fhd.resolution;
+    options.resolution = VideoPresets.h1080.resolution;
   }
 
   let videoConstraints: MediaTrackConstraints | boolean = true;

package/src/room/track/defaults.ts

@@ -17,11 +17,10 @@ export const publishDefaults: TrackPublishDefaults = {
 
 export const audioDefaults: AudioCaptureOptions = {
   autoGainControl: true,
-  channelCount: 1,
   echoCancellation: true,
   noiseSuppression: true,
 };
 
 export const videoDefaults: VideoCaptureOptions = {
-  resolution: VideoPresets.h540.resolution,
+  resolution: VideoPresets.h720.resolution,
 };

package/src/room/track/options.ts

@@ -33,6 +33,12 @@ export interface TrackPublishDefaults {
    */
   simulcast?: boolean;
 
+  /**
+   * scalability mode for svc codecs, defaults to 'L3T3'.
+   * for svc codecs, simulcast is disabled.
+   */
+  scalabilityMode?: ScalabilityMode;
+
   /**
    * custom video simulcast layers for camera tracks, defaults to h180, h360, h540
    * You can specify up to two custom layers that will be used instead of
@@ -200,6 +206,11 @@ export interface AudioPreset {
 
 export type VideoCodec = 'vp8' | 'h264' | 'av1' | 'vp9';
 
+/**
+ * scalability modes for svc, only supprot l3t3 now.
+ */
+export type ScalabilityMode = 'L3T3';
+
 export namespace AudioPresets {
   export const telephone: AudioPreset = {
     maxBitrate: 12_000,
@@ -221,20 +232,10 @@ export const VideoPresets = {
   h216: new VideoPreset(384, 216, 180_000, 15),
   h360: new VideoPreset(640, 360, 300_000, 20),
   h540: new VideoPreset(960, 540, 600_000, 25),
-  h720: new VideoPreset(1280, 720, 2_000_000, 30),
+  h720: new VideoPreset(1280, 720, 1_700_000, 30),
   h1080: new VideoPreset(1920, 1080, 3_000_000, 30),
   h1440: new VideoPreset(2560, 1440, 5_000_000, 30),
   h2160: new VideoPreset(3840, 2160, 8_000_000, 30),
-  /** @deprecated */
-  qvga: new VideoPreset(320, 180, 120_000, 10),
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 300_000, 20),
-  /** @deprecated */
-  qhd: new VideoPreset(960, 540, 600_000, 25),
-  /** @deprecated */
-  hd: new VideoPreset(1280, 720, 2_000_000, 30),
-  /** @deprecated */
-  fhd: new VideoPreset(1920, 1080, 3_000_000, 30),
 } as const;
 
 /**
@@ -250,16 +251,6 @@ export const VideoPresets43 = {
   h720: new VideoPreset(960, 720, 1_500_000, 30),
   h1080: new VideoPreset(1440, 1080, 2_500_000, 30),
   h1440: new VideoPreset(1920, 1440, 3_500_000, 30),
-  /** @deprecated */
-  qvga: new VideoPreset(240, 180, 90_000, 10),
-  /** @deprecated */
-  vga: new VideoPreset(480, 360, 225_000, 20),
-  /** @deprecated */
-  qhd: new VideoPreset(720, 540, 450_000, 25),
-  /** @deprecated */
-  hd: new VideoPreset(960, 720, 1_500_000, 30),
-  /** @deprecated */
-  fhd: new VideoPreset(1440, 1080, 2_800_000, 30),
 } as const;
 
 export const ScreenSharePresets = {
@@ -268,14 +259,4 @@ export const ScreenSharePresets = {
   h720fps15: new VideoPreset(1280, 720, 1_000_000, 15),
   h1080fps15: new VideoPreset(1920, 1080, 1_500_000, 15),
   h1080fps30: new VideoPreset(1920, 1080, 3_000_000, 30),
-  /** @deprecated */
-  vga: new VideoPreset(640, 360, 200_000, 3),
-  /** @deprecated */
-  hd_8: new VideoPreset(1280, 720, 400_000, 5),
-  /** @deprecated */
-  hd_15: new VideoPreset(1280, 720, 1_000_000, 15),
-  /** @deprecated */
-  fhd_15: new VideoPreset(1920, 1080, 1_500_000, 15),
-  /** @deprecated */
-  fhd_30: new VideoPreset(1920, 1080, 3_000_000, 30),
 } as const;

package/src/room/track/utils.test.ts

@@ -8,7 +8,7 @@ describe('mergeDefaultOptions', () => {
   };
   const videoDefaults: VideoCaptureOptions = {
     deviceId: 'video123',
-    resolution: VideoPresets.fhd.resolution,
+    resolution: VideoPresets.h1080.resolution,
   };
 
   it('does not enable undefined options', () => {
@@ -88,7 +88,7 @@ describe('constraintsForOptions', () => {
   it('converts video options correctly', () => {
     const constraints = constraintsForOptions({
       video: {
-        resolution: VideoPresets.hd.resolution,
+        resolution: VideoPresets.h720.resolution,
         facingMode: 'user',
         deviceId: 'video123',
       },
@@ -102,9 +102,9 @@ describe('constraintsForOptions', () => {
       'facingMode',
       'deviceId',
     ]);
-    expect(videoOpts.width).toEqual(VideoPresets.hd.resolution.width);
-    expect(videoOpts.height).toEqual(VideoPresets.hd.resolution.height);
-    expect(videoOpts.frameRate).toEqual(VideoPresets.hd.resolution.frameRate);
-    expect(videoOpts.aspectRatio).toEqual(VideoPresets.hd.resolution.aspectRatio);
+    expect(videoOpts.width).toEqual(VideoPresets.h720.resolution.width);
+    expect(videoOpts.height).toEqual(VideoPresets.h720.resolution.height);
+    expect(videoOpts.frameRate).toEqual(VideoPresets.h720.resolution.frameRate);
+    expect(videoOpts.aspectRatio).toEqual(VideoPresets.h720.resolution.aspectRatio);
   });
 });

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.18.4';
+export const version = '1.0.0';
 export const protocolVersion = 7;

package/dist/connect.d.ts

@@ -1,24 +0,0 @@
-import { ConnectOptions } from './options';
-import Room from './room/Room';
-export { version } from './version';
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
- */
-export declare function connect(url: string, token: string, options?: ConnectOptions): Promise<Room>;
-//# sourceMappingURL=connect.d.ts.map

package/dist/connect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C,OAAO,IAAI,MAAM,aAAa,CAAC;AAE/B,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAsEjG"}

package/src/connect.ts

@@ -1,98 +0,0 @@
-import log, { LogLevel, setLogLevel } from './logger';
-import { ConnectOptions } from './options';
-import { MediaDeviceFailure } from './room/errors';
-import { RoomEvent } from './room/events';
-import Room from './room/Room';
-
-export { version } from './version';
-
-/**
- * @deprecated Use room.connect() instead
- *
- * Connects to a LiveKit room, shorthand for `new Room()` and [[Room.connect]]
- *
- * ```typescript
- * connect('wss://myhost.livekit.io', token, {
- *   // publish audio and video tracks on joining
- *   audio: true,
- *   video: true,
- *   captureDefaults: {
- *    facingMode: 'user',
- *   },
- * })
- * ```
- * @param url URL to LiveKit server
- * @param token AccessToken, a JWT token that includes authentication and room details
- * @param options
- */
-export async function connect(url: string, token: string, options?: ConnectOptions): Promise<Room> {
-  options ??= {};
-  if (options.adaptiveStream === undefined) {
-    options.adaptiveStream = options.autoManageVideo === true ? {} : undefined;
-  }
-  setLogLevel(options.logLevel ?? LogLevel.warn);
-
-  const config: RTCConfiguration = options.rtcConfig ?? {};
-  if (options.iceServers) {
-    config.iceServers = options.iceServers;
-  }
-
-  const room = new Room(options);
-
-  // connect to room
-  await room.connect(url, token, options);
-
-  const publishAudio: boolean = options.audio ?? false;
-  const publishVideo: boolean = options.video ?? false;
-
-  if (publishAudio || publishVideo) {
-    setTimeout(async () => {
-      // if publishing both
-      let err: any;
-      if (publishAudio && publishVideo) {
-        try {
-          await room.localParticipant.enableCameraAndMicrophone();
-        } catch (e) {
-          const errKind = MediaDeviceFailure.getFailure(e);
-          log.warn('received error while creating media', { error: errKind });
-          if (e instanceof Error) {
-            log.warn(e.message);
-          }
-
-          // when it's a device issue, try to publish the other kind
-          if (
-            errKind === MediaDeviceFailure.NotFound ||
-            errKind === MediaDeviceFailure.DeviceInUse
-          ) {
-            try {
-              await room.localParticipant.setMicrophoneEnabled(true);
-            } catch (audioErr) {
-              err = audioErr;
-            }
-          } else {
-            err = e;
-          }
-        }
-      } else if (publishAudio) {
-        try {
-          await room.localParticipant.setMicrophoneEnabled(true);
-        } catch (e) {
-          err = e;
-        }
-      } else if (publishVideo) {
-        try {
-          await room.localParticipant.setCameraEnabled(true);
-        } catch (e) {
-          err = e;
-        }
-      }
-
-      if (err) {
-        room.emit(RoomEvent.MediaDevicesError, err);
-        log.error('could not create media', err);
-      }
-    });
-  }
-
-  return room;
-}