@webex/plugin-meetings 3.0.0-beta.85 → 3.0.0-beta.87

package/dist/types/meeting/muteState.d.ts

@@ -1,4 +1,5 @@
-export declare const createMuteState: (type: any, meeting: any, mediaDirection: any) => MuteState;
+import { ServerMuteReason } from '@webex/media-helpers';
+export declare const createMuteState: (type: any, meeting: any, mediaDirection: any, sdkOwnsLocalTrack: boolean) => MuteState;
 /** The purpose of this class is to manage the local and remote mute state and make sure that the server state always matches
    the last requested state by the client.
 
@@ -9,13 +10,42 @@ declare class MuteState {
     pendingPromiseResolve: any;
     state: any;
     type: any;
+    sdkOwnsLocalTrack: boolean;
+    ignoreMuteStateChange: boolean;
     /**
      * Constructor
      *
      * @param {String} type - audio or video
      * @param {Object} meeting - the meeting object (used for reading current remote mute status)
+     * @param {boolean} sdkOwnsLocalTrack - if false, then client app owns the local track (for now that's the case only for multistream meetings)
      */
-    constructor(type: string, meeting: any);
+    constructor(type: string, meeting: any, sdkOwnsLocalTrack: boolean);
+    /**
+     * Starts the mute state machine. Needs to be called after a new MuteState instance is created.
+     *
+     * @param {Object} meeting - the meeting object
+     * @returns {void}
+     */
+    init(meeting: any): void;
+    /**
+     * This method needs to be called whenever the local audio/video track has changed.
+     * It reapplies the remote mute state onto the new track and also reads the current
+     * local mute state from the track and updates the internal state machine and sends
+     * any required requests to the server.
+     *
+     * @param {Object} meeting - the meeting object
+     * @returns {void}
+     */
+    handleLocalTrackChange(meeting: any): void;
+    /**
+     * Mutes/unmutes local track
+     *
+     * @param {Object} meeting - the meeting object
+     * @param {Boolean} mute - true to mute the track, false to unmute it
+     * @param {ServerMuteReason} reason - reason for muting/unmuting
+     * @returns {void}
+     */
+    private muteLocalTrack;
     /**
      * Handles mute/unmute request from the client/user. Returns a promise that's resolved once the server update is completed or
      * at the point that this request becomese superseded by another client request.
@@ -30,16 +60,26 @@ declare class MuteState {
      * @param {Boolean} [mute] true for muting, false for unmuting request
      * @returns {Promise}
      */
-    handleClientRequest(meeting?: object, mute?: boolean): Promise<unknown>;
+    handleClientRequest(meeting: object, mute?: boolean): Promise<unknown>;
+    /**
+     * This method should be called when the local track mute state is changed
+     * @public
+     * @memberof MuteState
+     * @param {Object} [meeting] the meeting object
+     * @param {Boolean} [mute] true for muting, false for unmuting request
+     * @returns {void}
+     */
+    handleLocalTrackMuteStateChange(meeting?: object, mute?: boolean): void;
     /**
      * Applies the current mute state to the local track (by enabling or disabling it accordingly)
      *
      * @public
      * @param {Object} [meeting] the meeting object
+     * @param {ServerMuteReason} reason - reason why we're applying our client state to the local track
      * @memberof MuteState
      * @returns {void}
      */
-    applyClientStateLocally(meeting?: any): void;
+    applyClientStateLocally(meeting?: any, reason?: ServerMuteReason): void;
     /**
      * Updates the server local and remote mute values so that they match the current client desired state.
      *
@@ -67,16 +107,29 @@ declare class MuteState {
      * @returns {Promise}
      */
     private sendRemoteMuteRequestToServer;
+    /** Sets the mute state of the local track according to what server thinks is our state
+     * @param {Object} meeting - the meeting object
+     * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local track
+     * @returns {void}
+     */
+    private applyServerMuteToLocalTrack;
+    /** Applies the current value for unmute allowed to the underlying track
+     *
+     * @param {Meeting} meeting
+     * @returns {void}
+     */
+    private applyUnmuteAllowedToTrack;
     /**
      * This method should be called whenever the server remote mute state is changed
      *
      * @public
      * @memberof MuteState
+     * @param {Meeting} meeting
      * @param {Boolean} [muted] true if user is remotely muted, false otherwise
      * @param {Boolean} [unmuteAllowed] indicates if user is allowed to unmute self (false when "hard mute" feature is used)
      * @returns {undefined}
      */
-    handleServerRemoteMuteUpdate(muted?: boolean, unmuteAllowed?: boolean): void;
+    handleServerRemoteMuteUpdate(meeting: any, muted?: boolean, unmuteAllowed?: boolean): void;
     /**
      * This method should be called whenever we receive from the server a requirement to locally unmute
      *

package/dist/types/meetings/index.d.ts

@@ -60,6 +60,7 @@ export default class Meetings extends WebexPlugin {
     request: any;
     geoHintInfo: any;
     meetingInfo: any;
+    mediaHelpers: any;
     namespace: string;
     /**
      * Initializes the Meetings Plugin

package/dist/types/multistream/remoteMedia.d.ts

@@ -1,7 +1,7 @@
 import { MediaType, SourceState } from '@webex/internal-media-core';
 import EventsScope from '../common/events/events-scope';
 import { MediaRequestManager } from './mediaRequestManager';
-import { CSI, ReceiveSlot } from './receiveSlot';
+import { ReceiveSlot } from './receiveSlot';
 export declare const RemoteMediaEvents: {
     SourceUpdate: string;
     Stopped: string;
@@ -44,29 +44,6 @@ export declare class RemoteMedia extends EventsScope {
      * @param height height of the video element
      */
     setSizeHint(width: any, height: any): void;
-    /**
-     * Invalidates the remote media by clearing the reference to a receive slot and
-     * cancelling the media request.
-     * After this call the remote media is unusable.
-     *
-     * @param {boolean} commit - whether to commit the cancellation of the media request
-     * @internal
-     */
-    stop(commit?: boolean): void;
-    /**
-     * Sends a new media request. This method can only be used for receiver-selected policy,
-     * because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest
-     * and the request id is then stored in this RemoteMedia instance.
-     * For active-speaker policy, the same request is shared among many RemoteMedia instances,
-     * so it's managed through RemoteMediaGroup
-     *
-     * @internal
-     */
-    sendMediaRequest(csi: CSI, commit: boolean): void;
-    /**
-     * @internal
-     */
-    cancelMediaRequest(commit: boolean): void;
     /**
      * registers event listeners on the receive slot and forwards all the events
      */
@@ -91,10 +68,5 @@ export declare class RemoteMedia extends EventsScope {
      * Getter for remote media stream
      */
     get stream(): MediaStream;
-    /**
-     * @internal
-     * @returns {ReceiveSlot}
-     */
-    getUnderlyingReceiveSlot(): ReceiveSlot;
 }
 export {};

package/dist/types/multistream/remoteMediaGroup.d.ts

@@ -35,15 +35,6 @@ export declare class RemoteMediaGroup {
     isPinned(remoteMedia: RemoteMedia): boolean;
     private sendActiveSpeakerMediaRequest;
     private cancelActiveSpeakerMediaRequest;
-    /**
-     * Invalidates the remote media group by clearing the references to the receive slots
-     * used by all remote media from that group and cancelling all media requests.
-     * After this call the remote media group is unusable.
-     *
-     * @param{boolean} commit whether to commit the cancellation of media requests
-     * @internal
-     */
-    stop(commit?: boolean): void;
     /**
      * Checks if a given RemoteMedia instance belongs to this group.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.85",
+  "version": "3.0.0-beta.87",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -32,12 +32,12 @@
     "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.85",
-    "@webex/test-helper-chai": "3.0.0-beta.85",
-    "@webex/test-helper-mocha": "3.0.0-beta.85",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.85",
-    "@webex/test-helper-retry": "3.0.0-beta.85",
-    "@webex/test-helper-test-users": "3.0.0-beta.85",
+    "@webex/plugin-meetings": "3.0.0-beta.87",
+    "@webex/test-helper-chai": "3.0.0-beta.87",
+    "@webex/test-helper-mocha": "3.0.0-beta.87",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.87",
+    "@webex/test-helper-retry": "3.0.0-beta.87",
+    "@webex/test-helper-test-users": "3.0.0-beta.87",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -46,18 +46,19 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.85",
+    "@webex/common": "3.0.0-beta.87",
     "@webex/internal-media-core": "1.36.0",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.85",
-    "@webex/internal-plugin-device": "3.0.0-beta.85",
-    "@webex/internal-plugin-llm": "3.0.0-beta.85",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.85",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.85",
-    "@webex/internal-plugin-support": "3.0.0-beta.85",
-    "@webex/internal-plugin-user": "3.0.0-beta.85",
-    "@webex/plugin-people": "3.0.0-beta.85",
-    "@webex/plugin-rooms": "3.0.0-beta.85",
-    "@webex/webex-core": "3.0.0-beta.85",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.87",
+    "@webex/internal-plugin-device": "3.0.0-beta.87",
+    "@webex/internal-plugin-llm": "3.0.0-beta.87",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.87",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.87",
+    "@webex/internal-plugin-support": "3.0.0-beta.87",
+    "@webex/internal-plugin-user": "3.0.0-beta.87",
+    "@webex/media-helpers": "3.0.0-beta.87",
+    "@webex/plugin-people": "3.0.0-beta.87",
+    "@webex/plugin-rooms": "3.0.0-beta.87",
+    "@webex/webex-core": "3.0.0-beta.87",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",

package/src/{index.js → index.ts}

@@ -8,6 +8,21 @@ registerPlugin('meetings', Meetings, {
   config,
 });
 
+export {
+  LocalTrack,
+  LocalDisplayTrack,
+  LocalTrackEvents,
+  type TrackMuteEvent,
+  type ServerMuteReason,
+  LocalMicrophoneTrackEvents,
+  LocalCameraTrackEvents,
+  LocalMicrophoneTrack,
+  LocalCameraTrack,
+  createMicrophoneTrack,
+  createCameraTrack,
+  createDisplayTrack,
+} from '@webex/media-helpers';
+
 export default Meetings;
 
 export * as CONSTANTS from './constants';

package/src/media/index.ts

@@ -3,13 +3,8 @@
  */
 /* globals navigator */
 
-import {
-  LocalCameraTrack,
-  LocalDisplayTrack,
-  LocalMicrophoneTrack,
-  RoapMediaConnection,
-  MultistreamRoapMediaConnection,
-} from '@webex/internal-media-core';
+import {RoapMediaConnection, MultistreamRoapMediaConnection} from '@webex/internal-media-core';
+import {LocalCameraTrack, LocalDisplayTrack, LocalMicrophoneTrack} from '@webex/media-helpers';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {AUDIO_INPUT, VIDEO_INPUT, MEDIA_TRACK_CONSTRAINT} from '../constants';
 import Config from '../config';
@@ -19,6 +14,8 @@ import BrowserDetection from '../common/browser-detection';
 
 const {isBrowser} = BrowserDetection();
 
+type MultistreamConnectionConfig = ConstructorParameters<typeof MultistreamRoapMediaConnection>[0];
+
 export type BundlePolicy = ConstructorParameters<
   typeof MultistreamRoapMediaConnection
 >[0]['bundlePolicy'];
@@ -166,17 +163,19 @@ Media.createMediaConnection = (
   }
 
   if (isMultistream) {
-    return new MultistreamRoapMediaConnection(
-      {
-        iceServers,
-        enableMainAudio:
-          mediaProperties.mediaDirection?.sendAudio || mediaProperties.mediaDirection?.receiveAudio,
-        enableMainVideo:
-          mediaProperties.mediaDirection?.sendVideo || mediaProperties.mediaDirection?.receiveVideo,
-        bundlePolicy,
-      },
-      debugId
-    );
+    const config: MultistreamConnectionConfig = {
+      iceServers,
+      enableMainAudio:
+        mediaProperties.mediaDirection?.sendAudio || mediaProperties.mediaDirection?.receiveAudio,
+      enableMainVideo:
+        mediaProperties.mediaDirection?.sendVideo || mediaProperties.mediaDirection?.receiveVideo,
+    };
+
+    if (bundlePolicy) {
+      config.bundlePolicy = bundlePolicy;
+    }
+
+    return new MultistreamRoapMediaConnection(config, debugId);
   }
 
   if (!mediaProperties) {

package/src/media/properties.ts

@@ -1,10 +1,6 @@
-import {
-  ConnectionState,
-  Event,
-  LocalCameraTrack,
-  LocalMicrophoneTrack,
-  LocalDisplayTrack,
-} from '@webex/internal-media-core';
+import {ConnectionState, Event} from '@webex/internal-media-core';
+
+import {LocalCameraTrack, LocalMicrophoneTrack, LocalDisplayTrack} from '@webex/media-helpers';
 
 import {MEETINGS, PC_BAIL_TIMEOUT, QUALITY_LEVELS} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';

package/src/meeting/index.ts

@@ -7,13 +7,18 @@ import {
   Errors,
   ErrorType,
   Event,
+  MediaType,
+  RemoteTrackType,
+} from '@webex/internal-media-core';
+
+import {
+  LocalTrack,
   LocalCameraTrack,
   LocalDisplayTrack,
   LocalMicrophoneTrack,
   LocalTrackEvents,
-  MediaType,
-  RemoteTrackType,
-} from '@webex/internal-media-core';
+  TrackMuteEvent,
+} from '@webex/media-helpers';
 
 import {
   MeetingNotActiveError,
@@ -519,6 +524,8 @@ export default class Meeting extends StatelessWebexPlugin {
   resourceUrl: string;
   selfId: string;
   state: any;
+  localAudioTrackMuteStateHandler: (event: TrackMuteEvent) => void;
+  localVideoTrackMuteStateHandler: (event: TrackMuteEvent) => void;
   webexMeetingId: string;
 
   namespace = MEETINGS;
@@ -1163,6 +1170,14 @@ export default class Meeting extends StatelessWebexPlugin {
      * helper class for managing remote streams
      */
     this.remoteMediaManager = null;
+
+    this.localAudioTrackMuteStateHandler = (event) => {
+      this.audio.handleLocalTrackMuteStateChange(this, event.trackState.muted);
+    };
+
+    this.localVideoTrackMuteStateHandler = (event) => {
+      this.video.handleLocalTrackMuteStateChange(this, event.trackState.muted);
+    };
   }
 
   /**
@@ -2056,14 +2071,14 @@ export default class Meeting extends StatelessWebexPlugin {
         this.selfId === contentShare.beneficiaryId &&
         contentShare.disposition === FLOOR_ACTION.GRANTED
       ) {
-        // @ts-ignore originalTrack is private - this will be fixed when SPARK-399694 are SPARK-399695 done
+        // @ts-ignore originalTrack is private - this will be fixed when SPARK-399695 is done
         const localShareTrack = this.mediaProperties.shareTrack?.originalTrack;
 
         // todo: remove this block of code and instead make sure we have LocalTrackEvents.Ended listener always registered (SPARK-399695)
         if (localShareTrack?.readyState === 'ended') {
           try {
             if (this.isMultistream) {
-              await this.unpublishTracks([localShareTrack]); // todo screen share audio (SPARK-399690)
+              await this.unpublishTracks([this.mediaProperties.shareTrack]); // todo screen share audio (SPARK-399690)
             } else {
               await this.stopShare({
                 skipSignalingCheck: true,
@@ -2173,8 +2188,7 @@ export default class Meeting extends StatelessWebexPlugin {
                 oldShareStatus === SHARE_STATUS.LOCAL_SHARE_ACTIVE
               ) {
                 if (this.isMultistream) {
-                  // @ts-ignore originalTrack is private - this will be fixed in SPARK-399694
-                  await this.unpublishTracks([this.mediaProperties.shareTrack?.originalTrack]); // todo screen share audio (SPARK-399690)
+                  await this.unpublishTracks([this.mediaProperties.shareTrack]); // todo screen share audio (SPARK-399690)
                 } else {
                   await this.updateShare({
                     sendShare: false,
@@ -2491,7 +2505,7 @@ export default class Meeting extends StatelessWebexPlugin {
         if (this.video) {
           payload.muted = payload.muted ?? this.video.isRemotelyMuted();
           payload.unmuteAllowed = payload.unmuteAllowed ?? this.video.isUnmuteAllowed();
-          this.video.handleServerRemoteMuteUpdate(payload.muted, payload.unmuteAllowed);
+          this.video.handleServerRemoteMuteUpdate(this, payload.muted, payload.unmuteAllowed);
         }
         Trigger.trigger(
           this,
@@ -2512,7 +2526,7 @@ export default class Meeting extends StatelessWebexPlugin {
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED, (payload) => {
       if (payload) {
         if (this.audio) {
-          this.audio.handleServerRemoteMuteUpdate(payload.muted, payload.unmuteAllowed);
+          this.audio.handleServerRemoteMuteUpdate(this, payload.muted, payload.unmuteAllowed);
         }
         // with "mute on entry" server will send us remote mute even if we don't have media configured,
         // so if being muted by others, always send the notification,
@@ -3223,6 +3237,10 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   private setLocalAudioTrack(rawAudioTrack: MediaStreamTrack | null, emitEvent = true) {
+    if (this.isMultistream) {
+      throw new Error('this method is only supposed to be used for transcoded meetings');
+    }
+
     if (rawAudioTrack) {
       const settings = rawAudioTrack.getSettings();
 
@@ -3259,6 +3277,10 @@ export default class Meeting extends StatelessWebexPlugin {
    * @memberof Meeting
    */
   private setLocalVideoTrack(rawVideoTrack: MediaStreamTrack | null, emitEvent = true) {
+    if (this.isMultistream) {
+      throw new Error('this method is only supposed to be used for transcoded meetings');
+    }
+
     if (rawVideoTrack) {
       const {aspectRatio, frameRate, height, width, deviceId} = rawVideoTrack.getSettings();
 
@@ -3372,7 +3394,7 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     } else if (this.mediaProperties.shareTrack) {
       this.mediaProperties.shareTrack.off(LocalTrackEvents.Ended, this.handleShareTrackEnded);
-      this.mediaProperties.shareTrack.stop(); // todo: this line should be removed once SPARK-399694 are SPARK-399695 are done
+      this.mediaProperties.shareTrack.stop(); // todo: this line should be removed once SPARK-399695 is done
       this.mediaProperties.setLocalShareTrack(null);
     }
   }
@@ -5775,7 +5797,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
         // audio state could be undefined if you have not sent audio before
         this.audio =
-          this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection);
+          this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection, true);
       });
   }
 
@@ -5831,7 +5853,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
         // video state could be undefined if you have not sent video before
         this.video =
-          this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection);
+          this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection, true);
       });
   }
 
@@ -5947,10 +5969,14 @@ export default class Meeting extends StatelessWebexPlugin {
     // TODO wire into default config. There's currently an issue with the stateless plugin or how we register
     // @ts-ignore - config coming from registerPlugin
     this.mediaProperties.setMediaDirection(Object.assign(this.config.mediaSettings, mediaSettings));
-    // add a setup a function move the create and setup media in future
-    // TODO: delete old audio and video if stale
-    this.audio = this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection);
-    this.video = this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection);
+
+    // for multistream, this.audio and this.video are created when publishTracks() is called
+    if (!this.isMultistream) {
+      this.audio =
+        this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection, true);
+      this.video =
+        this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection, true);
+    }
     // Validation is already done in addMedia so no need to check if the lenght is greater then 0
     this.setLocalTracks(localStream);
     if (this.isMultistream && localShare) {
@@ -6802,7 +6828,10 @@ export default class Meeting extends StatelessWebexPlugin {
           error
         );
       } finally {
-        this.setLocalShareTrack(null);
+        // todo: once SPARK-399695 is done, we will be able to just call this.setLocalShareTrack(null); here instead of the next 2 lines:
+        this.mediaProperties.shareTrack?.off(LocalTrackEvents.Ended, this.handleShareTrackEnded);
+        this.mediaProperties.setLocalShareTrack(null);
+
         this.mediaProperties.mediaDirection.sendShare = false;
       }
     } else {
@@ -7265,18 +7294,29 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {Promise}
    */
   async publishTracks(tracks: {
-    microphone?: MediaStreamTrack;
-    camera?: MediaStreamTrack;
+    microphone?: LocalMicrophoneTrack;
+    camera?: LocalCameraTrack;
     screenShare: {
-      audio?: MediaStreamTrack; // todo: for now screen share audio is not supported (will be done in SPARK-399690)
-      video?: MediaStreamTrack;
+      audio?: LocalTrack; // todo: for now screen share audio is not supported (will be done in SPARK-399690)
+      video?: LocalDisplayTrack;
     };
   }): Promise<void> {
     this.checkMediaConnection();
 
+    if (!this.isMultistream) {
+      throw new Error('publishTracks() only supported with multistream');
+    }
+
     if (tracks.screenShare?.video) {
+      const oldTrack = this.mediaProperties.shareTrack;
+      const localDisplayTrack = tracks.screenShare?.video;
+
+      oldTrack?.off(LocalTrackEvents.Ended, this.handleShareTrackEnded);
+
       // we are starting a screen share
-      this.setLocalShareTrack(tracks.screenShare.video);
+      this.mediaProperties.setLocalShareTrack(localDisplayTrack);
+
+      localDisplayTrack.on(LocalTrackEvents.Ended, this.handleShareTrackEnded);
 
       await this.requestScreenShareFloor();
       this.mediaProperties.mediaDirection.sendShare = true;
@@ -7287,11 +7327,22 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     if (tracks.microphone) {
-      this.setLocalAudioTrack(tracks.microphone);
+      const oldTrack = this.mediaProperties.audioTrack;
+      const localTrack = tracks.microphone;
+
+      oldTrack?.off(LocalTrackEvents.Muted, this.localAudioTrackMuteStateHandler);
+
+      this.mediaProperties.setLocalAudioTrack(localTrack);
       this.mediaProperties.mediaDirection.sendAudio = true;
 
       // audio mute state could be undefined if you have not sent audio before
-      this.audio = this.audio || createMuteState(AUDIO, this, this.mediaProperties.mediaDirection);
+      if (!this.audio) {
+        this.audio = createMuteState(AUDIO, this, this.mediaProperties.mediaDirection, false);
+      } else {
+        this.audio.handleLocalTrackChange(this);
+      }
+
+      localTrack.on(LocalTrackEvents.Muted, this.localAudioTrackMuteStateHandler);
 
       await this.mediaProperties.webrtcMediaConnection.publishTrack(
         this.mediaProperties.audioTrack
@@ -7299,11 +7350,22 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     if (tracks.camera) {
-      this.setLocalVideoTrack(tracks.camera);
+      const oldTrack = this.mediaProperties.videoTrack;
+      const localTrack = tracks.camera;
+
+      oldTrack?.off(LocalTrackEvents.Muted, this.localVideoTrackMuteStateHandler);
+
+      this.mediaProperties.setLocalVideoTrack(localTrack);
       this.mediaProperties.mediaDirection.sendVideo = true;
 
       // video state could be undefined if you have not sent video before
-      this.video = this.video || createMuteState(VIDEO, this, this.mediaProperties.mediaDirection);
+      if (!this.video) {
+        this.video = createMuteState(VIDEO, this, this.mediaProperties.mediaDirection, false);
+      } else {
+        this.video.handleLocalTrackChange(this);
+      }
+
+      localTrack.on(LocalTrackEvents.Muted, this.localVideoTrackMuteStateHandler);
 
       await this.mediaProperties.webrtcMediaConnection.publishTrack(
         this.mediaProperties.videoTrack
@@ -7317,48 +7379,43 @@ export default class Meeting extends StatelessWebexPlugin {
    * @param {Array<MediaStreamTrack>} tracks
    * @returns {Promise}
    */
-  async unpublishTracks(tracks: MediaStreamTrack[]): Promise<void> {
+  async unpublishTracks(tracks: LocalTrack[]): Promise<void> {
     this.checkMediaConnection();
 
+    if (!this.isMultistream) {
+      throw new Error('unpublishTracks() is only supported with multistream');
+    }
+
     const unpublishPromises = [];
 
-    for (const track of tracks) {
-      // @ts-ignore originalTrack is private - this will be fixed in SPARK-399694
-      if (track === this.mediaProperties.shareTrack?.originalTrack) {
-        const localTrackToUnpublish = this.mediaProperties.shareTrack;
+    for (const track of tracks.filter((t) => !!t)) {
+      if (track === this.mediaProperties.shareTrack) {
+        this.mediaProperties.setLocalShareTrack(null);
 
-        this.setLocalShareTrack(null);
+        track.off(LocalTrackEvents.Ended, this.handleShareTrackEnded);
 
         this.releaseScreenShareFloor(); // we ignore the returned promise here on purpose
         this.mediaProperties.mediaDirection.sendShare = false;
 
-        unpublishPromises.push(
-          this.mediaProperties.webrtcMediaConnection.unpublishTrack(localTrackToUnpublish)
-        );
+        unpublishPromises.push(this.mediaProperties.webrtcMediaConnection.unpublishTrack(track));
       }
 
-      // @ts-ignore originalTrack is private - this will be fixed in SPARK-399694
-      if (track === this.mediaProperties.audioTrack?.originalTrack) {
-        const localTrackToUnpublish = this.mediaProperties.audioTrack;
-
-        this.setLocalAudioTrack(null);
+      if (track === this.mediaProperties.audioTrack) {
+        this.mediaProperties.setLocalAudioTrack(null);
         this.mediaProperties.mediaDirection.sendAudio = false;
 
-        unpublishPromises.push(
-          this.mediaProperties.webrtcMediaConnection.unpublishTrack(localTrackToUnpublish)
-        );
-      }
+        track.off(LocalTrackEvents.Muted, this.localAudioTrackMuteStateHandler);
 
-      // @ts-ignore originalTrack is private - this will be fixed in SPARK-399694
-      if (track === this.mediaProperties.videoTrack?.originalTrack) {
-        const localTrackToUnpublish = this.mediaProperties.videoTrack;
+        unpublishPromises.push(this.mediaProperties.webrtcMediaConnection.unpublishTrack(track));
+      }
 
-        this.setLocalVideoTrack(null);
+      if (track === this.mediaProperties.videoTrack) {
+        this.mediaProperties.setLocalVideoTrack(null);
         this.mediaProperties.mediaDirection.sendVideo = false;
 
-        unpublishPromises.push(
-          this.mediaProperties.webrtcMediaConnection.unpublishTrack(localTrackToUnpublish)
-        );
+        track.off(LocalTrackEvents.Muted, this.localVideoTrackMuteStateHandler);
+
+        unpublishPromises.push(this.mediaProperties.webrtcMediaConnection.unpublishTrack(track));
       }
     }