@stream-io/video-client 0.3.28 → 0.3.30

package/dist/index.cjs.js

@@ -6219,7 +6219,8 @@ const withSimulcastConstraints = (settings, optimalVideoLayers) => {
     const ridMapping = ['q', 'h', 'f'];
     return layers.map((layer, index) => (Object.assign(Object.assign({}, layer), { rid: ridMapping[index] })));
 };
-const findOptimalScreenSharingLayers = (videoTrack) => {
+const findOptimalScreenSharingLayers = (videoTrack, preferences) => {
+    var _a, _b;
     const settings = videoTrack.getSettings();
     return [
         {
@@ -6227,9 +6228,9 @@ const findOptimalScreenSharingLayers = (videoTrack) => {
             rid: 'q',
             width: settings.width || 0,
             height: settings.height || 0,
-            maxBitrate: 3000000,
             scaleResolutionDownBy: 1,
-            maxFramerate: 30,
+            maxBitrate: (_a = preferences === null || preferences === void 0 ? void 0 : preferences.maxBitrate) !== null && _a !== void 0 ? _a : 3000000,
+            maxFramerate: (_b = preferences === null || preferences === void 0 ? void 0 : preferences.maxFramerate) !== null && _b !== void 0 ? _b : 30,
         },
     ];
 };
@@ -6238,12 +6239,17 @@ const trackTypeToParticipantStreamKey = (trackType) => {
     switch (trackType) {
         case TrackType.SCREEN_SHARE:
             return 'screenShareStream';
+        case TrackType.SCREEN_SHARE_AUDIO:
+            return 'screenShareAudioStream';
         case TrackType.VIDEO:
             return 'videoStream';
         case TrackType.AUDIO:
             return 'audioStream';
+        case TrackType.UNSPECIFIED:
+            throw new Error('Track type is unspecified');
         default:
-            throw new Error(`Unknown track type: ${trackType}`);
+            const exhaustiveTrackTypeCheck = trackType;
+            throw new Error(`Unknown track type: ${exhaustiveTrackTypeCheck}`);
     }
 };
 const trackTypeToDeviceIdKey = (trackType) => {
@@ -6253,9 +6259,12 @@ const trackTypeToDeviceIdKey = (trackType) => {
         case TrackType.VIDEO:
             return 'videoDeviceId';
         case TrackType.SCREEN_SHARE:
+        case TrackType.SCREEN_SHARE_AUDIO:
+        case TrackType.UNSPECIFIED:
             return undefined;
         default:
-            throw new Error(`Unknown track type: ${trackType}`);
+            const exhaustiveTrackTypeCheck = trackType;
+            throw new Error(`Unknown track type: ${exhaustiveTrackTypeCheck}`);
     }
 };
 const muteTypeToTrackType = (muteType) => {
@@ -6266,8 +6275,11 @@ const muteTypeToTrackType = (muteType) => {
             return TrackType.VIDEO;
         case 'screenshare':
             return TrackType.SCREEN_SHARE;
+        case 'screenshare_audio':
+            return TrackType.SCREEN_SHARE_AUDIO;
         default:
-            throw new Error(`Unknown mute type: ${muteType}`);
+            const exhaustiveMuteTypeCheck = muteType;
+            throw new Error(`Unknown mute type: ${exhaustiveMuteTypeCheck}`);
     }
 };
 
@@ -6383,6 +6395,41 @@ const toggleDtx = (sdp, enable) => {
     }
     return sdp;
 };
+/**
+ * Enables high-quality audio through SDP munging for the given trackMid.
+ *
+ * @param sdp the SDP to munge.
+ * @param trackMid the trackMid.
+ * @param maxBitrate the max bitrate to set.
+ */
+const enableHighQualityAudio = (sdp, trackMid, maxBitrate = 510000) => {
+    maxBitrate = Math.max(Math.min(maxBitrate, 510000), 96000);
+    const parsedSdp = SDP__namespace.parse(sdp);
+    const audioMedia = parsedSdp.media.find((m) => m.type === 'audio' && String(m.mid) === trackMid);
+    if (!audioMedia)
+        return sdp;
+    const opusRtp = audioMedia.rtp.find((r) => r.codec === 'opus');
+    if (!opusRtp)
+        return sdp;
+    const opusFmtp = audioMedia.fmtp.find((f) => f.payload === opusRtp.payload);
+    if (!opusFmtp)
+        return sdp;
+    // enable stereo, if not already enabled
+    if (opusFmtp.config.match(/stereo=(\d)/)) {
+        opusFmtp.config = opusFmtp.config.replace(/stereo=(\d)/, 'stereo=1');
+    }
+    else {
+        opusFmtp.config = `${opusFmtp.config};stereo=1`;
+    }
+    // set maxaveragebitrate, to the given value
+    if (opusFmtp.config.match(/maxaveragebitrate=(\d*)/)) {
+        opusFmtp.config = opusFmtp.config.replace(/maxaveragebitrate=(\d*)/, `maxaveragebitrate=${maxBitrate}`);
+    }
+    else {
+        opusFmtp.config = `${opusFmtp.config};maxaveragebitrate=${maxBitrate}`;
+    }
+    return SDP__namespace.write(parsedSdp);
+};
 
 const logger$3 = getLogger(['Publisher']);
 /**
@@ -6409,6 +6456,7 @@ class Publisher {
             [TrackType.SCREEN_SHARE_AUDIO]: undefined,
             [TrackType.UNSPECIFIED]: undefined,
         };
+        this.publishOptionsPerTrackType = new Map();
         /**
          * An array maintaining the order how transceivers were added to the peer connection.
          * This is needed because some browsers (Firefox) don't reliably report
@@ -6421,7 +6469,7 @@ class Publisher {
             [TrackType.AUDIO]: 'audio',
             [TrackType.VIDEO]: 'video',
             [TrackType.SCREEN_SHARE]: 'video',
-            [TrackType.SCREEN_SHARE_AUDIO]: undefined,
+            [TrackType.SCREEN_SHARE_AUDIO]: 'audio',
             [TrackType.UNSPECIFIED]: undefined,
         };
         this.trackLayersCache = {
@@ -6466,10 +6514,11 @@ class Publisher {
          *
          * Consecutive calls to this method will replace the stream.
          * The previous stream will be stopped.
-         * @param mediaStream
-         * @param track
-         * @param trackType
-         * @param opts
+         *
+         * @param mediaStream the media stream to publish.
+         * @param track the track to publish.
+         * @param trackType the track type to publish.
+         * @param opts the optional publish options to use.
          */
         this.publishStream = (mediaStream, track, trackType, opts = {}) => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -6499,7 +6548,9 @@ class Publisher {
                 const targetResolution = settings === null || settings === void 0 ? void 0 : settings.video.target_resolution;
                 const videoEncodings = trackType === TrackType.VIDEO
                     ? findOptimalVideoLayers(track, targetResolution)
-                    : undefined;
+                    : trackType === TrackType.SCREEN_SHARE
+                        ? findOptimalScreenSharingLayers(track, opts.screenShareSettings)
+                        : undefined;
                 let preferredCodec = opts.preferredCodec;
                 if (!preferredCodec && trackType === TrackType.VIDEO) {
                     const isRNAndroid = isReactNative() && ((_a = getOSInfo()) === null || _a === void 0 ? void 0 : _a.name.toLowerCase()) === 'android';
@@ -6525,6 +6576,7 @@ class Publisher {
                 logger$3('debug', `Added ${TrackType[trackType]} transceiver`);
                 this.transceiverInitOrder.push(trackType);
                 this.transceiverRegistry[trackType] = transceiver;
+                this.publishOptionsPerTrackType.set(trackType, opts);
                 if ('setCodecPreferences' in transceiver && codecPreferences) {
                     logger$3('info', `Setting ${TrackType[trackType]} codec preferences`, codecPreferences);
                     transceiver.setCodecPreferences(codecPreferences);
@@ -6734,10 +6786,19 @@ class Publisher {
          * @param options the optional offer options to use.
          */
         this.negotiate = (options) => __awaiter(this, void 0, void 0, function* () {
-            var _d;
+            var _d, _e;
             this.isIceRestarting = (_d = options === null || options === void 0 ? void 0 : options.iceRestart) !== null && _d !== void 0 ? _d : false;
             const offer = yield this.pc.createOffer(options);
-            offer.sdp = this.mungeCodecs(offer.sdp);
+            let sdp = this.mungeCodecs(offer.sdp);
+            if (sdp && this.isPublishing(TrackType.SCREEN_SHARE_AUDIO)) {
+                const transceiver = this.transceiverRegistry[TrackType.SCREEN_SHARE_AUDIO];
+                if (transceiver && transceiver.sender.track) {
+                    const mid = (_e = transceiver.mid) !== null && _e !== void 0 ? _e : this.extractMid(sdp, transceiver.sender.track, TrackType.SCREEN_SHARE_AUDIO);
+                    sdp = enableHighQualityAudio(sdp, mid);
+                }
+            }
+            // set the munged SDP back to the offer
+            offer.sdp = sdp;
             const trackInfos = this.getCurrentTrackInfos(offer.sdp);
             if (trackInfos.length === 0) {
                 throw new Error(`Can't initiate negotiation without announcing any tracks`);
@@ -6776,50 +6837,50 @@ class Publisher {
             }
             return sdp;
         };
+        this.extractMid = (sdp, track, trackType) => {
+            if (!sdp) {
+                logger$3('warn', 'No SDP found. Returning empty mid');
+                return '';
+            }
+            logger$3('debug', `No 'mid' found for track. Trying to find it from the Offer SDP`);
+            const parsedSdp = SDP__namespace.parse(sdp);
+            const media = parsedSdp.media.find((m) => {
+                var _a, _b;
+                return (m.type === track.kind &&
+                    // if `msid` is not present, we assume that the track is the first one
+                    ((_b = (_a = m.msid) === null || _a === void 0 ? void 0 : _a.includes(track.id)) !== null && _b !== void 0 ? _b : true));
+            });
+            if (typeof (media === null || media === void 0 ? void 0 : media.mid) === 'undefined') {
+                logger$3('debug', `No mid found in SDP for track type ${track.kind} and id ${track.id}. Attempting to find a heuristic mid`);
+                const heuristicMid = this.transceiverInitOrder.indexOf(trackType);
+                if (heuristicMid !== -1) {
+                    return String(heuristicMid);
+                }
+                logger$3('debug', 'No heuristic mid found. Returning empty mid');
+                return '';
+            }
+            return String(media.mid);
+        };
         this.getCurrentTrackInfos = (sdp) => {
             var _a;
             sdp = sdp || ((_a = this.pc.localDescription) === null || _a === void 0 ? void 0 : _a.sdp);
-            const extractMid = (defaultMid, track, trackType) => {
-                if (defaultMid)
-                    return defaultMid;
-                if (!sdp) {
-                    logger$3('warn', 'No SDP found. Returning empty mid');
-                    return '';
-                }
-                logger$3('debug', `No 'mid' found for track. Trying to find it from the Offer SDP`);
-                const parsedSdp = SDP__namespace.parse(sdp);
-                const media = parsedSdp.media.find((m) => {
-                    var _a, _b;
-                    return (m.type === track.kind &&
-                        // if `msid` is not present, we assume that the track is the first one
-                        ((_b = (_a = m.msid) === null || _a === void 0 ? void 0 : _a.includes(track.id)) !== null && _b !== void 0 ? _b : true));
-                });
-                if (typeof (media === null || media === void 0 ? void 0 : media.mid) === 'undefined') {
-                    logger$3('debug', `No mid found in SDP for track type ${track.kind} and id ${track.id}. Attempting to find a heuristic mid`);
-                    const heuristicMid = this.transceiverInitOrder.indexOf(trackType);
-                    if (heuristicMid !== -1) {
-                        return String(heuristicMid);
-                    }
-                    logger$3('debug', 'No heuristic mid found. Returning empty mid');
-                    return '';
-                }
-                return String(media.mid);
-            };
             const { settings } = this.state;
             const targetResolution = settings === null || settings === void 0 ? void 0 : settings.video.target_resolution;
             return this.pc
                 .getTransceivers()
                 .filter((t) => t.direction === 'sendonly' && t.sender.track)
                 .map((transceiver) => {
+                var _a;
                 const trackType = Number(Object.keys(this.transceiverRegistry).find((key) => this.transceiverRegistry[key] === transceiver));
                 const track = transceiver.sender.track;
                 let optimalLayers;
                 if (track.readyState === 'live') {
+                    const publishOpts = this.publishOptionsPerTrackType.get(trackType);
                     optimalLayers =
                         trackType === TrackType.VIDEO
                             ? findOptimalVideoLayers(track, targetResolution)
                             : trackType === TrackType.SCREEN_SHARE
-                                ? findOptimalScreenSharingLayers(track)
+                                ? findOptimalScreenSharingLayers(track, publishOpts === null || publishOpts === void 0 ? void 0 : publishOpts.screenShareSettings)
                                 : [];
                     this.trackLayersCache[trackType] = optimalLayers;
                 }
@@ -6838,15 +6899,21 @@ class Publisher {
                         height: optimalLayer.height,
                     },
                 }));
+                const isAudioTrack = [
+                    TrackType.AUDIO,
+                    TrackType.SCREEN_SHARE_AUDIO,
+                ].includes(trackType);
+                const trackSettings = track.getSettings();
+                // @ts-expect-error - `channelCount` is not defined on `MediaTrackSettings`
+                const isStereo = isAudioTrack && trackSettings.channelCount === 2;
                 return {
                     trackId: track.id,
                     layers: layers,
                     trackType,
-                    mid: extractMid(transceiver.mid, track, trackType),
-                    // FIXME OL: adjust these values
-                    stereo: false,
-                    dtx: TrackType.AUDIO === trackType && this.isDtxEnabled,
-                    red: TrackType.AUDIO === trackType && this.isRedEnabled,
+                    mid: (_a = transceiver.mid) !== null && _a !== void 0 ? _a : this.extractMid(sdp, track, trackType),
+                    stereo: isStereo,
+                    dtx: isAudioTrack && this.isDtxEnabled,
+                    red: isAudioTrack && this.isRedEnabled,
                 };
             });
         };
@@ -7064,6 +7131,7 @@ class Subscriber {
                 TRACK_TYPE_AUDIO: 'audioStream',
                 TRACK_TYPE_VIDEO: 'videoStream',
                 TRACK_TYPE_SCREEN_SHARE: 'screenShareStream',
+                TRACK_TYPE_SCREEN_SHARE_AUDIO: 'screenShareAudioStream',
             }[trackType];
             if (!streamKindProp) {
                 logger$2('error', `Unknown track type: ${trackType}`);
@@ -7152,7 +7220,8 @@ class Subscriber {
         this.onIceCandidateError = (e) => {
             const errorMessage = e instanceof RTCPeerConnectionIceErrorEvent &&
                 `${e.errorCode}: ${e.errorText}`;
-            logger$2('error', `ICE Candidate error`, errorMessage);
+            const logLevel = this.pc.iceConnectionState === 'connected' ? 'debug' : 'error';
+            logger$2(logLevel, `ICE Candidate error`, errorMessage);
         };
         this.sfuClient = sfuClient;
         this.dispatcher = dispatcher;
@@ -8357,8 +8426,9 @@ class CallState {
         };
         this.logger = getLogger(['CallState']);
         this.participants$ = this.participantsSubject.asObservable().pipe(
-        // TODO: replace with Array.toSorted once available
-        operators.map((ps) => [...ps].sort(this.sortParticipantsBy)), operators.shareReplay({ bufferSize: 1, refCount: true }));
+        // maintain stable-sort by mutating the participants stored
+        // in the original subject
+        operators.map((ps) => ps.sort(this.sortParticipantsBy)), operators.shareReplay({ bufferSize: 1, refCount: true }));
         this.localParticipant$ = this.participants$.pipe(operators.map((participants) => participants.find(isStreamVideoLocalParticipant)), operators.shareReplay({ bufferSize: 1, refCount: true }));
         this.remoteParticipants$ = this.participants$.pipe(operators.map((participants) => participants.filter((p) => !p.isLocalParticipant)), operators.shareReplay({ bufferSize: 1, refCount: true }));
         this.pinnedParticipants$ = this.participants$.pipe(operators.map((participants) => participants.filter((p) => !!p.pin)), operators.shareReplay({ bufferSize: 1, refCount: true }));
@@ -9664,17 +9734,22 @@ class DynascaleManager {
          *
          * @param audioElement the audio element to bind to.
          * @param sessionId the session id.
+         * @param trackType the kind of audio.
          * @returns a cleanup function that will unbind the audio element.
          */
-        this.bindAudioElement = (audioElement, sessionId) => {
+        this.bindAudioElement = (audioElement, sessionId, trackType) => {
             const participant = this.call.state.findParticipantBySessionId(sessionId);
             if (!participant || participant.isLocalParticipant)
                 return;
             const participant$ = this.call.state.participants$.pipe(rxjs.map((participants) => participants.find((p) => p.sessionId === sessionId)), rxjs.takeWhile((p) => !!p), rxjs.distinctUntilChanged(), rxjs.shareReplay({ bufferSize: 1, refCount: true }));
             const updateMediaStreamSubscription = participant$
-                .pipe(rxjs.distinctUntilKeyChanged('audioStream'))
+                .pipe(rxjs.distinctUntilKeyChanged(trackType === 'screenShareAudioTrack'
+                ? 'screenShareAudioStream'
+                : 'audioStream'))
                 .subscribe((p) => {
-                const source = p.audioStream;
+                const source = trackType === 'screenShareAudioTrack'
+                    ? p.screenShareAudioStream
+                    : p.audioStream;
                 if (audioElement.srcObject === source)
                     return;
                 setTimeout(() => {
@@ -9989,7 +10064,16 @@ const getVideoStream = (trackConstraints) => __awaiter(void 0, void 0, void 0, f
  */
 const getScreenShareStream = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        return yield navigator.mediaDevices.getDisplayMedia(Object.assign({ video: true, audio: false }, options));
+        return yield navigator.mediaDevices.getDisplayMedia(Object.assign({ video: true, audio: {
+                channelCount: {
+                    ideal: 2,
+                },
+                echoCancellation: false,
+                autoGainControl: false,
+                noiseSuppression: false,
+            }, 
+            // @ts-expect-error - not present in types yet
+            systemAudio: 'include' }, options));
     }
     catch (e) {
         getLogger(['devices'])('error', 'Failed to get screen share stream', e);
@@ -10118,7 +10202,7 @@ class InputMediaDeviceManager {
         return this.getDevices();
     }
     /**
-     * Starts camera/microphone
+     * Starts stream.
      */
     enable() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -10137,9 +10221,7 @@ class InputMediaDeviceManager {
         });
     }
     /**
-     * Stops camera/microphone
-     *
-     * @returns
+     * Stops the stream.
      */
     disable() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -10160,7 +10242,7 @@ class InputMediaDeviceManager {
         });
     }
     /**
-     * If status was previously enabled, it will reenable the device.
+     * If status was previously enabled, it will re-enable the device.
      */
     resume() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -10171,9 +10253,8 @@ class InputMediaDeviceManager {
         });
     }
     /**
-     * If current device statis is disabled, it will enable the device, else it will disable it.
-     *
-     * @returns
+     * If the current device status is disabled, it will enable the device,
+     * else it will disable it.
      */
     toggle() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -10185,6 +10266,16 @@ class InputMediaDeviceManager {
             }
         });
     }
+    /**
+     * Will set the default constraints for the device.
+     *
+     * @param constraints the constraints to set.
+     */
+    setDefaultConstraints(constraints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state.setDefaultConstraints(constraints);
+        });
+    }
     /**
      * Select device
      *
@@ -10212,8 +10303,11 @@ class InputMediaDeviceManager {
             }
         });
     }
+    getTracks() {
+        var _a, _b;
+        return (_b = (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getTracks()) !== null && _b !== void 0 ? _b : [];
+    }
     muteStream(stopTracks = true) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.state.mediaStream) {
                 return;
@@ -10223,57 +10317,63 @@ class InputMediaDeviceManager {
                 yield this.stopPublishStream(stopTracks);
             }
             this.muteLocalStream(stopTracks);
-            if (((_a = this.getTrack()) === null || _a === void 0 ? void 0 : _a.readyState) === 'ended') {
-                // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
-                if (typeof this.state.mediaStream.release === 'function') {
-                    // @ts-expect-error
-                    this.state.mediaStream.release();
+            this.getTracks().forEach((track) => {
+                if (track.readyState === 'ended') {
+                    // @ts-expect-error release() is present in react-native-webrtc
+                    // and must be called to dispose the stream
+                    if (typeof this.state.mediaStream.release === 'function') {
+                        // @ts-expect-error
+                        this.state.mediaStream.release();
+                    }
+                    this.state.setMediaStream(undefined);
                 }
-                this.state.setMediaStream(undefined);
-            }
+            });
         });
     }
-    muteTrack() {
-        const track = this.getTrack();
-        if (!track || !track.enabled) {
-            return;
-        }
-        track.enabled = false;
+    muteTracks() {
+        this.getTracks().forEach((track) => {
+            if (track.enabled)
+                track.enabled = false;
+        });
     }
-    unmuteTrack() {
-        const track = this.getTrack();
-        if (!track || track.enabled) {
-            return;
-        }
-        track.enabled = true;
+    unmuteTracks() {
+        this.getTracks().forEach((track) => {
+            if (!track.enabled)
+                track.enabled = true;
+        });
     }
-    stopTrack() {
-        const track = this.getTrack();
-        if (!track || track.readyState === 'ended') {
-            return;
-        }
-        track.stop();
+    stopTracks() {
+        this.getTracks().forEach((track) => {
+            if (track.readyState === 'live')
+                track.stop();
+        });
     }
     muteLocalStream(stopTracks) {
         if (!this.state.mediaStream) {
             return;
         }
-        stopTracks ? this.stopTrack() : this.muteTrack();
+        if (stopTracks) {
+            this.stopTracks();
+        }
+        else {
+            this.muteTracks();
+        }
     }
     unmuteStream() {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.logger('debug', 'Starting stream');
             let stream;
-            if (this.state.mediaStream && ((_a = this.getTrack()) === null || _a === void 0 ? void 0 : _a.readyState) === 'live') {
+            if (this.state.mediaStream &&
+                this.getTracks().every((t) => t.readyState === 'live')) {
                 stream = this.state.mediaStream;
-                this.unmuteTrack();
+                this.unmuteTracks();
             }
             else {
                 if (this.state.mediaStream) {
-                    this.stopTrack();
+                    this.stopTracks();
                 }
-                const constraints = { deviceId: this.state.selectedDevice };
+                const defaultConstraints = this.state.defaultConstraints;
+                const constraints = Object.assign(Object.assign({}, defaultConstraints), { deviceId: this.state.selectedDevice });
                 stream = yield this.getStream(constraints);
             }
             if (this.call.state.callingState === exports.CallingState.JOINED) {
@@ -10292,6 +10392,26 @@ class InputMediaDeviceManagerState {
         this.statusSubject = new rxjs.BehaviorSubject(undefined);
         this.mediaStreamSubject = new rxjs.BehaviorSubject(undefined);
         this.selectedDeviceSubject = new rxjs.BehaviorSubject(undefined);
+        this.defaultConstraintsSubject = new rxjs.BehaviorSubject(undefined);
+        /**
+         * An Observable that emits the current media stream, or `undefined` if the device is currently disabled.
+         *
+         */
+        this.mediaStream$ = this.mediaStreamSubject.asObservable();
+        /**
+         * An Observable that emits the currently selected device
+         */
+        this.selectedDevice$ = this.selectedDeviceSubject
+            .asObservable()
+            .pipe(rxjs.distinctUntilChanged());
+        /**
+         * An Observable that emits the device status
+         */
+        this.status$ = this.statusSubject.asObservable().pipe(rxjs.distinctUntilChanged());
+        /**
+         * The default constraints for the device.
+         */
+        this.defaultConstraints$ = this.defaultConstraintsSubject.asObservable();
         /**
          * Gets the current value of an observable, or undefined if the observable has
          * not emitted a value yet.
@@ -10311,13 +10431,6 @@ class InputMediaDeviceManagerState {
          * @return the updated value.
          */
         this.setCurrentValue = setCurrentValue;
-        this.mediaStream$ = this.mediaStreamSubject.asObservable();
-        this.selectedDevice$ = this.selectedDeviceSubject
-            .asObservable()
-            .pipe(rxjs.distinctUntilChanged());
-        this.status$ = this.statusSubject
-            .asObservable()
-            .pipe(rxjs.distinctUntilChanged());
     }
     /**
      * The device status
@@ -10361,6 +10474,21 @@ class InputMediaDeviceManagerState {
     setDevice(deviceId) {
         this.setCurrentValue(this.selectedDeviceSubject, deviceId);
     }
+    /**
+     * Gets the default constraints for the device.
+     */
+    get defaultConstraints() {
+        return this.getCurrentValue(this.defaultConstraints$);
+    }
+    /**
+     * Sets the default constraints for the device.
+     *
+     * @internal
+     * @param constraints the constraints to set.
+     */
+    setDefaultConstraints(constraints) {
+        this.setCurrentValue(this.defaultConstraintsSubject, constraints);
+    }
 }
 
 class CameraManagerState extends InputMediaDeviceManagerState {
@@ -10485,10 +10613,6 @@ class CameraManager extends InputMediaDeviceManager {
     stopPublishStream(stopTracks) {
         return this.call.stopPublish(TrackType.VIDEO, stopTracks);
     }
-    getTrack() {
-        var _a;
-        return (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getVideoTracks()[0];
-    }
 }
 
 class MicrophoneManagerState extends InputMediaDeviceManagerState {
@@ -10613,10 +10737,6 @@ class MicrophoneManager extends InputMediaDeviceManager {
     stopPublishStream(stopTracks) {
         return this.call.stopPublish(TrackType.AUDIO, stopTracks);
     }
-    getTrack() {
-        var _a;
-        return (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0];
-    }
     startSpeakingWhileMutedDetection(deviceId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (isReactNative()) {
@@ -10648,6 +10768,128 @@ class MicrophoneManager extends InputMediaDeviceManager {
     }
 }
 
+class ScreenShareState extends InputMediaDeviceManagerState {
+    constructor() {
+        super(...arguments);
+        this.audioEnabledSubject = new rxjs.BehaviorSubject(true);
+        this.settingsSubject = new rxjs.BehaviorSubject(undefined);
+        /**
+         * An Observable that emits the current screen share audio status.
+         */
+        this.audioEnabled$ = this.audioEnabledSubject
+            .asObservable()
+            .pipe(operators.distinctUntilChanged());
+        /**
+         * An Observable that emits the current screen share settings.
+         */
+        this.settings$ = this.settingsSubject.asObservable();
+        /**
+         * @internal
+         */
+        this.getDeviceIdFromStream = (stream) => {
+            const [track] = stream.getTracks();
+            return track === null || track === void 0 ? void 0 : track.getSettings().deviceId;
+        };
+    }
+    /**
+     * The current screen share audio status.
+     */
+    get audioEnabled() {
+        return this.getCurrentValue(this.audioEnabled$);
+    }
+    /**
+     * Set the current screen share audio status.
+     */
+    setAudioEnabled(isEnabled) {
+        this.setCurrentValue(this.audioEnabledSubject, isEnabled);
+    }
+    /**
+     * The current screen share settings.
+     */
+    get settings() {
+        return this.getCurrentValue(this.settings$);
+    }
+    /**
+     * Set the current screen share settings.
+     *
+     * @param settings the screen share settings to set.
+     */
+    setSettings(settings) {
+        this.setCurrentValue(this.settingsSubject, settings);
+    }
+}
+
+class ScreenShareManager extends InputMediaDeviceManager {
+    constructor(call) {
+        super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
+    }
+    /**
+     * Will enable screen share audio options on supported platforms.
+     *
+     * Note: for ongoing screen share, audio won't be enabled until you
+     * re-publish the screen share stream.
+     */
+    enableScreenShareAudio() {
+        this.state.setAudioEnabled(true);
+    }
+    /**
+     * Will disable screen share audio options on supported platforms.
+     */
+    disableScreenShareAudio() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state.setAudioEnabled(false);
+            if ((_a = this.call.publisher) === null || _a === void 0 ? void 0 : _a.isPublishing(TrackType.SCREEN_SHARE_AUDIO)) {
+                yield this.call.stopPublish(TrackType.SCREEN_SHARE_AUDIO, true);
+            }
+        });
+    }
+    /**
+     * Returns the current screen share settings.
+     */
+    getSettings() {
+        return this.state.settings;
+    }
+    /**
+     * Sets the current screen share settings.
+     *
+     * @param settings the settings to set.
+     */
+    setSettings(settings) {
+        this.state.setSettings(settings);
+    }
+    getDevices() {
+        return rxjs.of([]); // there are no devices to be listed for Screen Share
+    }
+    getStream(constraints) {
+        if (!this.state.audioEnabled) {
+            constraints.audio = false;
+        }
+        return getScreenShareStream(constraints);
+    }
+    publishStream(stream) {
+        return this.call.publishScreenShareStream(stream, {
+            screenShareSettings: this.state.settings,
+        });
+    }
+    stopPublishStream(stopTracks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.call.stopPublish(TrackType.SCREEN_SHARE, stopTracks);
+            yield this.call.stopPublish(TrackType.SCREEN_SHARE_AUDIO, stopTracks);
+        });
+    }
+    /**
+     * Overrides the default `select` method to throw an error.
+     *
+     * @param deviceId ignored.
+     */
+    select(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('This method is not supported in for Screen Share');
+        });
+    }
+}
+
 class SpeakerState {
     constructor() {
         this.selectedDeviceSubject = new rxjs.BehaviorSubject('');
@@ -11021,7 +11263,17 @@ class Call {
                 // as the underlying peer connection will take care of it as part
                 // of the ice-restart process
                 if (localParticipant && !migrate) {
-                    const { audioStream, videoStream, screenShareStream: screenShare, } = localParticipant;
+                    const { audioStream, videoStream, screenShareStream, screenShareAudioStream, } = localParticipant;
+                    let screenShare;
+                    if (screenShareStream || screenShareAudioStream) {
+                        screenShare = new MediaStream();
+                        screenShareStream === null || screenShareStream === void 0 ? void 0 : screenShareStream.getVideoTracks().forEach((track) => {
+                            screenShare === null || screenShare === void 0 ? void 0 : screenShare.addTrack(track);
+                        });
+                        screenShareAudioStream === null || screenShareAudioStream === void 0 ? void 0 : screenShareAudioStream.getAudioTracks().forEach((track) => {
+                            screenShare === null || screenShare === void 0 ? void 0 : screenShare.addTrack(track);
+                        });
+                    }
                     // restore previous publishing state
                     if (audioStream)
                         yield this.publishAudioStream(audioStream);
@@ -11275,7 +11527,6 @@ class Call {
          * Consecutive calls to this method will replace the audio stream that is currently being published.
          * The previous audio stream will be stopped.
          *
-         *
          * @param audioStream the audio stream to publish.
          */
         this.publishAudioStream = (audioStream) => __awaiter(this, void 0, void 0, function* () {
@@ -11299,10 +11550,10 @@ class Call {
          * Consecutive calls to this method will replace the previous screen-share stream.
          * The previous screen-share stream will be stopped.
          *
-         *
          * @param screenShareStream the screen-share stream to publish.
+         * @param opts the options to use when publishing the stream.
          */
-        this.publishScreenShareStream = (screenShareStream) => __awaiter(this, void 0, void 0, function* () {
+        this.publishScreenShareStream = (screenShareStream, opts = {}) => __awaiter(this, void 0, void 0, function* () {
             // we should wait until we get a JoinResponse from the SFU,
             // otherwise we risk breaking the ICETrickle flow.
             yield this.assertCallJoined();
@@ -11315,7 +11566,11 @@ class Call {
                 this.logger('error', `There is no video track in the screen share stream to publish`);
                 return;
             }
-            yield this.publisher.publishStream(screenShareStream, screenShareTrack, TrackType.SCREEN_SHARE);
+            yield this.publisher.publishStream(screenShareStream, screenShareTrack, TrackType.SCREEN_SHARE, opts);
+            const [screenShareAudioTrack] = screenShareStream.getAudioTracks();
+            if (screenShareAudioTrack) {
+                yield this.publisher.publishStream(screenShareStream, screenShareAudioTrack, TrackType.SCREEN_SHARE_AUDIO, opts);
+            }
         });
         /**
          * Stops publishing the given track type to the call, if it is currently being published.
@@ -11400,6 +11655,13 @@ class Call {
                         dimension: p.screenShareDimension,
                     });
                 }
+                if (p.publishedTracks.includes(TrackType.SCREEN_SHARE_AUDIO)) {
+                    subscriptions.push({
+                        userId: p.userId,
+                        sessionId: p.sessionId,
+                        trackType: TrackType.SCREEN_SHARE_AUDIO,
+                    });
+                }
             }
             // schedule update
             this.trackSubscriptionsSubject.next({ type, data: subscriptions });
@@ -11870,9 +12132,10 @@ class Call {
          *
          * @param audioElement the audio element to bind to.
          * @param sessionId the session id.
+         * @param trackType the kind of audio.
          */
-        this.bindAudioElement = (audioElement, sessionId) => {
-            const unbind = this.dynascaleManager.bindAudioElement(audioElement, sessionId);
+        this.bindAudioElement = (audioElement, sessionId, trackType = 'audioTrack') => {
+            const unbind = this.dynascaleManager.bindAudioElement(audioElement, sessionId, trackType);
             if (!unbind)
                 return;
             this.leaveCallHooks.add(unbind);
@@ -11934,6 +12197,7 @@ class Call {
         this.camera = new CameraManager(this);
         this.microphone = new MicrophoneManager(this);
         this.speaker = new SpeakerManager();
+        this.screenShare = new ScreenShareManager(this);
     }
     registerEffects() {
         this.leaveCallHooks.add(
@@ -13242,7 +13506,7 @@ class WSConnectionFallback {
     }
 }
 
-const version = '0.3.28';
+const version = '0.3.30';
 
 const logger = getLogger(['location']);
 const HINT_URL = `https://hint.stream-io-video.com/`;
@@ -14248,6 +14512,8 @@ exports.OwnCapability = OwnCapability;
 exports.RecordSettingsRequestModeEnum = RecordSettingsRequestModeEnum;
 exports.RecordSettingsRequestQualityEnum = RecordSettingsRequestQualityEnum;
 exports.RxUtils = rxUtils;
+exports.ScreenShareManager = ScreenShareManager;
+exports.ScreenShareState = ScreenShareState;
 exports.SfuEvents = events;
 exports.SfuModels = models;
 exports.SpeakerManager = SpeakerManager;