@webex/plugin-meetings 3.11.0-next.2 → 3.11.0-next.21

package/src/hashTree/types.ts

@@ -10,6 +10,7 @@ export const ObjectType = {
   fullState: 'fullstate',
   links: 'links',
   control: 'controlentry',
+  metadata: 'metadata',
 } as const;
 
 export type ObjectType = Enum<typeof ObjectType>;

package/src/hashTree/utils.ts

@@ -11,6 +11,15 @@ export function isSelf(object: HashTreeObject) {
   return object.htMeta.elementId.type.toLowerCase() === ObjectType.self;
 }
 
+/**
+ * Checks if the given hash tree object is of type "Metadata"
+ * @param {HashTreeObject} object object to check
+ * @returns {boolean} True if the object is of type "Metadata", false otherwise
+ */
+export function isMetadata(object: HashTreeObject) {
+  return object.htMeta.elementId.type.toLowerCase() === ObjectType.metadata;
+}
+
 /**
  * Analyzes given part of Locus DTO recursively and delete any nested objects that have their own htMeta
  *

package/src/locus-info/index.ts

@@ -35,10 +35,11 @@ import HashTreeParser, {
   DataSet,
   HashTreeMessage,
   LocusInfoUpdateType,
+  Metadata,
 } from '../hashTree/hashTreeParser';
 import {HashTreeObject, ObjectType, ObjectTypeToLocusKeyMap} from '../hashTree/types';
-import {isSelf} from '../hashTree/utils';
-import {Links, LocusDTO, LocusFullState} from './types';
+import {isMetadata} from '../hashTree/utils';
+import {Links, LocusDTO} from './types';
 
 export type LocusLLMEvent = {
   data: {
@@ -69,6 +70,7 @@ const LocusDtoTopLevelKeys = [
 export type LocusApiResponseBody = {
   dataSets?: DataSet[];
   locus: LocusDTO; // this LocusDTO here might not be the full one (for example it won't have all the participants, but it should have self)
+  metadata?: Metadata;
 };
 
 const LocusObjectStateAfterUpdates = {
@@ -239,7 +241,7 @@ export default class LocusInfo extends EventsScope {
             'Locus-info:index#doLocusSync --> got full DTO when we asked for delta'
           );
         }
-        meeting.locusInfo.onFullLocus(res.body);
+        meeting.locusInfo.onFullLocus('classic Locus sync', res.body);
       })
       .catch((e) => {
         LoggerProxy.logger.info(
@@ -362,14 +364,17 @@ export default class LocusInfo extends EventsScope {
    */
   private createHashTreeParser({
     initialLocus,
+    metadata,
   }: {
     initialLocus: {
       dataSets: Array<DataSet>;
       locus: any;
     };
+    metadata: Metadata;
   }) {
     return new HashTreeParser({
       initialLocus,
+      metadata,
       webexRequest: this.webex.request.bind(this.webex),
       locusInfoUpdateCallback: this.updateFromHashTree.bind(this),
       debugId: `HT-${this.meetingId.substring(0, 4)}`,
@@ -387,6 +392,7 @@ export default class LocusInfo extends EventsScope {
           trigger: 'join-response';
           locus: LocusDTO;
           dataSets?: DataSet[];
+          metadata?: Metadata;
         }
       | {
           trigger: 'locus-message';
@@ -401,28 +407,33 @@ export default class LocusInfo extends EventsScope {
     switch (data.trigger) {
       case 'locus-message':
         if (data.hashTreeMessage) {
-          // we need the SELF object to be in the received message, because it contains visibleDataSets
+          // we need the Metadata object to be in the received message, because it contains visibleDataSets
           // and these are needed to initialize all the hash trees
-          const selfObject = data.hashTreeMessage.locusStateElements?.find((el) => isSelf(el));
+          const metadataObject = data.hashTreeMessage.locusStateElements?.find((el) =>
+            isMetadata(el)
+          );
 
-          if (!selfObject?.data?.visibleDataSets) {
+          if (!metadataObject?.data?.visibleDataSets) {
             LoggerProxy.logger.warn(
-              `Locus-info:index#initialSetup --> cannot initialize HashTreeParser, SELF object with visibleDataSets is missing in the message`
+              `Locus-info:index#initialSetup --> cannot initialize HashTreeParser, Metadata object with visibleDataSets is missing in the message`
             );
 
-            throw new Error('SELF object with visibleDataSets is missing in the message');
+            throw new Error('Metadata object with visibleDataSets is missing in the message');
           }
 
           LoggerProxy.logger.info(
             'Locus-info:index#initialSetup --> creating HashTreeParser from message'
           );
           // first create the HashTreeParser, but don't initialize it with any data yet
-          // pass just a fake locus that contains only the visibleDataSets
           this.hashTreeParser = this.createHashTreeParser({
             initialLocus: {
-              locus: {self: {visibleDataSets: selfObject.data.visibleDataSets}},
+              locus: null,
               dataSets: [], // empty, because they will be populated in initializeFromMessage() call  // dataSets: data.hashTreeMessage.dataSets,
             },
+            metadata: {
+              htMeta: metadataObject.htMeta,
+              visibleDataSets: metadataObject.data.visibleDataSets,
+            },
           });
 
           // now handle the message - that should populate all the visible datasets
@@ -430,12 +441,12 @@ export default class LocusInfo extends EventsScope {
         } else {
           // "classic" Locus case, no hash trees involved
           this.updateLocusCache(data.locus);
-          this.onFullLocus(data.locus, undefined);
+          this.onFullLocus('classic locus message', data.locus, undefined);
         }
         break;
       case 'join-response':
         this.updateLocusCache(data.locus);
-        this.onFullLocus(data.locus, undefined, data.dataSets);
+        this.onFullLocus('join response', data.locus, undefined, data.dataSets, data.metadata);
         break;
       case 'get-loci-response':
         if (data.locus?.links?.resources?.visibleDataSets?.url) {
@@ -443,12 +454,12 @@ export default class LocusInfo extends EventsScope {
             'Locus-info:index#initialSetup --> creating HashTreeParser from get-loci-response'
           );
           // first create the HashTreeParser, but don't initialize it with any data yet
-          // pass just a fake locus that contains only the visibleDataSets
           this.hashTreeParser = this.createHashTreeParser({
             initialLocus: {
-              locus: {self: {visibleDataSets: data.locus?.self?.visibleDataSets}},
+              locus: null,
               dataSets: [], // empty, because we don't have them yet
             },
+            metadata: null, // get-loci-response doesn't contain Metadata object
           });
 
           // now initialize all the data
@@ -456,7 +467,7 @@ export default class LocusInfo extends EventsScope {
         } else {
           // "classic" Locus case, no hash trees involved
           this.updateLocusCache(data.locus);
-          this.onFullLocus(data.locus, undefined);
+          this.onFullLocus('classic get-loci-response', data.locus, undefined);
         }
     }
     // Change it to true after it receives it first locus object
@@ -643,6 +654,12 @@ export default class LocusInfo extends EventsScope {
           }
         }
         break;
+      case ObjectType.metadata:
+        LoggerProxy.logger.info(
+          `Locus-info:index#updateLocusFromHashTreeObject --> metadata object updated to version ${object.htMeta.elementId.version}`
+        );
+        // we don't use hash tree metadata right now for anything, it's mainly used internally by HashTreeParser
+        break;
       default:
         LoggerProxy.logger.warn(
           `Locus-info:index#updateLocusFromHashTreeObject --> received unsupported object type ${type}`
@@ -815,8 +832,18 @@ export default class LocusInfo extends EventsScope {
         data.stateElementsMessage as HashTreeMessage
       );
     } else {
-      // eslint-disable-next-line @typescript-eslint/no-shadow
       const {eventType} = data;
+
+      if (eventType === LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
+        // this can happen when we get an event before join http response
+        // it's OK to just ignore it
+        LoggerProxy.logger.info(
+          `Locus-info:index#parse --> received locus hash tree event before hashTreeParser is created`
+        );
+
+        return;
+      }
+
       const locus = this.getTheLocusToUpdate(data.locus);
       LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);
 
@@ -837,17 +864,11 @@ export default class LocusInfo extends EventsScope {
         case LOCUSEVENT.PARTICIPANT_DECLINED:
         case LOCUSEVENT.FLOOR_GRANTED:
         case LOCUSEVENT.FLOOR_RELEASED:
-          this.onFullLocus(locus, eventType);
+          this.onFullLocus(`classic locus event ${eventType}`, locus, eventType);
           break;
         case LOCUSEVENT.DIFFERENCE:
           this.handleLocusDelta(locus, meeting);
           break;
-        case LOCUSEVENT.HASH_TREE_DATA_UPDATED:
-          this.sendClassicVsHashTreeMismatchMetric(
-            meeting,
-            `got ${eventType}, expected classic events`
-          );
-          break;
 
         default:
           // Why will there be a event with no eventType ????
@@ -871,22 +892,35 @@ export default class LocusInfo extends EventsScope {
   /**
    * Function for handling full locus when it's using hash trees (so not the "classic" one).
    *
+   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
    * @param {object} locus locus object
+   * @param {object} metadata locus hash trees metadata
    * @param {string} eventType locus event
    * @param {DataSet[]} dataSets
    * @returns {void}
    */
-  private onFullLocusWithHashTrees(locus: any, eventType?: string, dataSets?: Array<DataSet>) {
+  private onFullLocusWithHashTrees(
+    debugText: string,
+    locus: any,
+    metadata: Metadata,
+    eventType?: string,
+    dataSets?: Array<DataSet>
+  ) {
     if (!this.hashTreeParser) {
-      LoggerProxy.logger.info(`Locus-info:index#onFullLocus --> creating hash tree parser`);
       LoggerProxy.logger.info(
-        'Locus-info:index#onFullLocus --> dataSets:',
+        `Locus-info:index#onFullLocus (${debugText}) --> creating hash tree parser`
+      );
+      LoggerProxy.logger.info(
+        `Locus-info:index#onFullLocus (${debugText}) --> dataSets:`,
         dataSets,
         ' and locus:',
-        locus
+        locus,
+        ' and metadata:',
+        metadata
       );
       this.hashTreeParser = this.createHashTreeParser({
         initialLocus: {locus, dataSets},
+        metadata,
       });
       this.onFullLocusCommon(locus, eventType);
     } else {
@@ -894,23 +928,24 @@ export default class LocusInfo extends EventsScope {
       // so treat it like if we just got it in any api response
 
       LoggerProxy.logger.info(
-        'Locus-info:index#onFullLocus --> hash tree parser already exists, handling it like a normal API response'
+        `Locus-info:index#onFullLocus (${debugText}) --> hash tree parser already exists, handling it like a normal API response`
       );
-      this.handleLocusAPIResponse(undefined, {dataSets, locus});
+      this.handleLocusAPIResponse(undefined, {dataSets, locus, metadata});
     }
   }
 
   /**
    * Function for handling full locus when it's the "classic" one (not hash trees)
    *
+   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
    * @param {object} locus locus object
    * @param {string} eventType locus event
    * @returns {void}
    */
-  private onFullLocusClassic(locus: any, eventType?: string) {
+  private onFullLocusClassic(debugText: string, locus: any, eventType?: string) {
     if (!this.locusParser.isNewFullLocus(locus)) {
       LoggerProxy.logger.info(
-        `Locus-info:index#onFullLocus --> ignoring old full locus DTO, eventType=${eventType}`
+        `Locus-info:index#onFullLocus (${debugText}) --> ignoring old full locus DTO, eventType=${eventType}`
       );
 
       return;
@@ -920,24 +955,37 @@ export default class LocusInfo extends EventsScope {
 
   /**
    * updates the locus with full locus object
+   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
    * @param {object} locus locus object
    * @param {string} eventType locus event
    * @param {DataSet[]} dataSets
+   * @param {object} metadata locus hash trees metadata
    * @returns {object} null
    * @memberof LocusInfo
    */
-  onFullLocus(locus: any, eventType?: string, dataSets?: Array<DataSet>) {
+  onFullLocus(
+    debugText: string,
+    locus: any,
+    eventType?: string,
+    dataSets?: Array<DataSet>,
+    metadata?: Metadata
+  ) {
     if (!locus) {
       LoggerProxy.logger.error(
-        'Locus-info:index#onFullLocus --> object passed as argument was invalid, continuing.'
+        `Locus-info:index#onFullLocus (${debugText}) --> object passed as argument was invalid, continuing.`
       );
     }
 
     if (dataSets) {
+      if (!metadata) {
+        throw new Error(
+          `Locus-info:index#onFullLocus (${debugText}) --> hash tree metadata is missing with full Locus`
+        );
+      }
       // this is the new hashmap Locus DTO format (only applicable to webinars for now)
-      this.onFullLocusWithHashTrees(locus, eventType, dataSets);
+      this.onFullLocusWithHashTrees(debugText, locus, metadata, eventType, dataSets);
     } else {
-      this.onFullLocusClassic(locus, eventType);
+      this.onFullLocusClassic(debugText, locus, eventType);
     }
   }
 

package/src/media/MediaConnectionAwaiter.ts

@@ -2,9 +2,12 @@ import {Defer} from '@webex/common';
 import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '../constants';
+import BEHAVIORAL_METRICS from '../metrics/constants';
+import Metrics from '../metrics';
 
 export interface MediaConnectionAwaiterProps {
   webrtcMediaConnection: any;
+  correlationId: string;
 }
 
 /**
@@ -16,6 +19,7 @@ export default class MediaConnectionAwaiter {
   private defer: Defer;
   private retried: boolean;
   private iceConnected: boolean;
+  private correlationId: string;
   private onTimeoutCallback: () => void;
   private peerConnectionStateCallback: () => void;
   private iceConnectionStateCallback: () => void;
@@ -24,11 +28,12 @@ export default class MediaConnectionAwaiter {
   /**
    * @param {MediaConnectionAwaiterProps} mediaConnectionAwaiterProps
    */
-  constructor({webrtcMediaConnection}: MediaConnectionAwaiterProps) {
+  constructor({webrtcMediaConnection, correlationId}: MediaConnectionAwaiterProps) {
     this.webrtcMediaConnection = webrtcMediaConnection;
     this.defer = new Defer();
     this.retried = false;
     this.iceConnected = false;
+    this.correlationId = correlationId;
     this.onTimeoutCallback = this.onTimeout.bind(this);
     this.peerConnectionStateCallback = this.peerConnectionStateHandler.bind(this);
     this.iceConnectionStateCallback = this.iceConnectionStateHandler.bind(this);
@@ -175,6 +180,32 @@ export default class MediaConnectionAwaiter {
     this.timer = setTimeout(this.onTimeoutCallback, ICE_AND_DTLS_CONNECTION_TIMEOUT);
   }
 
+  /**
+   * sends a metric with some additional info that might help debugging
+   * issues where browser doesn't update the RTCPeerConnection's iceConnectionState or connectionState
+   *
+   * @returns {void}
+   */
+  async sendMetric() {
+    const stats = await this.webrtcMediaConnection.getStats();
+
+    // in theory we can end up with more than one transport report in the stats,
+    // but for the purpose of this metric it's fine to just use the first one
+    const transportReports = Array.from(
+      stats.values().filter((report) => report.type === 'transport')
+    ) as Record<string, number | string>[];
+
+    Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEDIA_STILL_NOT_CONNECTED, {
+      correlation_id: this.correlationId,
+      numTransports: transportReports.length,
+      dtlsState: transportReports[0]?.dtlsState,
+      iceState: transportReports[0]?.iceState,
+      packetsSent: transportReports[0]?.packetsSent,
+      packetsReceived: transportReports[0]?.packetsReceived,
+      dataChannelState: this.webrtcMediaConnection.multistreamConnection?.dataChannel?.readyState,
+    });
+  }
+
   /**
    * Function called when the timeout is reached.
    *
@@ -189,6 +220,8 @@ export default class MediaConnectionAwaiter {
       return;
     }
 
+    this.sendMetric();
+
     if (!this.isIceGatheringCompleted()) {
       if (!this.retried) {
         LoggerProxy.logger.warn(
@@ -226,8 +259,15 @@ export default class MediaConnectionAwaiter {
    */
   waitForMediaConnectionConnected(): Promise<void> {
     if (this.isConnected()) {
+      LoggerProxy.logger.log(
+        'Media:MediaConnectionAwaiter#waitForMediaConnectionConnected --> Already connected'
+      );
+
       return Promise.resolve();
     }
+    LoggerProxy.logger.log(
+      'Media:MediaConnectionAwaiter#waitForMediaConnectionConnected --> Waiting for media connection to be connected'
+    );
 
     this.webrtcMediaConnection.on(
       MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED,

package/src/media/properties.ts

@@ -196,11 +196,13 @@ export default class MediaProperties {
   /**
    * Waits for the webrtc media connection to be connected.
    *
+   * @param {string} correlationId
    * @returns {Promise<void>}
    */
-  waitForMediaConnectionConnected(): Promise<void> {
+  waitForMediaConnectionConnected(correlationId: string): Promise<void> {
     const mediaConnectionAwaiter = new MediaConnectionAwaiter({
       webrtcMediaConnection: this.webrtcMediaConnection,
+      correlationId,
     });
 
     return mediaConnectionAwaiter.waitForMediaConnectionConnected();

package/src/meeting/index.ts

@@ -13,7 +13,7 @@ import {
   CALL_DIAGNOSTIC_CONFIG,
   RtcMetrics,
 } from '@webex/internal-plugin-metrics';
-import {ClientEvent as RawClientEvent} from '@webex/event-dictionary-ts';
+import type {ClientEvent as RawClientEvent} from '@webex/event-dictionary-ts';
 
 import {
   ConnectionState,
@@ -179,7 +179,7 @@ import JoinForbiddenError from '../common/errors/join-forbidden-error';
 import {ReachabilityMetrics} from '../reachability/reachability.types';
 import {SetStageOptions, SetStageVideoLayout, UnsetStageVideoLayout} from './request.type';
 import {Invitee} from './type';
-import {DataSet} from '../hashTree/hashTreeParser';
+import {DataSet, Metadata} from '../hashTree/hashTreeParser';
 import {LocusDTO} from '../locus-info/types';
 
 // default callback so we don't call an undefined function, but in practice it should never be used
@@ -250,6 +250,7 @@ export type AddMediaOptions = {
   remoteMediaManagerConfig?: RemoteMediaManagerConfiguration; // applies only to multistream meetings
   bundlePolicy?: BundlePolicy; // applies only to multistream meetings
   allowMediaInLobby?: boolean; // allows adding media when in the lobby
+  allowPublishMediaInLobby?: boolean; // allows publishing media when in the lobby, if not specified, default value false is used
   additionalMediaOptions?: AdditionalMediaOptions; // allows adding additional options like send/receive audio/video
 };
 
@@ -623,6 +624,13 @@ export default class Meeting extends StatelessWebexPlugin {
   keepAliveTimerId: NodeJS.Timeout;
   lastVideoLayoutInfo: any;
   locusInfo: any;
+  // this group of properties is populated via updateMeetingObject() that's registered as a callback with LocusInfo
+  isUserUnadmitted?: boolean;
+  joinedWith?: any;
+  selfId?: string;
+  roles: any[];
+  // ... there is more ... see SelfUtils.parse()
+  // end of the group
   locusMediaRequest?: LocusMediaRequest;
   mediaProperties: MediaProperties;
   mediaRequestManagers: {
@@ -657,7 +665,6 @@ export default class Meeting extends StatelessWebexPlugin {
   endCallInitJoinReq: any;
   endJoinReqResp: any;
   endLocalSDPGenRemoteSDPRecvDelay: any;
-  joinedWith: any;
   locusId: any;
   startCallInitJoinReq: any;
   startJoinReqResp: any;
@@ -672,12 +679,10 @@ export default class Meeting extends StatelessWebexPlugin {
   permissionTokenReceivedLocalTime: number;
   resourceId: any;
   resourceUrl: string;
-  selfId: string;
   state: any;
   localAudioStreamMuteStateHandler: () => void;
   localVideoStreamMuteStateHandler: () => void;
   localOutputTrackChangeHandler: () => void;
-  roles: any[];
   environment: string;
   namespace = MEETINGS;
   allowMediaInLobby: boolean;
@@ -4593,7 +4598,8 @@ export default class Meeting extends StatelessWebexPlugin {
     mediaId: string;
     host: object;
     selfId: string;
-    dataSets: DataSet[];
+    dataSets: DataSet[]; // only sent by Locus when hash trees are used
+    metadata: Metadata; // only sent by Locus when hash trees are used
   }) {
     const mtgLocus: any = data.locus;
 
@@ -4609,6 +4615,7 @@ export default class Meeting extends StatelessWebexPlugin {
       trigger: 'join-response',
       locus: mtgLocus,
       dataSets: data.dataSets,
+      metadata: data.metadata,
     });
   }
 
@@ -5781,7 +5788,7 @@ export default class Meeting extends StatelessWebexPlugin {
           this.isReactionsSupported()
         ) {
           const member = this.members.membersCollection.get(e.data.sender.participantId);
-          if (!member) {
+          if (!member && !this.locusInfo?.info?.isWebinar) {
             // @ts-ignore -- fix type
             LoggerProxy.logger.warn(
               `Meeting:index#processRelayEvent --> Skipping handling of ${REACTION_RELAY_TYPES.REACTION} for ${this.id}. participantId ${e.data.sender.participantId} does not exist in membersCollection.`
@@ -5789,7 +5796,7 @@ export default class Meeting extends StatelessWebexPlugin {
             break;
           }
 
-          const {name} = member;
+          const name = (member && member.name) || e.data.sender.displayName;
           const processedReaction: ProcessedReaction = {
             reaction: e.data.reaction,
             sender: {
@@ -7433,7 +7440,7 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   private async waitForMediaConnectionConnected(): Promise<void> {
     try {
-      await this.mediaProperties.waitForMediaConnectionConnected();
+      await this.mediaProperties.waitForMediaConnectionConnected(this.correlationId);
     } catch (error) {
       const {iceConnected} = error;
 
@@ -8026,6 +8033,7 @@ export default class Meeting extends StatelessWebexPlugin {
       remoteMediaManagerConfig,
       bundlePolicy = 'max-bundle',
       additionalMediaOptions = {},
+      allowPublishMediaInLobby = false,
     } = options;
 
     const {
@@ -8046,7 +8054,6 @@ export default class Meeting extends StatelessWebexPlugin {
     const ipver = MeetingUtil.getIpVersion(this.webex); // used just for metrics
 
     // If the user is unjoined or guest waiting in lobby dont allow the user to addMedia
-    // @ts-ignore - isUserUnadmitted coming from SelfUtil
     if (this.isUserUnadmitted && !this.wirelessShare && !this.allowMediaInLobby) {
       throw new UserInLobbyError();
     }
@@ -8091,7 +8098,13 @@ export default class Meeting extends StatelessWebexPlugin {
     this.brbState = createBrbState(this, false);
 
     try {
-      await this.setUpLocalStreamReferences(localStreams);
+      // if we're in a lobby and allowPublishMediaInLobby==false, we don't want to
+      // setup local streams for publishing, because if we ever end up admitted to the meeting
+      // but Locus event about it for us is delayed or missed, others could see/hear our user's video/audio
+      // while the user would still think they're in the lobby
+      if (allowPublishMediaInLobby || !this.isUserUnadmitted) {
+        await this.setUpLocalStreamReferences(localStreams);
+      }
 
       this.setMercuryListener();