@stream-io/video-client 1.13.1 → 1.15.0

package/src/StreamSfuClient.ts

@@ -20,19 +20,19 @@ import {
   SendAnswerRequest,
   SendStatsRequest,
   SetPublisherRequest,
+  TrackMuteState,
   TrackSubscriptionDetails,
-  UpdateMuteStatesRequest,
 } from './gen/video/sfu/signal_rpc/signal';
-import { ICETrickle, TrackType } from './gen/video/sfu/models/models';
+import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
 import { generateUUIDv4 } from './coordinator/connection/utils';
 import { Credentials } from './gen/coordinator';
 import { Logger } from './coordinator/connection/types';
 import { getLogger, getLogLevel } from './logger';
 import {
-  promiseWithResolvers,
-  PromiseWithResolvers,
   makeSafePromise,
+  PromiseWithResolvers,
+  promiseWithResolvers,
   SafePromise,
 } from './helpers/promise';
 import { getTimers } from './timers';
@@ -277,7 +277,7 @@ export class StreamSfuClient {
     this.dispose();
   };
 
-  dispose = () => {
+  private dispose = () => {
     this.logger('debug', 'Disposing SFU client');
     this.unsubscribeIceTrickle();
     this.unsubscribeNetworkChanged();
@@ -286,6 +286,7 @@ export class StreamSfuClient {
     clearTimeout(this.migrateAwayTimeout);
     this.abortController.abort();
     this.migrationTask?.resolve();
+    this.iceTrickleBuffer.dispose();
   };
 
   leaveAndClose = async (reason: string) => {
@@ -340,17 +341,11 @@ export class StreamSfuClient {
     );
   };
 
-  updateMuteState = async (trackType: TrackType, muted: boolean) => {
-    await this.joinTask;
-    return this.updateMuteStates({ muteStates: [{ trackType, muted }] });
-  };
-
-  updateMuteStates = async (
-    data: Omit<UpdateMuteStatesRequest, 'sessionId'>,
-  ) => {
+  updateMuteStates = async (muteStates: TrackMuteState[]) => {
     await this.joinTask;
     return retryable(
-      () => this.rpc.updateMuteStates({ ...data, sessionId: this.sessionId }),
+      () =>
+        this.rpc.updateMuteStates({ muteStates, sessionId: this.sessionId }),
       this.abortController.signal,
     );
   };

package/src/StreamVideoClient.ts

@@ -415,7 +415,7 @@ export class StreamVideoClient {
         clientStore: this.writeableStateStore,
       });
       call.state.updateFromCallResponse(c.call);
-      await call.applyDeviceConfig(false);
+      await call.applyDeviceConfig(c.call.settings, false);
       if (data.watch) {
         this.writeableStateStore.registerCall(call);
       }

package/src/__tests__/Call.publishing.test.ts

@@ -0,0 +1,306 @@
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Call } from '../Call';
+import { Publisher } from '../rtc';
+import { StreamClient } from '../coordinator/connection/client';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { PermissionsContext } from '../permissions';
+import { OwnCapability } from '../gen/coordinator';
+import { StreamVideoWriteableStateStore } from '../store';
+import { TrackType } from '../gen/video/sfu/models/models';
+import { StreamSfuClient } from '../StreamSfuClient';
+
+describe('Publishing and Unpublishing tracks', () => {
+  let call: Call;
+
+  beforeEach(async () => {
+    call = new Call({
+      type: 'test',
+      id: generateUUIDv4(),
+      streamClient: new StreamClient('abc'),
+      clientStore: new StreamVideoWriteableStateStore(),
+    });
+
+    const ctx = new PermissionsContext();
+    ctx.setPermissions([
+      OwnCapability.SEND_AUDIO,
+      OwnCapability.SEND_VIDEO,
+      OwnCapability.SCREENSHARE,
+    ]);
+    // @ts-expect-error permissionsContext is private
+    call['permissionsContext'] = ctx;
+  });
+
+  describe('Validations', () => {
+    it('publishing is not allowed only when call is not joined', async () => {
+      const ms = new MediaStream();
+      const err = 'Call not joined yet.';
+      await expect(call.publish(ms, TrackType.VIDEO)).rejects.toThrowError(err);
+      await expect(call.publish(ms, TrackType.AUDIO)).rejects.toThrowError(err);
+      await expect(
+        call.publish(ms, TrackType.SCREEN_SHARE),
+      ).rejects.toThrowError(err);
+    });
+
+    it('publishing is not allowed when permissions are not set', async () => {
+      // @ts-expect-error sfuClient is private
+      call['sfuClient'] = {};
+
+      call['permissionsContext'].setPermissions([]);
+
+      const ms = new MediaStream();
+      await expect(call.publish(ms, TrackType.VIDEO)).rejects.toThrowError(
+        `No permission to publish VIDEO`,
+      );
+      await expect(call.publish(ms, TrackType.AUDIO)).rejects.toThrowError(
+        'No permission to publish AUDIO',
+      );
+      await expect(
+        call.publish(ms, TrackType.SCREEN_SHARE),
+      ).rejects.toThrowError('No permission to publish SCREEN_SHARE');
+    });
+
+    it('publishing is not allowed when the publisher is not initialized', async () => {
+      // @ts-expect-error sfuClient is private
+      call['sfuClient'] = {};
+
+      const ms = new MediaStream();
+      await expect(call.publish(ms, TrackType.VIDEO)).rejects.toThrowError(
+        'Publisher is not initialized',
+      );
+    });
+
+    it('publishing is not allowed when there are no tracks in the stream', async () => {
+      // @ts-expect-error sfuClient is private
+      call['sfuClient'] = {};
+      // @ts-expect-error publisher is private
+      call['publisher'] = {};
+
+      const ms = new MediaStream();
+      vi.spyOn(ms, 'getVideoTracks').mockReturnValue([]);
+      vi.spyOn(ms, 'getAudioTracks').mockReturnValue([]);
+
+      await expect(call.publish(ms, TrackType.VIDEO)).rejects.toThrowError(
+        'There is no VIDEO track in the stream',
+      );
+      await expect(call.publish(ms, TrackType.AUDIO)).rejects.toThrowError(
+        'There is no AUDIO track in the stream',
+      );
+      await expect(
+        call.publish(ms, TrackType.SCREEN_SHARE),
+      ).rejects.toThrowError('There is no SCREEN_SHARE track in the stream');
+    });
+
+    it('publishing is not allowed when the track ended', async () => {
+      // @ts-expect-error sfuClient is private
+      call['sfuClient'] = {};
+      // @ts-expect-error publisher is private
+      call['publisher'] = {};
+
+      const ms = new MediaStream();
+      const track = new MediaStreamTrack();
+      vi.spyOn(ms, 'getVideoTracks').mockReturnValue([track]);
+      vi.spyOn(track, 'readyState', 'get').mockReturnValue('ended');
+
+      await expect(call.publish(ms, TrackType.VIDEO)).rejects.toThrowError(
+        `Can't publish ended tracks.`,
+      );
+    });
+  });
+
+  describe('Publishing and Unpublishing', () => {
+    const sessionId = 'abc';
+    let publisher: Publisher;
+    let sfuClient: StreamSfuClient;
+
+    beforeEach(() => {
+      // @ts-expect-error partial data
+      call.state.updateOrAddParticipant(sessionId, {
+        sessionId,
+        publishedTracks: [],
+      });
+
+      sfuClient = vi.fn() as unknown as StreamSfuClient;
+      // @ts-expect-error sessionId is readonly
+      sfuClient['sessionId'] = sessionId;
+      sfuClient.updateMuteStates = vi.fn();
+
+      publisher = vi.fn() as unknown as Publisher;
+      publisher.publish = vi.fn();
+      publisher.stopTracks = vi.fn();
+
+      call['sfuClient'] = sfuClient;
+      call.publisher = publisher;
+    });
+
+    it('publish video stream', async () => {
+      const track = new MediaStreamTrack();
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getVideoTracks').mockReturnValue([track]);
+
+      await call.publish(mediaStream, TrackType.VIDEO);
+      expect(publisher.publish).toHaveBeenCalledWith(track, TrackType.VIDEO);
+      expect(call['trackPublishOrder']).toEqual([TrackType.VIDEO]);
+
+      expect(sfuClient.updateMuteStates).toHaveBeenCalledWith([
+        { trackType: TrackType.VIDEO, muted: false },
+      ]);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant).toBeDefined();
+      expect(participant!.publishedTracks).toEqual([TrackType.VIDEO]);
+      expect(participant!.videoStream).toEqual(mediaStream);
+    });
+
+    it('publish audio stream', async () => {
+      const track = new MediaStreamTrack();
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getAudioTracks').mockReturnValue([track]);
+
+      await call.publish(mediaStream, TrackType.AUDIO);
+      expect(publisher.publish).toHaveBeenCalledWith(track, TrackType.AUDIO);
+      expect(call['trackPublishOrder']).toEqual([TrackType.AUDIO]);
+
+      expect(sfuClient.updateMuteStates).toHaveBeenCalledWith([
+        { trackType: TrackType.AUDIO, muted: false },
+      ]);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant).toBeDefined();
+      expect(participant!.publishedTracks).toEqual([TrackType.AUDIO]);
+      expect(participant!.audioStream).toEqual(mediaStream);
+    });
+
+    it('publish screen share stream', async () => {
+      const track = new MediaStreamTrack();
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getVideoTracks').mockReturnValue([track]);
+
+      await call.publish(mediaStream, TrackType.SCREEN_SHARE);
+      expect(publisher.publish).toHaveBeenCalledWith(
+        track,
+        TrackType.SCREEN_SHARE,
+      );
+      expect(call['trackPublishOrder']).toEqual([TrackType.SCREEN_SHARE]);
+
+      expect(sfuClient.updateMuteStates).toHaveBeenCalledWith([
+        { trackType: TrackType.SCREEN_SHARE, muted: false },
+      ]);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant).toBeDefined();
+      expect(participant!.publishedTracks).toEqual([TrackType.SCREEN_SHARE]);
+      expect(participant!.screenShareStream).toEqual(mediaStream);
+    });
+
+    it('publish screen share stream with audio', async () => {
+      const videoTrack = new MediaStreamTrack();
+      const audioTrack = new MediaStreamTrack();
+      const mediaStream = new MediaStream();
+      vi.spyOn(mediaStream, 'getVideoTracks').mockReturnValue([videoTrack]);
+      vi.spyOn(mediaStream, 'getAudioTracks').mockReturnValue([audioTrack]);
+
+      await call.publish(mediaStream, TrackType.SCREEN_SHARE);
+      expect(publisher.publish).toHaveBeenCalledWith(
+        videoTrack,
+        TrackType.SCREEN_SHARE,
+      );
+      expect(publisher.publish).toHaveBeenCalledWith(
+        audioTrack,
+        TrackType.SCREEN_SHARE_AUDIO,
+      );
+      expect(call['trackPublishOrder']).toEqual([
+        TrackType.SCREEN_SHARE,
+        TrackType.SCREEN_SHARE_AUDIO,
+      ]);
+
+      expect(sfuClient.updateMuteStates).toHaveBeenCalledWith([
+        { trackType: TrackType.SCREEN_SHARE, muted: false },
+        { trackType: TrackType.SCREEN_SHARE_AUDIO, muted: false },
+      ]);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant).toBeDefined();
+      expect(participant!.publishedTracks).toEqual([
+        TrackType.SCREEN_SHARE,
+        TrackType.SCREEN_SHARE_AUDIO,
+      ]);
+      expect(participant!.screenShareStream).toEqual(mediaStream);
+      expect(participant!.screenShareAudioStream).toEqual(mediaStream);
+    });
+
+    it('unpublish video stream', async () => {
+      const mediaStream = new MediaStream();
+      call.state.updateParticipant(sessionId, {
+        publishedTracks: [TrackType.VIDEO, TrackType.AUDIO],
+        videoStream: mediaStream,
+      });
+      await call.stopPublish(TrackType.VIDEO);
+      expect(publisher.publish).not.toHaveBeenCalled();
+      expect(publisher.stopTracks).toHaveBeenCalledWith(TrackType.VIDEO);
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([TrackType.AUDIO]);
+      expect(participant!.videoStream).toBeUndefined();
+    });
+
+    it('unpublish audio stream', async () => {
+      const mediaStream = new MediaStream();
+      call.state.updateParticipant(sessionId, {
+        publishedTracks: [TrackType.VIDEO, TrackType.AUDIO],
+        audioStream: mediaStream,
+      });
+      await call.stopPublish(TrackType.AUDIO);
+      expect(publisher.publish).not.toHaveBeenCalled();
+      expect(publisher.stopTracks).toHaveBeenCalledWith(TrackType.AUDIO);
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([TrackType.VIDEO]);
+      expect(participant!.audioStream).toBeUndefined();
+    });
+
+    it('unpublish screen share stream', async () => {
+      const mediaStream = new MediaStream();
+      call.state.updateParticipant(sessionId, {
+        publishedTracks: [TrackType.SCREEN_SHARE, TrackType.SCREEN_SHARE_AUDIO],
+        screenShareStream: mediaStream,
+        screenShareAudioStream: mediaStream,
+      });
+      await call.stopPublish(
+        TrackType.SCREEN_SHARE,
+        TrackType.SCREEN_SHARE_AUDIO,
+      );
+      expect(publisher.publish).not.toHaveBeenCalled();
+      expect(publisher.stopTracks).toHaveBeenCalledWith(
+        TrackType.SCREEN_SHARE,
+        TrackType.SCREEN_SHARE_AUDIO,
+      );
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([]);
+      expect(participant!.screenShareStream).toBeUndefined();
+      expect(participant!.screenShareAudioStream).toBeUndefined();
+    });
+  });
+
+  describe('Deprecated methods', () => {
+    it('publishVideoStream', async () => {
+      const ms = new MediaStream();
+      call.publish = vi.fn();
+      await call.publishVideoStream(ms);
+      expect(call.publish).toHaveBeenCalledWith(ms, TrackType.VIDEO);
+    });
+
+    it('publishAudioStream', async () => {
+      const ms = new MediaStream();
+      call.publish = vi.fn();
+      await call.publishAudioStream(ms);
+      expect(call.publish).toHaveBeenCalledWith(ms, TrackType.AUDIO);
+    });
+
+    it('publishScreenShareStream', async () => {
+      const ms = new MediaStream();
+      call.publish = vi.fn();
+      await call.publishScreenShareStream(ms);
+      expect(call.publish).toHaveBeenCalledWith(ms, TrackType.SCREEN_SHARE);
+    });
+  });
+});

package/src/devices/CameraManager.ts

@@ -3,9 +3,9 @@ import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { getVideoDevices, getVideoStream } from './devices';
+import { OwnCapability, VideoSettingsResponse } from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
-import { PreferredCodec } from '../types';
-import { isMobile } from '../compatibility';
+import { isMobile } from '../helpers/compatibility';
 import { isReactNative } from '../helpers/platforms';
 
 export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
@@ -86,14 +86,39 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
   }
 
   /**
-   * Sets the preferred codec for encoding the video.
+   * Applies the video settings to the camera.
    *
-   * @internal internal use only, not part of the public API.
-   * @deprecated use {@link call.updatePublishOptions} instead.
-   * @param codec the codec to use for encoding the video.
+   * @param settings the video settings to apply.
+   * @param publish whether to publish the stream after applying the settings.
    */
-  setPreferredCodec(codec: PreferredCodec | undefined) {
-    this.call.updatePublishOptions({ preferredCodec: codec });
+  async apply(settings: VideoSettingsResponse, publish: boolean) {
+    const hasPublishedVideo = !!this.call.state.localParticipant?.videoStream;
+    const hasPermission = this.call.permissionsContext.hasPermission(
+      OwnCapability.SEND_AUDIO,
+    );
+    if (hasPublishedVideo || !hasPermission) return;
+
+    // Wait for any in progress camera operation
+    await this.statusChangeSettled();
+
+    const { target_resolution, camera_facing, camera_default_on } = settings;
+    await this.selectTargetResolution(target_resolution);
+
+    // Set camera direction if it's not yet set
+    if (!this.state.direction && !this.state.selectedDevice) {
+      this.state.setDirection(camera_facing === 'front' ? 'front' : 'back');
+    }
+
+    if (!publish) return;
+
+    const { mediaStream } = this.state;
+    if (this.enabled && mediaStream) {
+      // The camera is already enabled (e.g. lobby screen). Publish the stream
+      await this.publishStream(mediaStream);
+    } else if (this.state.status === undefined && camera_default_on) {
+      // Start camera if backend config specifies, and there is no local setting
+      await this.enable();
+    }
   }
 
   protected getDevices(): Observable<MediaDeviceInfo[]> {
@@ -118,12 +143,4 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
     }
     return getVideoStream(constraints);
   }
-
-  protected publishStream(stream: MediaStream): Promise<void> {
-    return this.call.publishVideoStream(stream);
-  }
-
-  protected stopPublishStream(stopTracks: boolean): Promise<void> {
-    return this.call.stopPublish(TrackType.VIDEO, stopTracks);
-  }
 }

package/src/devices/InputMediaDeviceManager.ts

@@ -241,43 +241,45 @@ export abstract class InputMediaDeviceManager<
 
   protected abstract getStream(constraints: C): Promise<MediaStream>;
 
-  protected abstract publishStream(stream: MediaStream): Promise<void>;
+  protected publishStream(stream: MediaStream): Promise<void> {
+    return this.call.publish(stream, this.trackType);
+  }
 
-  protected abstract stopPublishStream(stopTracks: boolean): Promise<void>;
+  protected stopPublishStream(): Promise<void> {
+    return this.call.stopPublish(this.trackType);
+  }
 
   protected getTracks(): MediaStreamTrack[] {
     return this.state.mediaStream?.getTracks() ?? [];
   }
 
   protected async muteStream(stopTracks: boolean = true) {
-    if (!this.state.mediaStream) return;
+    const mediaStream = this.state.mediaStream;
+    if (!mediaStream) return;
     this.logger('debug', `${stopTracks ? 'Stopping' : 'Disabling'} stream`);
     if (this.call.state.callingState === CallingState.JOINED) {
-      await this.stopPublishStream(stopTracks);
+      await this.stopPublishStream();
     }
     this.muteLocalStream(stopTracks);
     const allEnded = this.getTracks().every((t) => t.readyState === 'ended');
     if (allEnded) {
-      if (
-        this.state.mediaStream &&
-        // @ts-expect-error release() is present in react-native-webrtc
-        typeof this.state.mediaStream.release === 'function'
-      ) {
+      // @ts-expect-error release() is present in react-native-webrtc
+      if (typeof mediaStream.release === 'function') {
         // @ts-expect-error called to dispose the stream in RN
-        this.state.mediaStream.release();
+        mediaStream.release();
       }
       this.state.setMediaStream(undefined, undefined);
       this.filters.forEach((entry) => entry.stop?.());
     }
   }
 
-  private muteTracks() {
+  private disableTracks() {
     this.getTracks().forEach((track) => {
       if (track.enabled) track.enabled = false;
     });
   }
 
-  private unmuteTracks() {
+  private enableTracks() {
     this.getTracks().forEach((track) => {
       if (!track.enabled) track.enabled = true;
     });
@@ -296,7 +298,7 @@ export abstract class InputMediaDeviceManager<
     if (stopTracks) {
       this.stopTracks();
     } else {
-      this.muteTracks();
+      this.disableTracks();
     }
   }
 
@@ -309,7 +311,7 @@ export abstract class InputMediaDeviceManager<
       this.getTracks().every((t) => t.readyState === 'live')
     ) {
       stream = this.state.mediaStream;
-      this.unmuteTracks();
+      this.enableTracks();
     } else {
       const defaultConstraints = this.state.defaultConstraints;
       const constraints: MediaTrackConstraints = {
@@ -414,11 +416,22 @@ export abstract class InputMediaDeviceManager<
           await this.disable();
         }
       };
-      this.getTracks().forEach((track) => {
+      const createTrackMuteHandler = (muted: boolean) => () => {
+        this.call.notifyTrackMuteState(muted, this.trackType).catch((err) => {
+          this.logger('warn', 'Error while notifying track mute state', err);
+        });
+      };
+      stream.getTracks().forEach((track) => {
+        const muteHandler = createTrackMuteHandler(true);
+        const unmuteHandler = createTrackMuteHandler(false);
+        track.addEventListener('mute', muteHandler);
+        track.addEventListener('unmute', unmuteHandler);
         track.addEventListener('ended', handleTrackEnded);
-        this.subscriptions.push(() =>
-          track.removeEventListener('ended', handleTrackEnded),
-        );
+        this.subscriptions.push(() => {
+          track.removeEventListener('mute', muteHandler);
+          track.removeEventListener('unmute', unmuteHandler);
+          track.removeEventListener('ended', handleTrackEnded);
+        });
       });
     }
   }
@@ -447,11 +460,8 @@ export abstract class InputMediaDeviceManager<
 
             let isDeviceDisconnected = false;
             let isDeviceReplaced = false;
-            const currentDevice = this.findDeviceInList(
-              currentDevices,
-              deviceId,
-            );
-            const prevDevice = this.findDeviceInList(prevDevices, deviceId);
+            const currentDevice = this.findDevice(currentDevices, deviceId);
+            const prevDevice = this.findDevice(prevDevices, deviceId);
             if (!currentDevice && prevDevice) {
               isDeviceDisconnected = true;
             } else if (
@@ -490,9 +500,8 @@ export abstract class InputMediaDeviceManager<
     );
   }
 
-  private findDeviceInList(devices: MediaDeviceInfo[], deviceId: string) {
-    return devices.find(
-      (d) => d.deviceId === deviceId && d.kind === this.mediaDeviceKind,
-    );
+  private findDevice(devices: MediaDeviceInfo[], deviceId: string) {
+    const kind = this.mediaDeviceKind;
+    return devices.find((d) => d.deviceId === deviceId && d.kind === kind);
   }
 }

package/src/devices/MicrophoneManager.ts

@@ -9,6 +9,7 @@ import { TrackType } from '../gen/video/sfu/models/models';
 import { createSoundDetector } from '../helpers/sound-detector';
 import { isReactNative } from '../helpers/platforms';
 import {
+  AudioSettingsResponse,
   NoiseCancellationSettingsModeEnum,
   OwnCapability,
 } from '../gen/coordinator';
@@ -201,6 +202,34 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     await this.stopSpeakingWhileMutedDetection();
   }
 
+  /**
+   * Applies the audio settings to the microphone.
+   * @param settings the audio settings to apply.
+   * @param publish whether to publish the stream after applying the settings.
+   */
+  async apply(settings: AudioSettingsResponse, publish: boolean) {
+    if (!publish) return;
+
+    const hasPublishedAudio = !!this.call.state.localParticipant?.audioStream;
+    const hasPermission = this.call.permissionsContext.hasPermission(
+      OwnCapability.SEND_AUDIO,
+    );
+    if (hasPublishedAudio || !hasPermission) return;
+
+    // Wait for any in progress mic operation
+    await this.statusChangeSettled();
+
+    // Publish media stream that was set before we joined
+    const { mediaStream } = this.state;
+    if (this.enabled && mediaStream) {
+      // The mic is already enabled (e.g. lobby screen). Publish the stream
+      await this.publishStream(mediaStream);
+    } else if (this.state.status === undefined && settings.mic_default_on) {
+      // Start mic if backend config specifies, and there is no local setting
+      await this.enable();
+    }
+  }
+
   protected getDevices(): Observable<MediaDeviceInfo[]> {
     return getAudioDevices();
   }
@@ -211,14 +240,6 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     return getAudioStream(constraints);
   }
 
-  protected publishStream(stream: MediaStream): Promise<void> {
-    return this.call.publishAudioStream(stream);
-  }
-
-  protected stopPublishStream(stopTracks: boolean): Promise<void> {
-    return this.call.stopPublish(TrackType.AUDIO, stopTracks);
-  }
-
   private async startSpeakingWhileMutedDetection(deviceId?: string) {
     await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
       await this.stopSpeakingWhileMutedDetection();

package/src/devices/ScreenShareManager.ts

@@ -46,7 +46,7 @@ export class ScreenShareManager extends InputMediaDeviceManager<
   async disableScreenShareAudio(): Promise<void> {
     this.state.setAudioEnabled(false);
     if (this.call.publisher?.isPublishing(TrackType.SCREEN_SHARE_AUDIO)) {
-      await this.call.stopPublish(TrackType.SCREEN_SHARE_AUDIO, true);
+      await this.call.stopPublish(TrackType.SCREEN_SHARE_AUDIO);
     }
   }
 
@@ -79,13 +79,11 @@ export class ScreenShareManager extends InputMediaDeviceManager<
     return getScreenShareStream(constraints);
   }
 
-  protected publishStream(stream: MediaStream): Promise<void> {
-    return this.call.publishScreenShareStream(stream);
-  }
-
-  protected async stopPublishStream(stopTracks: boolean): Promise<void> {
-    await this.call.stopPublish(TrackType.SCREEN_SHARE, stopTracks);
-    await this.call.stopPublish(TrackType.SCREEN_SHARE_AUDIO, stopTracks);
+  protected async stopPublishStream(): Promise<void> {
+    return this.call.stopPublish(
+      TrackType.SCREEN_SHARE,
+      TrackType.SCREEN_SHARE_AUDIO,
+    );
   }
 
   /**