@webex/plugin-meetings 3.7.0-next.9 → 3.7.0-wxcc.1

package/src/multistream/remoteMedia.ts

@@ -19,6 +19,14 @@ export type RemoteVideoResolution =
   | 'large' // 1080p or less
   | 'best'; // highest possible resolution
 
+const MAX_FS_VALUES = {
+  '90p': 60,
+  '180p': 240,
+  '360p': 920,
+  '720p': 3600,
+  '1080p': 8192,
+};
+
 /**
  * Converts pane size into h264 maxFs
  * @param {PaneSize} paneSize
@@ -29,28 +37,28 @@ export function getMaxFs(paneSize: RemoteVideoResolution): number {
 
   switch (paneSize) {
     case 'thumbnail':
-      maxFs = 60;
+      maxFs = MAX_FS_VALUES['90p'];
       break;
     case 'very small':
-      maxFs = 240;
+      maxFs = MAX_FS_VALUES['180p'];
       break;
     case 'small':
-      maxFs = 920;
+      maxFs = MAX_FS_VALUES['360p'];
       break;
     case 'medium':
-      maxFs = 3600;
+      maxFs = MAX_FS_VALUES['720p'];
       break;
     case 'large':
-      maxFs = 8192;
+      maxFs = MAX_FS_VALUES['1080p'];
       break;
     case 'best':
-      maxFs = 8192; // for now 'best' is 1080p, so same as 'large'
+      maxFs = MAX_FS_VALUES['1080p']; // for now 'best' is 1080p, so same as 'large'
       break;
     default:
       LoggerProxy.logger.warn(
         `RemoteMedia#getMaxFs --> unsupported paneSize: ${paneSize}, using "medium" instead`
       );
-      maxFs = 3600;
+      maxFs = MAX_FS_VALUES['720p'];
   }
 
   return maxFs;
@@ -117,16 +125,21 @@ export class RemoteMedia extends EventsScope {
       return;
     }
 
-    if (height < 135) {
-      fs = 60;
-    } else if (height < 270) {
-      fs = 240;
-    } else if (height < 540) {
-      fs = 920;
+    // we switch to the next resolution level when the height is 10% more than the current resolution height
+    // except for 1080p - we switch to it immediately when the height is more than 720p
+    const threshold = 1.1;
+    const getThresholdHeight = (h: number) => Math.round(h * threshold);
+
+    if (height < getThresholdHeight(90)) {
+      fs = MAX_FS_VALUES['90p'];
+    } else if (height < getThresholdHeight(180)) {
+      fs = MAX_FS_VALUES['180p'];
+    } else if (height < getThresholdHeight(360)) {
+      fs = MAX_FS_VALUES['360p'];
     } else if (height <= 720) {
-      fs = 3600;
+      fs = MAX_FS_VALUES['720p'];
     } else {
-      fs = 8192;
+      fs = MAX_FS_VALUES['1080p'];
     }
 
     this.receiveSlot?.setMaxFs(fs);

package/src/multistream/sendSlotManager.ts

@@ -4,6 +4,7 @@ import {
   LocalStream,
   MultistreamRoapMediaConnection,
   NamedMediaGroup,
+  StreamState,
 } from '@webex/internal-media-core';
 
 export default class SendSlotManager {
@@ -83,6 +84,36 @@ export default class SendSlotManager {
     );
   }
 
+  /**
+   * Sets the source state override for the given media type.
+   * @param {MediaType} mediaType - The type of media (must be MediaType.VideoMain to apply source state changes).
+   * @param {StreamState | null} state - The state to set or null to clear the override value.
+   * @returns {void}
+   */
+  public setSourceStateOverride(mediaType: MediaType, state: StreamState | null) {
+    if (mediaType !== MediaType.VideoMain) {
+      throw new Error(
+        `sendSlotManager cannot set source state override which media type is ${mediaType}`
+      );
+    }
+
+    const slot = this.slots.get(mediaType);
+
+    if (!slot) {
+      throw new Error(`Slot for ${mediaType} does not exist`);
+    }
+
+    if (state) {
+      slot.setSourceStateOverride(state);
+    } else {
+      slot.clearSourceStateOverride();
+    }
+
+    this.LoggerProxy.logger.info(
+      `SendSlotsManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
+    );
+  }
+
   /**
    * This method publishes the given stream to the sendSlot for the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

package/src/roap/index.ts

@@ -231,14 +231,16 @@ export default class Roap extends StatelessWebexPlugin {
               headers,
             } = remoteSdp.roapMessage;
 
-            roapAnswer = {
-              seq: answerSeq,
-              messageType,
-              sdp: sdps[0],
-              errorType,
-              errorCause,
-              headers,
-            };
+            if (messageType === ROAP.ROAP_TYPES.ANSWER) {
+              roapAnswer = {
+                seq: answerSeq,
+                messageType,
+                sdp: sdps[0],
+                errorType,
+                errorCause,
+                headers,
+              };
+            }
           }
         }
 

package/src/webinar/index.ts

@@ -1,9 +1,10 @@
 /*!
  * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
  */
-import {WebexPlugin} from '@webex/webex-core';
+import {WebexPlugin, config} from '@webex/webex-core';
+import uuid from 'uuid';
 import {get} from 'lodash';
-import {HTTP_VERBS, MEETINGS, SELF_ROLES} from '../constants';
+import {_ID_, HEADERS, HTTP_VERBS, MEETINGS, SELF_ROLES, SHARE_STATUS} from '../constants';
 
 import WebinarCollection from './collection';
 import LoggerProxy from '../common/logs/logger-proxy';
@@ -24,6 +25,7 @@ const Webinar = WebexPlugin.extend({
     selfIsPanelist: 'boolean', // self is panelist
     selfIsAttendee: 'boolean', // self is attendee
     practiceSessionEnabled: 'boolean', // practice session enabled
+    meetingId: 'string',
   },
 
   /**
@@ -67,14 +69,47 @@ const Webinar = WebexPlugin.extend({
     const isPromoted =
       oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.PANELIST);
     const isDemoted =
-      oldRoles.includes(SELF_ROLES.PANELIST) && newRoles.includes(SELF_ROLES.ATTENDEE);
+      (oldRoles.includes(SELF_ROLES.PANELIST) && newRoles.includes(SELF_ROLES.ATTENDEE)) ||
+      (!oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.ATTENDEE)); // for attendee just join meeting case
     this.set('selfIsPanelist', newRoles.includes(SELF_ROLES.PANELIST));
     this.set('selfIsAttendee', newRoles.includes(SELF_ROLES.ATTENDEE));
     this.updateCanManageWebcast(newRoles.includes(SELF_ROLES.MODERATOR));
+    this.updateStatusByRole({isPromoted, isDemoted});
 
     return {isPromoted, isDemoted};
   },
 
+  /**
+   * should join practice session data channel or not
+   * @param {Object} {isPromoted: boolean, isDemoted: boolean}} Role transition states
+   * @returns {void}
+   */
+  updateStatusByRole({isPromoted, isDemoted}) {
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+
+    if (
+      (isDemoted && meeting?.shareStatus === SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE) ||
+      isPromoted
+    ) {
+      // attendees in webinar should subscribe streaming for whiteboard sharing
+      // while panelist still need subscribe native mode so trigger force update here
+      meeting?.locusInfo?.updateMediaShares(meeting?.locusInfo?.mediaShares, true);
+    }
+
+    if (this.practiceSessionEnabled) {
+      // may need change data channel in practice session
+      meeting?.updateLLMConnection();
+    }
+  },
+
+  /**
+   * should join practice session data channel or not
+   * @returns {boolean}
+   */
+  isJoinPracticeSessionDataChannel() {
+    return this.selfIsPanelist && this.practiceSessionEnabled;
+  },
+
   /**
    * start or stop practice session for webinar
    * @param {boolean} enabled
@@ -103,6 +138,165 @@ const Webinar = WebexPlugin.extend({
   updatePracticeSessionStatus(payload) {
     this.set('practiceSessionEnabled', payload.enabled);
   },
+
+  /**
+   * start webcast mode for webinar
+   * @param {object} meeting
+   * @param {object} layout
+   * @returns {Promise}
+   */
+  async startWebcast(meeting, layout) {
+    if (!meeting) {
+      LoggerProxy.logger.error(
+        `Meeting:webinar#startWebcast failed --> meeting parameter : ${meeting}`
+      );
+      throw new Error('Meeting parameter does not meet expectations');
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: `${this.webcastInstanceUrl}/streaming`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+        [HEADERS.CONTENT_TYPE]: HEADERS.CONTENT_TYPE_VALUE.APPLICATION_JSON,
+      },
+      body: {
+        action: 'start',
+        meetingInfo: {
+          locusId: meeting.locusId,
+          correlationId: meeting.correlationId,
+        },
+        layout,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#startWebcast failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * stop webcast mode for webinar
+   * @returns {Promise}
+   */
+  async stopWebcast() {
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: `${this.webcastInstanceUrl}/streaming`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+        [HEADERS.CONTENT_TYPE]: HEADERS.CONTENT_TYPE_VALUE.APPLICATION_JSON,
+      },
+      body: {
+        action: 'stop',
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#stopWebcast failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * query webcast layout for webinar
+   * @returns {Promise}
+   */
+  async queryWebcastLayout() {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.webcastInstanceUrl}/layout`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#queryWebcastLayout failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * update webcast layout for webinar
+   * @param {object} layout
+   * @returns {Promise}
+   */
+  async updateWebcastLayout(layout) {
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: `${this.webcastInstanceUrl}/layout`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+        [HEADERS.CONTENT_TYPE]: HEADERS.CONTENT_TYPE_VALUE.APPLICATION_JSON,
+      },
+      body: {
+        videoLayout: layout.videoLayout,
+        contentLayout: layout.contentLayout,
+        syncStageLayout: layout.syncStageLayout,
+        syncStageInMeeting: layout.syncStageInMeeting,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#updateWebcastLayout failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * view all webcast attendees
+   * @param {string} queryString
+   * @returns {Promise}
+   */
+  async viewAllWebcastAttendees() {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.webcastInstanceUrl}/attendees`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#viewAllWebcastAttendees failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * search webcast attendees by query string
+   * @param {string} queryString
+   * @returns {Promise}
+   */
+  async searchWebcastAttendees(queryString = '') {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(queryString)}`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#searchWebcastAttendees failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * expel webcast attendee by participantId
+   * @param {string} participantId
+   * @returns {Promise}
+   */
+  async expelWebcastAttendee(participantId) {
+    return this.request({
+      method: HTTP_VERBS.DELETE,
+      uri: `${this.webcastInstanceUrl}/attendees/${participantId}`,
+      headers: {
+        authorization: await this.webex.credentials.getUserToken(),
+        trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#expelWebcastAttendee failed', error);
+      throw error;
+    });
+  },
 });
 
 export default Webinar;

package/test/unit/spec/annotation/index.ts

@@ -413,6 +413,51 @@ describe('live-annotation', () => {
         });
       });
     });
-  });
 
+    describe('#deregisterEvents', () => {
+      let llmOn;
+      let llmOff;
+      let mercuryOn;
+      let mercuryOff;
+
+      beforeEach(() => {
+        llmOn = sinon.spy(webex.internal.llm, 'on');
+        llmOff = sinon.spy(webex.internal.llm, 'off');
+        mercuryOn = sinon.spy(webex.internal.mercury, 'on');
+        mercuryOff = sinon.spy(webex.internal.mercury, 'off');
+      });
+
+      it('cleans up events', () => {
+        annotationService.locusUrlUpdate(locusUrl);
+        assert.calledWith(
+          mercuryOn,
+          'event:locus.approval_request',
+          annotationService.eventCommandProcessor,
+          annotationService
+        );
+        assert.calledWith(
+          llmOn,
+          'event:relay.event',
+          annotationService.eventDataProcessor,
+          annotationService
+        );
+        assert.match(annotationService.hasSubscribedToEvents, true);
+
+        annotationService.deregisterEvents();
+        assert.calledWith(llmOff, 'event:relay.event', annotationService.eventDataProcessor);
+        assert.calledWith(
+          mercuryOff,
+          'event:locus.approval_request',
+          annotationService.eventCommandProcessor
+        );
+        assert.match(annotationService.hasSubscribedToEvents, false);
+      });
+
+      it('does not call llm off if events have not been registered', () => {
+        annotationService.deregisterEvents();
+        assert.notCalled(llmOff);
+        assert.notCalled(mercuryOff);
+      });
+    });
+  });
 });