@webex/plugin-meetings 3.8.0-next.82 → 3.8.0-next.83

package/src/member/types.ts

@@ -15,22 +15,6 @@ export type ServerRoleShape = {
   hasRole: boolean;
 };
 
-export type ParticipantWithRoles = {
-  controls: {
-    role: {
-      roles: Array<ServerRoleShape>;
-    };
-  };
-};
-
-export type ParticipantWithBrb = {
-  controls: {
-    brb?: {
-      enabled: boolean;
-    };
-  };
-};
-
 // values are inherited from locus so don't update these
 export enum MediaStatus {
   RECVONLY = 'RECVONLY', // participant only receiving and not sending
@@ -44,3 +28,85 @@ export interface IMediaStatus {
   audio: MediaStatus;
   video: MediaStatus;
 }
+
+export type Csi = number;
+export type Direction = 'inactive' | 'sendrecv' | 'sendonly' | 'recvonly';
+export type ParticipantUrl = string;
+export interface MediaSession {
+  csi: Csi;
+  direction: Direction;
+  mediaContent: 'main' | 'slides';
+  mediaType: 'audio' | 'video';
+  state: string;
+}
+
+export interface Intent {
+  associatedWith: ParticipantUrl;
+  id: string;
+  type: string; // could be "WAIT" or "OBSERVE" or other....
+}
+export interface ParticipantDevice {
+  correlationId: string;
+  csis: Csi[];
+  deviceType: string; // WDM device type, could be "WEB", "TP_ENDPOINT", "MAC" or other things, don't know the full list, so keeping it as string
+  intent?: Intent;
+  intents: Array<Intent | null>;
+  isVideoCallback: boolean;
+  mediaSessions: Array<MediaSession>;
+  mediaSessionsExternal: boolean;
+  state: string; // probably one of MEETING_STATE.STATES
+}
+
+// this is not a complete type, Locus may send more fields
+export interface ParticipantPerson {
+  id: string;
+  isExternal: boolean;
+  name: string;
+  orgId: string;
+}
+
+export interface ParticipantMediaStatus {
+  audioStatus: MediaStatus;
+  videoStatus: MediaStatus;
+  audioSlidesStatus?: MediaStatus;
+  videoSlidesStatus?: MediaStatus;
+  csis: Csi[];
+}
+
+// this is not a complete type, Locus may send more fields
+export interface ParticipantControls {
+  role: {
+    roles: Array<ServerRoleShape>;
+  };
+  brb?: {
+    enabled: boolean;
+  };
+  hand: {
+    raised: boolean;
+  };
+  localRecord: {
+    recording: boolean;
+  };
+}
+
+// this is not a complete type, Locus may send more fields
+export interface Participant {
+  canBeController: boolean;
+  controls: ParticipantControls;
+  deviceUrl: string;
+  devices: Array<ParticipantDevice>;
+  guest: boolean;
+  id: string;
+  identity: string;
+  identityTrustLevel: string; // could be 'INTERNAL', 'EXTERNAL' or other....
+  isCreator: boolean;
+  moderator: boolean; // Locus docs say this is deprecated and role control should be used instead
+  moderatorAssignmentNotAllowed: boolean;
+  presenterAssignmentNotAllowed: boolean;
+  person: ParticipantPerson;
+  resourceGuest: boolean;
+  state: string; // probably one of MEETING_STATE.STATES
+  status: ParticipantMediaStatus;
+  type: string;
+  url: ParticipantUrl;
+}

package/src/member/util.ts

@@ -1,10 +1,10 @@
 import {
   IExternalRoles,
-  ParticipantWithRoles,
   ServerRoles,
   ServerRoleShape,
   IMediaStatus,
-  ParticipantWithBrb,
+  Participant,
+  ParticipantUrl,
 } from './types';
 import {
   _USER_,
@@ -46,23 +46,23 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {[ServerRoleShape]}
    */
-  getControlsRoles: (participant: ParticipantWithRoles): Array<ServerRoleShape> =>
+  getControlsRoles: (participant: Participant): Array<ServerRoleShape> =>
     participant?.controls?.role?.roles,
 
   /**
    * Checks if the participant has the brb status enabled.
    *
-   * @param {ParticipantWithBrb} participant - The locus participant object.
+   * @param {Participant} participant - The locus participant object.
    * @returns {boolean} - True if the participant has brb enabled, false otherwise.
    */
-  isBrb: (participant: ParticipantWithBrb): boolean => participant.controls?.brb?.enabled || false,
+  isBrb: (participant: Participant): boolean => participant.controls?.brb?.enabled || false,
 
   /**
    * @param {Object} participant - The locus participant object.
    * @param {ServerRoles} controlRole the search role
    * @returns {Boolean}
    */
-  hasRole: (participant: any, controlRole: ServerRoles): boolean =>
+  hasRole: (participant: Participant, controlRole: ServerRoles): boolean =>
     MemberUtil.getControlsRoles(participant)?.some(
       (role) => role.type === controlRole && role.hasRole
     ),
@@ -71,28 +71,28 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  hasCohost: (participant: ParticipantWithRoles): boolean =>
+  hasCohost: (participant: Participant): boolean =>
     MemberUtil.hasRole(participant, ServerRoles.Cohost) || false,
 
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  hasModerator: (participant: ParticipantWithRoles): boolean =>
+  hasModerator: (participant: Participant): boolean =>
     MemberUtil.hasRole(participant, ServerRoles.Moderator) || false,
 
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  hasPresenter: (participant: ParticipantWithRoles): boolean =>
+  hasPresenter: (participant: Participant): boolean =>
     MemberUtil.hasRole(participant, ServerRoles.Presenter) || false,
 
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {IExternalRoles}
    */
-  extractControlRoles: (participant: ParticipantWithRoles): IExternalRoles => {
+  extractControlRoles: (participant: Participant): IExternalRoles => {
     const roles = {
       cohost: MemberUtil.hasCohost(participant),
       moderator: MemberUtil.hasModerator(participant),
@@ -106,26 +106,26 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isUser: (participant: any) => participant && participant.type === _USER_,
+  isUser: (participant: Participant) => participant && participant.type === _USER_,
 
-  isModerator: (participant) => participant && participant.moderator,
+  isModerator: (participant: Participant) => participant && participant.moderator,
 
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isGuest: (participant: any) => participant && participant.guest,
+  isGuest: (participant: Participant) => participant && participant.guest,
 
   /**
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isDevice: (participant: any) => participant && participant.type === _RESOURCE_ROOM_,
+  isDevice: (participant: Participant) => participant && participant.type === _RESOURCE_ROOM_,
 
-  isModeratorAssignmentProhibited: (participant) =>
+  isModeratorAssignmentProhibited: (participant: Participant) =>
     participant && participant.moderatorAssignmentNotAllowed,
 
-  isPresenterAssignmentProhibited: (participant) =>
+  isPresenterAssignmentProhibited: (participant: Participant) =>
     participant && participant.presenterAssignmentNotAllowed,
 
   /**
@@ -135,30 +135,16 @@ const MemberUtil = {
    * @param {String} id
    * @returns {Boolean}
    */
-  isSame: (participant: any, id: string) =>
+  isSame: (participant: Participant, id: string) =>
     participant && (participant.id === id || (participant.person && participant.person.id === id)),
 
-  /**
-   * checks to see if the participant id is the same as the passed id for associated devices
-   * there are multiple ids that can be used
-   * @param {Object} participant - The locus participant object.
-   * @param {String} id
-   * @returns {Boolean}
-   */
-  isAssociatedSame: (participant: any, id: string) =>
-    participant &&
-    participant.associatedUsers &&
-    participant.associatedUsers.some(
-      (user) => user.id === id || (user.person && user.person.id === id)
-    ),
-
   /**
    * @param {Object} participant - The locus participant object.
    * @param {Boolean} isGuest
    * @param {String} status
    * @returns {Boolean}
    */
-  isNotAdmitted: (participant: any, isGuest: boolean, status: string): boolean =>
+  isNotAdmitted: (participant: Participant, isGuest: boolean, status: string): boolean =>
     participant &&
     participant.guest &&
     ((participant.devices &&
@@ -175,7 +161,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isAudioMuted: (participant: any) => {
+  isAudioMuted: (participant: Participant) => {
     if (!participant) {
       throw new ParameterError('Audio could not be processed, participant is undefined.');
     }
@@ -187,7 +173,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isVideoMuted: (participant: any): boolean => {
+  isVideoMuted: (participant: Participant): boolean => {
     if (!participant) {
       throw new ParameterError('Video could not be processed, participant is undefined.');
     }
@@ -199,7 +185,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isHandRaised: (participant: any) => {
+  isHandRaised: (participant: Participant) => {
     if (!participant) {
       throw new ParameterError('Raise hand could not be processed, participant is undefined.');
     }
@@ -256,7 +242,7 @@ const MemberUtil = {
    * @param {String} controlsAccessor
    * @returns {Boolean | undefined}
    */
-  isMuted: (participant: any, statusAccessor: string, controlsAccessor: string) => {
+  isMuted: (participant: Participant, statusAccessor: string, controlsAccessor: string) => {
     // check remote mute
     const remoteMute = participant?.controls?.[controlsAccessor]?.muted;
     if (remoteMute === true) {
@@ -295,7 +281,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Boolean}
    */
-  isRecording: (participant: any) => {
+  isRecording: (participant: Participant) => {
     if (!participant) {
       throw new ParameterError('Recording could not be processed, participant is undefined.');
     }
@@ -341,7 +327,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {String}
    */
-  extractStatus: (participant: any) => {
+  extractStatus: (participant: Participant) => {
     if (!(participant && participant.devices && participant.devices.length)) {
       return _NOT_IN_MEETING_;
     }
@@ -371,7 +357,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {String}
    */
-  extractId: (participant: any) => {
+  extractId: (participant: Participant) => {
     if (participant) {
       return participant.id;
     }
@@ -384,7 +370,7 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {Object}
    */
-  extractMediaStatus: (participant: any): IMediaStatus => {
+  extractMediaStatus: (participant: Participant): IMediaStatus => {
     if (!participant) {
       throw new ParameterError('Media status could not be extracted, participant is undefined.');
     }
@@ -399,12 +385,30 @@ const MemberUtil = {
    * @param {Object} participant - The locus participant object.
    * @returns {String}
    */
-  extractName: (participant: any) => {
+  extractName: (participant: Participant) => {
     if (participant && participant.person) {
       return participant.person.name;
     }
 
     return null;
   },
+
+  /**
+   * @param {Object} participant - The locus participant object.
+   * @returns {String}
+   */
+  extractPairedWithParticipantUrl: (participant: Participant): ParticipantUrl | undefined => {
+    let participantUrl;
+
+    participant?.devices?.forEach((device) => {
+      device?.intents?.forEach((intent) => {
+        if (intent?.type === _OBSERVE_ && intent?.associatedWith) {
+          participantUrl = intent.associatedWith;
+        }
+      });
+    });
+
+    return participantUrl;
+  },
 };
 export default MemberUtil;

package/src/members/collection.ts

@@ -1,10 +1,11 @@
 import {MEETINGS} from '../constants';
+import Member from '../member';
 
 /**
  * @class MembersCollection
  */
 export default class MembersCollection {
-  members: any;
+  members: Record<string, Member>;
   namespace = MEETINGS;
   /**
    * @param {Object} locus
@@ -14,11 +15,11 @@ export default class MembersCollection {
     this.members = {};
   }
 
-  set(id, member) {
+  set(id: string, member: Member) {
     this.members[id] = member;
   }
 
-  setAll(members) {
+  setAll(members: Record<string, Member>) {
     this.members = members;
   }
 

package/src/members/index.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-import {isEmpty} from 'lodash';
+import {get, isEmpty, set} from 'lodash';
 // @ts-ignore
 import {StatelessWebexPlugin} from '@webex/webex-core';
 
@@ -73,6 +73,7 @@ import {ServerRoleShape} from './types';
  * @memberof Members
  */
 
+type UpdatedMembers = {added: Array<Member>; updated: Array<Member>};
 /**
  * @class Members
  */
@@ -81,7 +82,7 @@ export default class Members extends StatelessWebexPlugin {
   locusUrl: any;
   mediaShareContentId: any;
   mediaShareWhiteboardId: any;
-  membersCollection: any;
+  membersCollection: MembersCollection;
   membersRequest: any;
   receiveSlotManager: ReceiveSlotManager;
   mediaRequestManagers: {
@@ -321,6 +322,63 @@ export default class Members extends StatelessWebexPlugin {
     );
   }
 
+  /**
+   * Updates properties on members that rely on information from other members.
+   * This function MUST be called only after the membersCollection has been fully updated
+   * @param {UpdatedMembers} membersUpdate
+   * @returns {Object} membersCollection
+   * @private
+   * @memberof Members
+   */
+  private updateRelationsBetweenMembers(membersUpdate: UpdatedMembers) {
+    const updatePairedMembers = (membersList: Member[]) => {
+      membersList.forEach((member) => {
+        if (!member.pairedWith.participantUrl) {
+          // if we don't have a participantUrl set, it may be that we had it in the past and not anymore, so cleanup the rest of the data
+          if (member.pairedWith.memberId) {
+            const pairedMember = this.membersCollection.get(member.pairedWith.memberId);
+
+            if (pairedMember) {
+              // remove member from pairedMember's associatedUsers array
+              pairedMember.associatedUsers.delete(member.id);
+
+              if (pairedMember.associatedUser === member.id) {
+                pairedMember.associatedUser = null;
+              }
+
+              // reset all the props that we set on pairedMember
+              pairedMember.isPairedWithSelf = false;
+              pairedMember.isHost = false;
+            }
+          }
+          member.pairedWith.memberId = undefined;
+        } else if (member.pairedWith.memberId === undefined) {
+          // we have participantUrl set but not memberId, so find the member and set it
+          const pairedMember = Object.values(this.membersCollection.getAll()).find(
+            (m) => m.participant?.url === member.pairedWith.participantUrl
+          );
+
+          if (pairedMember) {
+            member.pairedWith.memberId = pairedMember.id;
+            pairedMember.associatedUsers.add(member.id);
+
+            if (pairedMember.associatedUsers.size === 1) {
+              // associatedUser is deprecated, because it's broken - device can have multiple associated users,
+              // so for backwards compatibility we set it to the first associated user
+              pairedMember.associatedUser = member.id;
+            }
+
+            pairedMember.isPairedWithSelf = member.isSelf;
+            pairedMember.isHost = member.isHost;
+          }
+        }
+      });
+    };
+
+    updatePairedMembers(membersUpdate.updated);
+    updatePairedMembers(membersUpdate.added);
+  }
+
   /**
    * when new participant updates come in, both delta and full participants, update them in members collection
    * delta object in the event will have {updated, added} and full will be the full membersCollection
@@ -338,6 +396,8 @@ export default class Members extends StatelessWebexPlugin {
       const delta = this.handleLocusInfoUpdatedParticipants(payload);
       const full = this.handleMembersUpdate(delta); // SDK should propagate the full list for both delta and non delta updates
 
+      this.updateRelationsBetweenMembers(delta);
+
       this.receiveSlotManager?.updateMemberIds();
 
       Trigger.trigger(
@@ -478,20 +538,14 @@ export default class Members extends StatelessWebexPlugin {
 
   /**
    * sets values in the members collection for updated and added properties from delta
-   * @param {Object} membersUpdate {updated: [], added: []}
+   * @param {UpdatedMembers} membersUpdate
    * @returns {Object} membersCollection
    * @private
    * @memberof Members
    */
-  private handleMembersUpdate(membersUpdate: any) {
-    if (membersUpdate) {
-      if (membersUpdate.updated) {
-        this.constructMembers(membersUpdate.updated);
-      }
-      if (membersUpdate.added) {
-        this.constructMembers(membersUpdate.added);
-      }
-    }
+  private handleMembersUpdate(membersUpdate: UpdatedMembers) {
+    this.constructMembers(membersUpdate.updated, true);
+    this.constructMembers(membersUpdate.added, false);
 
     return this.membersCollection.getAll();
   }
@@ -499,12 +553,30 @@ export default class Members extends StatelessWebexPlugin {
   /**
    * set members to the member collection from each updated/added lists as passed in
    * @param {Array} list
+   * @param {boolean} isUpdate
    * @returns {undefined}
    * @private
    * @memberof Members
    */
-  private constructMembers(list: Array<any>) {
+  private constructMembers(list: Array<any>, isUpdate: boolean) {
     list.forEach((member) => {
+      if (isUpdate) {
+        // some member props are generated by SDK and need to be preserved on update,
+        // because they depend on relationships with other members so they need to be handled
+        // at the end, once all members are updated - this is done in updateRelationsBetweenMembers()
+        const propsToKeepOnUpdate = ['pairedWith.memberId'];
+
+        const existingMember = this.membersCollection.get(member.id);
+        if (existingMember) {
+          propsToKeepOnUpdate.forEach((prop) => {
+            const existingValue = get(existingMember, prop);
+
+            if (existingValue !== undefined) {
+              set(member, prop, existingValue);
+            }
+          });
+        }
+      }
       this.membersCollection.set(member.id, member);
     });
   }
@@ -512,11 +584,11 @@ export default class Members extends StatelessWebexPlugin {
   /**
    * Internal update the participants value
    * @param {Object} payload
-   * @returns {Object}
+   * @returns {UpdatedMembers}
    * @private
    * @memberof Members
    */
-  private handleLocusInfoUpdatedParticipants(payload: any) {
+  private handleLocusInfoUpdatedParticipants(payload: any): UpdatedMembers {
     this.hostId = payload.hostId || this.hostId;
     this.selfId = payload.selfId || this.selfId;
     this.recordingId = payload.recordingId;
@@ -681,12 +753,12 @@ export default class Members extends StatelessWebexPlugin {
    * Removed/left members will end up in updates
    * Each array contains only members
    * @param {Array} participants the locus participants
-   * @returns {Object} {added: {Array}, updated: {Array}}
+   * @returns {UpdatedMembers} {added: {Array}, updated: {Array}}
    * @private
    * @memberof Members
    */
-  private update(participants: Array<any>) {
-    const membersUpdate = {added: [], updated: []};
+  private update(participants: Array<any>): UpdatedMembers {
+    const membersUpdate: UpdatedMembers = {added: [], updated: []};
 
     if (participants) {
       participants.forEach((participant) => {