@webex/plugin-meetings 3.0.0-beta.397 → 3.0.0-beta.399

package/src/meeting/muteState.ts

@@ -150,15 +150,30 @@ export class MuteState {
    * @param {Boolean} [mute] true for muting, false for unmuting request
    * @returns {void}
    */
-  public handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean) {
+  public handleLocalStreamMuteStateChange(meeting?: any) {
     if (this.ignoreMuteStateChange) {
       return;
     }
+
+    // either user or system may have triggered a mute state change, but localMute should reflect both
+    let newMuteState: boolean;
+    let userMuteState: boolean;
+    let systemMuteState: boolean;
+    if (this.type === AUDIO) {
+      newMuteState = meeting.mediaProperties.audioStream?.muted;
+      userMuteState = meeting.mediaProperties.audioStream?.userMuted;
+      systemMuteState = meeting.mediaProperties.audioStream?.systemMuted;
+    } else {
+      newMuteState = meeting.mediaProperties.videoStream?.muted;
+      userMuteState = meeting.mediaProperties.videoStream?.userMuted;
+      systemMuteState = meeting.mediaProperties.videoStream?.systemMuted;
+    }
+
     LoggerProxy.logger.info(
-      `Meeting:muteState#handleLocalStreamMuteStateChange --> ${this.type}: local stream new mute state: ${mute}`
+      `Meeting:muteState#handleLocalStreamMuteStateChange --> ${this.type}: local stream new mute state: ${newMuteState} (user mute: ${userMuteState}, system mute: ${systemMuteState})`
     );
 
-    this.state.client.localMute = mute;
+    this.state.client.localMute = newMuteState;
 
     this.applyClientStateToServer(meeting);
   }
@@ -249,7 +264,12 @@ export class MuteState {
           `Meeting:muteState#applyClientStateToServer --> ${this.type}: error: ${e}`
         );
 
-        this.applyServerMuteToLocalStream(meeting, 'clientRequestFailed');
+        // failed to apply client state to server, so revert stream mute state to server state
+        this.muteLocalStream(
+          meeting,
+          this.state.server.localMute || this.state.server.remoteMute,
+          'clientRequestFailed'
+        );
       });
   }
 
@@ -325,18 +345,6 @@ export class MuteState {
       });
   }
 
-  /** Sets the mute state of the local stream 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 stream
-   * @returns {void}
-   */
-  private applyServerMuteToLocalStream(meeting: any, serverMuteReason: ServerMuteReason) {
-    const muted = this.state.server.localMute || this.state.server.remoteMute;
-
-    // update the local stream mute state, but not this.state.client.localMute
-    this.muteLocalStream(meeting, muted, serverMuteReason);
-  }
-
   /** Applies the current value for unmute allowed to the underlying stream
    *
    * @param {Meeting} meeting
@@ -371,7 +379,7 @@ export class MuteState {
     }
     if (muted !== undefined) {
       this.state.server.remoteMute = muted;
-      this.applyServerMuteToLocalStream(meeting, 'remotelyMuted');
+      this.muteLocalStream(meeting, muted, 'remotelyMuted');
     }
   }
 
@@ -383,7 +391,7 @@ export class MuteState {
    * @param {Object} [meeting] the meeting object
    * @returns {undefined}
    */
-  public handleServerLocalUnmuteRequired(meeting?: object) {
+  public handleServerLocalUnmuteRequired(meeting?: any) {
     if (!this.state.client.enabled) {
       LoggerProxy.logger.warn(
         `Meeting:muteState#handleServerLocalUnmuteRequired --> ${this.type}: localAudioUnmuteRequired received while ${this.type} is disabled -> local unmute will not result in ${this.type} being sent`
@@ -396,9 +404,15 @@ export class MuteState {
 
     // todo: I'm seeing "you can now unmute yourself " popup  when this happens - but same thing happens on web.w.c so we can ignore for now
     this.state.server.remoteMute = false;
-    this.state.client.localMute = false;
 
-    this.applyClientStateLocally(meeting, 'localUnmuteRequired');
+    // change user mute state to false, but keep localMute true if overall mute state is still true
+    this.muteLocalStream(meeting, false, 'localUnmuteRequired');
+    if (this.type === AUDIO) {
+      this.state.client.localMute = meeting.mediaProperties.audioStream?.muted;
+    } else {
+      this.state.client.localMute = meeting.mediaProperties.videoStream?.muted;
+    }
+
     this.applyClientStateToServer(meeting);
   }
 

package/test/integration/spec/journey.js

@@ -432,11 +432,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.microphone.setMuted(true);
+        localStreams.alice.microphone.setUserMuted(true);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.microphone.muted, true);
+        assert.equal(localStreams.alice.microphone.userMuted, true);
       });
 
       it('alice Audio unMute ', async () => {
@@ -451,11 +451,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.microphone.setMuted(false);
+        localStreams.alice.microphone.setUserMuted(false);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.microphone.muted, false);
+        assert.equal(localStreams.alice.microphone.userMuted, false);
       });
 
       it('alice video mute', async () => {
@@ -470,11 +470,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.camera.setMuted(true);
+        localStreams.alice.camera.setUserMuted(true);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.camera.muted, true);
+        assert.equal(localStreams.alice.camera.userMuted, true);
       });
 
       it('alice video unmute', async () => {
@@ -489,11 +489,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: bob.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.alice.camera.setMuted(false);
+        localStreams.alice.camera.setUserMuted(false);
 
         await membersUpdate;
 
-        assert.equal(localStreams.alice.camera.muted, false);
+        assert.equal(localStreams.alice.camera.userMuted, false);
       });
 
       it('alice update Audio', async () => {
@@ -574,11 +574,11 @@ skipInNode(describe)('plugin-meetings', () => {
         ]);
 
         // first bob mutes himself
-        localStreams.bob.microphone.setMuted(true);
+        localStreams.bob.microphone.setUserMuted(true);
 
         await membersUpdate;
 
-        assert.equal(localStreams.bob.microphone.muted, true);
+        assert.equal(localStreams.bob.microphone.userMuted, true);
 
         // now alice tries to unmmute bob
         await testUtils.delayedPromise(alice.meeting.mute(bob.meeting.members.selfId, false))
@@ -593,7 +593,7 @@ skipInNode(describe)('plugin-meetings', () => {
             assert.fail('bob received unexpected meeting:self:unmutedByOthers event');
           })
           .catch(() => {
-            assert.equal(localStreams.bob.microphone.muted, true);
+            assert.equal(localStreams.bob.microphone.userMuted, true);
           });
       });
 
@@ -607,11 +607,11 @@ skipInNode(describe)('plugin-meetings', () => {
           {scope: alice.meeting.members, event: 'members:update', match: checkEvent},
         ]);
 
-        localStreams.bob.microphone.setMuted(false);
+        localStreams.bob.microphone.setUserMuted(false);
 
         await membersUpdate;
 
-        assert.equal(localStreams.bob.microphone.muted, false);
+        assert.equal(localStreams.bob.microphone.userMuted, false);
       });
 
       it('alice shares the screen with highFrameRate', async () => {

package/test/unit/spec/meeting/index.js

@@ -43,7 +43,7 @@ import {
   RemoteTrackType,
   MediaType,
 } from '@webex/internal-media-core';
-import {StreamEventNames} from '@webex/media-helpers';
+import {LocalStreamEventNames} from '@webex/media-helpers';
 import * as StatsAnalyzerModule from '@webex/plugin-meetings/src/statsAnalyzer';
 import EventsScope from '@webex/plugin-meetings/src/common/events/events-scope';
 import Meetings, {CONSTANTS} from '@webex/plugin-meetings';
@@ -99,7 +99,6 @@ import {
   MeetingInfoV2PolicyError,
 } from '../../../../src/meeting-info/meeting-info-v2';
 import {
-  CLIENT_ERROR_CODE_TO_ERROR_PAYLOAD,
   DTLS_HANDSHAKE_FAILED_CLIENT_CODE,
   ICE_FAILED_WITHOUT_TURN_TLS_CLIENT_CODE,
   ICE_FAILED_WITH_TURN_TLS_CLIENT_CODE,
@@ -1548,7 +1547,6 @@ describe('plugin-meetings', () => {
       describe('#addMedia', () => {
         const muteStateStub = {
           handleClientRequest: sinon.stub().returns(Promise.resolve(true)),
-          applyClientStateLocally: sinon.stub().returns(Promise.resolve(true)),
         };
 
         let fakeMediaConnection;
@@ -3028,9 +3026,13 @@ describe('plugin-meetings', () => {
               getSettings: sinon.stub().returns({
                 deviceId: 'some device id',
               }),
-              muted: false,
+              userMuted: false,
+              systemMuted: false,
+              get muted() {
+                return this.userMuted || this.systemMuted;
+              },
               setUnmuteAllowed: sinon.stub(),
-              setMuted: sinon.stub(),
+              setUserMuted: sinon.stub(),
               setServerMuted: sinon.stub(),
               outputStream: {
                 getTracks: () => {
@@ -3265,28 +3267,50 @@ describe('plugin-meetings', () => {
                 if (stream !== undefined) {
                   switch (type) {
                     case 'audio':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream);
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioMain).publishStream,
+                          stream
+                        );
+                      }
                       break;
                     case 'video':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.VideoMain).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoMain).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoMain).publishStream,
+                          stream
+                        );
+                      }
                       break;
                     case 'screenShareAudio':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.AudioSlides).publishStream,
+                          stream
+                        );
+                      }
                       break;
                     case 'screenShareVideo':
-                      assert.calledOnceWithExactly(
-                        meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream,
-                        stream
-                      );
+                      if (stream?.readyState === 'ended') {
+                        assert.notCalled(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream
+                        );
+                      } else {
+                        assert.calledOnceWithExactly(
+                          meeting.sendSlotManager.getSlot(MediaType.VideoSlides).publishStream,
+                          stream
+                        );
+                      }
                       break;
                   }
                 }
@@ -3314,7 +3338,7 @@ describe('plugin-meetings', () => {
             }
           };
 
-          it('addMedia() works correctly when media is enabled without tracks to publish', async () => {
+          it('addMedia() works correctly when media is enabled without streams to publish', async () => {
             await meeting.addMedia();
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3380,8 +3404,76 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when media is enabled with tracks to publish and track is muted', async () => {
-            fakeMicrophoneStream.muted = true;
+          it('addMedia() works correctly when media is enabled with streams to publish and stream is user muted', async () => {
+            fakeMicrophoneStream.userMuted = true;
+
+            await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
+            await simulateRoapOffer();
+            await simulateRoapOk();
+
+            // check RoapMediaConnection was created correctly
+            checkMediaConnectionCreated({
+              mediaConnectionConfig: expectedMediaConnectionConfig,
+              localStreams: {
+                audio: fakeMicrophoneStream,
+                video: undefined,
+                screenShareVideo: undefined,
+                screenShareAudio: undefined,
+              },
+              direction: {
+                audio: 'sendrecv',
+                video: 'sendrecv',
+                screenShare: 'recvonly',
+              },
+              remoteQualityLevel: 'HIGH',
+              expectedDebugId,
+              meetingId: meeting.id,
+            });
+            // and SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+            // check OK was sent with the right audioMuted/videoMuted values
+            checkOkSent({audioMuted: true, videoMuted: true});
+
+            // and that these were the only /media requests that were sent
+            assert.calledTwice(locusMediaRequestStub);
+          });
+
+          it('addMedia() works correctly when media is enabled with tracks to publish and track is ended', async () => {
+            fakeMicrophoneStream.readyState = 'ended';
+
+            await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
+            await simulateRoapOffer();
+            await simulateRoapOk();
+
+            // check RoapMediaConnection was created correctly
+            checkMediaConnectionCreated({
+              mediaConnectionConfig: expectedMediaConnectionConfig,
+              localStreams: {
+                audio: undefined,
+                video: undefined,
+                screenShareVideo: undefined,
+                screenShareAudio: undefined,
+              },
+              direction: {
+                audio: 'sendrecv',
+                video: 'sendrecv',
+                screenShare: 'recvonly',
+              },
+              remoteQualityLevel: 'HIGH',
+              expectedDebugId,
+              meetingId: meeting.id,
+            });
+            // and SDP offer was sent with the right audioMuted/videoMuted values
+            checkSdpOfferSent({audioMuted: true, videoMuted: true});
+            // check OK was sent with the right audioMuted/videoMuted values
+            checkOkSent({audioMuted: true, videoMuted: true});
+
+            // and that these were the only /media requests that were sent
+            assert.calledTwice(locusMediaRequestStub);
+          });
+
+          it('addMedia() works correctly when media is enabled with streams to publish and stream is system muted', async () => {
+            fakeMicrophoneStream.systemMuted = true;
 
             await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
             await simulateRoapOffer();
@@ -3414,7 +3506,7 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when media is disabled with tracks to publish', async () => {
+          it('addMedia() works correctly when media is disabled with streams to publish', async () => {
             await meeting.addMedia({
               localStreams: {microphone: fakeMicrophoneStream},
               audioEnabled: false,
@@ -3450,7 +3542,7 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when media is disabled with no tracks to publish', async () => {
+          it('addMedia() works correctly when media is disabled with no streams to publish', async () => {
             await meeting.addMedia({audioEnabled: false});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3483,7 +3575,7 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when video is disabled with no tracks to publish', async () => {
+          it('addMedia() works correctly when video is disabled with no streams to publish', async () => {
             await meeting.addMedia({videoEnabled: false});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3516,7 +3608,7 @@ describe('plugin-meetings', () => {
             assert.calledTwice(locusMediaRequestStub);
           });
 
-          it('addMedia() works correctly when screen share is disabled with no tracks to publish', async () => {
+          it('addMedia() works correctly when screen share is disabled with no streams to publish', async () => {
             await meeting.addMedia({shareAudioEnabled: false, shareVideoEnabled: false});
             await simulateRoapOffer();
             await simulateRoapOk();
@@ -3617,9 +3709,13 @@ describe('plugin-meetings', () => {
                 const fakeMicrophoneStream2 = {
                   on: sinon.stub(),
                   off: sinon.stub(),
-                  muted: false,
+                  userMuted: false,
+                  systemMuted: false,
+                  get muted() {
+                    return this.userMuted || this.systemMuted;
+                  },
                   setUnmuteAllowed: sinon.stub(),
-                  setMuted: sinon.stub(),
+                  setUserMuted: sinon.stub(),
                   outputStream: {
                     getTracks: () => {
                       return [
@@ -3856,12 +3952,55 @@ describe('plugin-meetings', () => {
           });
 
           [
-            {mute: true, title: 'muting a track before confluence is created'},
-            {mute: false, title: 'unmuting a track before confluence is created'},
+            {mute: true, title: 'user muting a track before confluence is created'},
+            {mute: false, title: 'user unmuting a track before confluence is created'},
+          ].forEach(({mute, title}) =>
+            it(title, async () => {
+              // initialize the microphone mute state to opposite of what we do in the test
+              fakeMicrophoneStream.userMuted = !mute;
+
+              await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
+              await stableState();
+
+              resetHistory();
+
+              assert.equal(
+                fakeMicrophoneStream.on.getCall(0).args[0],
+                LocalStreamEventNames.UserMuteStateChange
+              );
+              const mutedListener = fakeMicrophoneStream.on.getCall(0).args[1];
+              // simulate track being muted
+              fakeMicrophoneStream.userMuted = mute;
+              mutedListener(mute);
+
+              await stableState();
+
+              // nothing should happen
+              assert.notCalled(locusMediaRequestStub);
+              assert.notCalled(fakeRoapMediaConnection.update);
+
+              // now simulate roap offer and ok
+              await simulateRoapOffer();
+              await simulateRoapOk();
+
+              // it should be sent with the right mute status
+              checkSdpOfferSent({audioMuted: mute, videoMuted: true});
+              // check OK was sent with the right audioMuted/videoMuted values
+              checkOkSent({audioMuted: mute, videoMuted: true});
+
+              // nothing else should happen
+              assert.calledTwice(locusMediaRequestStub);
+              assert.notCalled(fakeRoapMediaConnection.update);
+            })
+          );
+
+          [
+            {mute: true, title: 'system muting a track before confluence is created'},
+            {mute: false, title: 'system unmuting a track before confluence is created'},
           ].forEach(({mute, title}) =>
             it(title, async () => {
               // initialize the microphone mute state to opposite of what we do in the test
-              fakeMicrophoneStream.muted = !mute;
+              fakeMicrophoneStream.systemMuted = !mute;
 
               await meeting.addMedia({localStreams: {microphone: fakeMicrophoneStream}});
               await stableState();
@@ -3870,10 +4009,11 @@ describe('plugin-meetings', () => {
 
               assert.equal(
                 fakeMicrophoneStream.on.getCall(0).args[0],
-                StreamEventNames.MuteStateChange
+                LocalStreamEventNames.UserMuteStateChange
               );
               const mutedListener = fakeMicrophoneStream.on.getCall(0).args[1];
               // simulate track being muted
+              fakeMicrophoneStream.systemMuted = mute;
               mutedListener(mute);
 
               await stableState();
@@ -6274,6 +6414,65 @@ describe('plugin-meetings', () => {
             checkScreenShareVideoPublished(videoShareStream);
             checkScreenShareAudioPublished(audioShareStream);
           });
+
+          [
+            {
+              endedStream: 'microphone', 
+              streams: {
+                microphone: {
+                  readyState: 'ended',
+                },
+                camera: undefined,
+                screenShare: {
+                  audio: undefined,
+                  video: undefined,
+                },
+              },
+            },
+            {
+              endedStream: 'camera', 
+              streams: {
+                microphone: undefined,
+                camera: {
+                  readyState: 'ended',
+                },
+                screenShare: {
+                  audio: undefined,
+                  video: undefined,
+                },
+              },
+            },
+            {
+              endedStream: 'screenShare audio', 
+              streams: {
+                microphone: undefined,
+                camera: undefined,
+                screenShare: {
+                  audio: {
+                    readyState: 'ended',
+                  },
+                  video: undefined,
+                },
+              },
+            },
+            {
+              endedStream: 'screenShare video', 
+              streams: {
+                microphone: undefined,
+                camera: undefined,
+                screenShare: {
+                  audio: undefined,
+                  video: {
+                    readyState: 'ended',
+                  },
+                },
+              },
+            },
+          ].forEach(({endedStream, streams}) => {
+            it(`throws error if readyState of ${endedStream} is ended`, async () => {
+              assert.isRejected(meeting.publishStreams(streams));
+            })
+          });
         });
 
         describe('unpublishStreams', () => {
@@ -6408,11 +6607,11 @@ describe('plugin-meetings', () => {
         meeting.sendSlotManager.setNamedMediaGroups = sinon.stub().returns(undefined);
       });
       it('should throw error if not audio type', () => {
-        expect(() => meeting.setSendNamedMediaGroup(MediaType.VideoMain, 20)).to.throw(`cannot set send named media group which media type is ${MediaType.VideoMain}`)
-
+        expect(() => meeting.setSendNamedMediaGroup(MediaType.VideoMain, 20)).to.throw(
+          `cannot set send named media group which media type is ${MediaType.VideoMain}`
+        );
       });
       it('fails if there is no media connection', () => {
-
         meeting.mediaProperties.webrtcMediaConnection = undefined;
         meeting.setSendNamedMediaGroup('AUDIO-MAIN', 20);
         assert.notCalled(meeting.sendSlotManager.setNamedMediaGroups);
@@ -6421,8 +6620,10 @@ describe('plugin-meetings', () => {
       it('success if there is media connection', () => {
         meeting.isMultistream = true;
         meeting.mediaProperties.webrtcMediaConnection = true;
-        meeting.setSendNamedMediaGroup("AUDIO-MAIN", 20);
-        assert.calledOnceWithExactly(meeting.sendSlotManager.setNamedMediaGroups, "AUDIO-MAIN", [{type: 1, value: 20}]);
+        meeting.setSendNamedMediaGroup('AUDIO-MAIN', 20);
+        assert.calledOnceWithExactly(meeting.sendSlotManager.setNamedMediaGroups, 'AUDIO-MAIN', [
+          {type: 1, value: 20},
+        ]);
       });
     });