@webex/plugin-meetings 2.59.8-next.2 → 2.60.0

package/src/members/request.ts

@@ -59,6 +59,26 @@ export default class MembersRequest extends StatelessWebexPlugin {
     return this.request(requestParams);
   }
 
+  /**
+   * Sends a request to assign roles to a member
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.memberId ID of PSTN user
+   * @returns {Promise}
+   */
+  assignRolesMember(options: any) {
+    if (!options || !options.locusUrl || !options.memberId) {
+      throw new ParameterError(
+        'memberId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getRoleAssignmentMemberRequestParams(options);
+
+    // @ts-ignore
+    return this.request(requestParams);
+  }
+
   removeMember(options) {
     if (!options || !options.locusUrl || !options.memberId) {
       throw new ParameterError(

package/src/members/types.ts

@@ -0,0 +1,29 @@
+export enum ServerRoles {
+  Cohost = 'COHOST',
+  Moderator = 'MODERATOR',
+  Presenter = 'PRESENTER',
+}
+
+export type ServerRoleShape = {
+  type: ServerRoles;
+  hasRole: boolean;
+  hostKey?: string;
+};
+
+export type RoleAssignmentOptions = {
+  roles: Array<ServerRoleShape>;
+  locusUrl: string;
+  memberId: string;
+};
+
+export type RoleAssignmentBody = {
+  role: {
+    roles: Array<ServerRoleShape>;
+  };
+};
+
+export type RoleAssignmentRequest = {
+  method: string;
+  uri: string;
+  body: RoleAssignmentBody;
+};

package/src/members/util.ts

@@ -11,6 +11,7 @@ import {
   SEND_DTMF_ENDPOINT,
   _REMOVE_,
 } from '../constants';
+import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
 
 const MembersUtil: any = {};
 
@@ -91,6 +92,20 @@ MembersUtil.getAddMemberRequestParams = (format: any) => {
   return requestParams;
 };
 
+/**
+ * @param {ServerRoleShape} role
+ * @returns {ServerRoleShape} the role shape to be added to the body
+ */
+MembersUtil.getAddedRoleShape = (role: ServerRoleShape) => {
+  const roleShape: ServerRoleShape = {type: role.type, hasRole: role.hasRole};
+
+  if (role.hostKey) {
+    roleShape.hostKey = role.hostKey;
+  }
+
+  return roleShape;
+};
+
 MembersUtil.isInvalidInvitee = (invitee) => {
   if (!(invitee && (invitee.email || invitee.emailAddress || invitee.phoneNumber))) {
     return true;
@@ -116,6 +131,43 @@ MembersUtil.getRemoveMemberRequestParams = (options) => {
   };
 };
 
+/**
+ * @param {String} memberId
+ * @param {[ServerRoleShape]} roles
+ * @param {String} locusUrl
+ * @returns {RoleAssignmentOptions}
+ */
+MembersUtil.generateRoleAssignmentMemberOptions = (
+  memberId: string,
+  roles: Array<ServerRoleShape>,
+  locusUrl: string
+): RoleAssignmentOptions => ({
+  memberId,
+  roles,
+  locusUrl,
+});
+
+/**
+ * @param {RoleAssignmentOptions} options
+ * @returns {RoleAssignmentRequest} the request parameters (method, uri, body) needed to make a addMember request
+ */
+MembersUtil.getRoleAssignmentMemberRequestParams = (
+  options: RoleAssignmentOptions
+): RoleAssignmentRequest => {
+  const body = {role: {roles: []}};
+  options.roles.forEach((role) => {
+    body.role.roles.push(MembersUtil.getAddedRoleShape(role));
+  });
+
+  const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+  return {
+    method: HTTP_VERBS.PATCH,
+    uri,
+    body,
+  };
+};
+
 MembersUtil.generateTransferHostMemberOptions = (transfer, moderator, locusUrl) => ({
   moderator,
   locusUrl,

package/src/metrics/constants.ts

@@ -1,6 +1,8 @@
 // Metrics constants ----------------------------------------------------------
 
 const BEHAVIORAL_METRICS = {
+  NO_FRAMES_SENT: 'js_sdk_meetings_no_frames_sent',
+  NO_VIDEO_ENCODED: 'js_sdk_meetings_no_video_encoded',
   MEETINGS_REGISTRATION_FAILED: 'js_sdk_meetings_registration_failed',
   MEETINGS_REGISTRATION_SUCCESS: 'js_sdk_meetings_registration_success',
   MERCURY_CONNECTION_FAILURE: 'js_sdk_mercury_connection_failure',

package/src/roap/index.ts

@@ -302,6 +302,7 @@ export default class Roap extends StatelessWebexPlugin {
           meetingId: meeting.id,
         });
       })
+
       .then(({locus, mediaConnections}) => {
         this.roapHandler.submit({
           type: ROAP.SEND_ROAP_MSG_SUCCESS,

package/src/statsAnalyzer/global.ts

@@ -76,20 +76,11 @@ const STATS_DEFAULT = {
     },
   },
   resolutions: {
-    audio: {
-      send: {
-        width: 0,
-        height: 0,
-      },
-      recv: {
-        width: 0,
-        height: 0,
-      },
-    },
     video: {
       send: {
         width: 0,
         height: 0,
+        framesSent: 0,
       },
       recv: {
         width: 0,
@@ -100,6 +91,7 @@ const STATS_DEFAULT = {
       send: {
         width: 0,
         height: 0,
+        framesSent: 0,
       },
       recv: {
         width: 0,

package/src/statsAnalyzer/index.ts

@@ -25,6 +25,8 @@ import {
 
 export const EVENTS = {
   MEDIA_QUALITY: 'MEDIA_QUALITY',
+  NO_FRAMES_SENT: 'NO_FRAMES_SENT',
+  NO_VIDEO_ENCODED: 'NO_VIDEO_ENCODED',
   LOCAL_MEDIA_STARTED: 'LOCAL_MEDIA_STARTED',
   LOCAL_MEDIA_STOPPED: 'LOCAL_MEDIA_STOPPED',
   REMOTE_MEDIA_STARTED: 'REMOTE_MEDIA_STARTED',
@@ -420,9 +422,6 @@ export class StatsAnalyzer extends EventsScope {
       case 'inbound-rtp':
         this.processInboundRTPResult(getStatsResult, type);
         break;
-      case 'track':
-        this.processTrackResult(getStatsResult, type);
-        break;
       case 'remote-inbound-rtp':
       case 'remote-outbound-rtp':
         // @ts-ignore
@@ -520,7 +519,7 @@ export class StatsAnalyzer extends EventsScope {
 
     if (currentValue - previousValue > 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STARTED : EVENTS.REMOTE_MEDIA_STARTED;
-    } else if (currentValue === previousValue && currentValue > 0) {
+    } else if (currentValue === previousValue && currentValue >= 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STOPPED : EVENTS.REMOTE_MEDIA_STOPPED;
     }
 
@@ -635,14 +634,25 @@ export class StatsAnalyzer extends EventsScope {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
-        } else {
+        } else if (this.lastEmittedStartStopEvent[mediaType].local !== EVENTS.LOCAL_MEDIA_STOPPED) {
           if (
             currentStats.framesEncoded === previousStats.framesEncoded ||
             currentStats.framesEncoded === 0
           ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_VIDEO_ENCODED;
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames Encoded`
             );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_VIDEO_ENCODED,
+              {
+                mediaType,
+              }
+            );
           }
 
           if (
@@ -654,8 +664,28 @@ export class StatsAnalyzer extends EventsScope {
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent`
             );
           }
-        }
 
+          // Video is encoded but frames are not sent
+          if (
+            currentStats.framesEncoded !== previousStats.framesEncoded &&
+            (currentStats.framesSent === previousStats.framesSent || currentStats.framesSent === 0)
+          ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_FRAMES_SENT;
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent even though frames are encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_FRAMES_SENT,
+              {
+                mediaType,
+              }
+            );
+          }
+        }
         this.emitStartStopEvents(
           mediaType,
           previousStats.framesSent,
@@ -731,14 +761,25 @@ export class StatsAnalyzer extends EventsScope {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
-        } else {
+        } else if (this.lastEmittedStartStopEvent[mediaType].local !== EVENTS.LOCAL_MEDIA_STOPPED) {
           if (
             currentStats.framesEncoded === previousStats.framesEncoded ||
             currentStats.framesEncoded === 0
           ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_VIDEO_ENCODED;
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames getting encoded`
             );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_VIDEO_ENCODED,
+              {
+                mediaType,
+              }
+            );
           }
 
           if (
@@ -750,6 +791,27 @@ export class StatsAnalyzer extends EventsScope {
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent`
             );
           }
+
+          // Share video is encoded but frames are not sent
+          if (
+            currentStats.framesEncoded !== previousStats.framesEncoded &&
+            (currentStats.framesSent === previousStats.framesSent || currentStats.framesSent === 0)
+          ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_FRAMES_SENT;
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent even though frames are being encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_FRAMES_SENT,
+              {
+                mediaType,
+              }
+            );
+          }
         }
 
         // TODO:need to check receive share value
@@ -881,6 +943,7 @@ export class StatsAnalyzer extends EventsScope {
     const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.SEND_DIRECTION;
 
+    this.processTrackResult(result, type, sendrecvType);
     if (result.bytesSent) {
       let kilobytes = 0;
 
@@ -904,7 +967,6 @@ export class StatsAnalyzer extends EventsScope {
 
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
       this.statsResults[mediaType].bytesSent = kilobytes;
-
       this.statsResults[mediaType][sendrecvType].framesEncoded =
         result.framesEncoded - this.statsResults.internal[mediaType][sendrecvType].framesEncoded;
       this.statsResults[mediaType][sendrecvType].keyFramesEncoded =
@@ -955,6 +1017,7 @@ export class StatsAnalyzer extends EventsScope {
     const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.RECEIVE_DIRECTION;
 
+    this.processTrackResult(result, type, sendrecvType);
     if (result.bytesReceived) {
       let kilobytes = 0;
 
@@ -1158,29 +1221,29 @@ export class StatsAnalyzer extends EventsScope {
    * @private
    * @param {*} result
    * @param {*} mediaType
+   * @param {*} sendrecvType
    * @returns {void}
    * @memberof StatsAnalyzer
    */
-  private processTrackResult(result: any, mediaType: any) {
-    if (!result || result.type !== 'track') {
+  private processTrackResult(result: any, mediaType: any, sendrecvType: any) {
+    if (!result || mediaType === STATS.AUDIO_CORRELATE) {
+      return;
+    }
+    if (result.type !== 'inbound-rtp' && result.type !== 'outbound-rtp') {
       return;
     }
-    if (result.type !== 'track') return;
-
-    const sendrecvType =
-      result.remoteSource === true ? STATS.RECEIVE_DIRECTION : STATS.SEND_DIRECTION;
-
     if (result.frameWidth && result.frameHeight) {
       this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
       this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
-      this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
-      this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
     }
 
     if (sendrecvType === STATS.RECEIVE_DIRECTION) {
       this.statsResults.resolutions[mediaType][sendrecvType].framesReceived = result.framesReceived;
       this.statsResults.resolutions[mediaType][sendrecvType].framesDecoded = result.framesDecoded;
       this.statsResults.resolutions[mediaType][sendrecvType].framesDropped = result.framesDropped;
+    } else if (sendrecvType === STATS.SEND_DIRECTION) {
+      this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
+      this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
     }
 
     if (result.trackIdentifier && mediaType !== STATS.AUDIO_CORRELATE) {

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

@@ -1329,6 +1329,71 @@ describe('plugin-meetings', () => {
               data: {intervalData: fakeData, networkType: 'wifi'},
             });
           });
+          it('NO_FRAMES_SENT triggers "meeting:noFramesSent" event and sends metrics', async () => {
+            meeting.mediaProperties.mediaDirection = {sendVideo: true};
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.NO_FRAMES_SENT,
+              {mediaType: 'video'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'compareLastStatsResult',
+              },
+              EVENT_TRIGGERS.MEETING_NO_FRAMES_SENT,
+              {
+                mediaType: 'video',
+              }
+            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.NO_FRAMES_SENT);
+          });
+          it('NO_FRAMES_SENT triggers "meeting:noFramesSent" event and sends metrics for share', async () => {
+            meeting.mediaProperties.mediaDirection = {sendShare: true};
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.NO_FRAMES_SENT,
+              {mediaType: 'share'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'compareLastStatsResult',
+              },
+              EVENT_TRIGGERS.MEETING_NO_FRAMES_SENT,
+              {
+                mediaType: 'share',
+              }
+            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.NO_FRAMES_SENT);
+          });
+          it('NO_VIDEO_ENCODED triggers "meeting:noVideoEncoded" event and sends metrics', async () => {
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.NO_VIDEO_ENCODED,
+              {mediaType: 'video'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'compareLastStatsResult',
+              },
+              EVENT_TRIGGERS.MEETING_NO_VIDEO_ENCODED,
+              {
+                mediaType: 'video',
+              }
+            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.NO_VIDEO_ENCODED);
+          });
         });
       });
       describe('#acknowledge', () => {
@@ -3646,14 +3711,17 @@ describe('plugin-meetings', () => {
       describe('#setUpLocusServicesListener', () => {
         it('listens to the locus services update event', (done) => {
           const newLocusServices = {
-              services: {
-                record: {
-                  url: 'url',
-                }
+            services: {
+              record: {
+                url: 'url',
               },
+            },
           };
 
-          meeting.recordingController = {setServiceUrl: sinon.stub().returns(undefined), setSessionId: sinon.stub().returns(undefined)};
+          meeting.recordingController = {
+            setServiceUrl: sinon.stub().returns(undefined),
+            setSessionId: sinon.stub().returns(undefined),
+          };
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -3661,7 +3729,10 @@ describe('plugin-meetings', () => {
             newLocusServices
           );
 
-          assert.calledWith(meeting.recordingController.setServiceUrl, newLocusServices.services.record.url);
+          assert.calledWith(
+            meeting.recordingController.setServiceUrl,
+            newLocusServices.services.record.url
+          );
           assert.calledOnce(meeting.recordingController.setSessionId);
           done();
         });

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

@@ -20,6 +20,13 @@ describe('member', () => {
   
       assert.calledOnceWithExactly(MemberUtil.isHandRaised, participant);
     });
+
+    it('checks that processParticipant calls canReclaimHost', () => {
+      sinon.spy(MemberUtil, 'canReclaimHost');
+      member.processParticipant(participant);
+
+      assert.calledOnceWithExactly(MemberUtil.canReclaimHost, participant);
+    });
   })
 
   describe('#processMember', ()=>{

package/test/unit/spec/member/util.js

@@ -78,3 +78,35 @@ describe('extractMediaStatus', () => {
     assert.deepEqual(mediaStatus, {audio: 'RECVONLY', video: 'SENDRECV'});
   });
 });
+
+describe('MemberUtil.canReclaimHost', () => {
+  it('throws error when there is no participant', () => {
+    assert.throws(() => {
+      MemberUtil.canReclaimHost();
+    }, 'canReclaimHostRole could not be processed, participant is undefined.');
+  });
+
+  it('returns true when canReclaimHostRole is true', () => {
+    const participant = {
+      canReclaimHostRole: true,
+    };
+
+    assert.isTrue(MemberUtil.canReclaimHost(participant));
+  });
+
+  it('returns false when canReclaimHostRole is false', () => {
+    const participant = {
+      canReclaimHostRole: false,
+    };
+
+    assert.isFalse(MemberUtil.canReclaimHost(participant));
+  });
+
+  it('returns false when canReclaimHostRole is falsy', () => {
+    const participant = {
+      canReclaimHostRole: undefined,
+    };
+
+    assert.isFalse(MemberUtil.canReclaimHost(participant));
+  });
+});