@webex/plugin-meetings 3.10.0-next.14 → 3.10.0-next.15

package/src/hashTree/types.ts

@@ -1,15 +1,25 @@
 import {Enum} from '../constants';
 
-// todo: Locus docs have now more types like CONTROL_ENTRY, EMBEDDED_APP, FULL_STATE, INFO, MEDIA_SHARE - need to add support for them once Locus implements them
+// todo: Locus docs have now more types like CONTROL_ENTRY, EMBEDDED_APP - need to add support for them once Locus implements them
 export const ObjectType = {
   participant: 'participant',
   self: 'self',
   locus: 'locus',
   mediaShare: 'mediashare',
+  info: 'info',
+  fullState: 'fullstate',
 } as const;
 
 export type ObjectType = Enum<typeof ObjectType>;
 
+// mapping from ObjectType to top level LocusDTO keys
+export const ObjectTypeToLocusKeyMap = {
+  [ObjectType.info]: 'info',
+  [ObjectType.fullState]: 'fullState',
+  [ObjectType.self]: 'self',
+  [ObjectType.participant]: 'participants', // note: each object is a single participant in participants array
+  [ObjectType.mediaShare]: 'mediaShares', // note: each object is a single mediaShare in mediaShares array
+};
 export interface HtMeta {
   elementId: {
     type: ObjectType;

package/src/hashTree/utils.ts

@@ -0,0 +1,42 @@
+/* eslint-disable import/prefer-default-export */
+
+/**
+ * Analyzes given part of Locus DTO recursively and delete any nested objects that have their own htMeta
+ *
+ * @param {Object} currentLocusPart part of locus DTO to analyze
+ * @param {Object} parent parent object
+ * @param {string|number} currentKey key of the parent object that currentLocusPart is
+ * @returns {void}
+ */
+export const deleteNestedObjectsWithHtMeta = (
+  currentLocusPart: any,
+  parent?: any,
+  currentKey?: string | number
+) => {
+  if (typeof currentLocusPart !== 'object' || currentLocusPart === null) {
+    return;
+  }
+
+  if (parent && currentKey !== undefined && currentLocusPart.htMeta) {
+    if (Array.isArray(parent)) {
+      parent.splice(Number(currentKey), 1);
+    } else {
+      delete parent[currentKey];
+    }
+
+    return;
+  }
+
+  if (Array.isArray(currentLocusPart)) {
+    // iterate array in reverse, so that indexes remain valid when deleting elements
+    for (let i = currentLocusPart.length - 1; i >= 0; i -= 1) {
+      deleteNestedObjectsWithHtMeta(currentLocusPart[i], currentLocusPart, i);
+    }
+  } else {
+    for (const key of Object.keys(currentLocusPart)) {
+      if (Object.prototype.hasOwnProperty.call(currentLocusPart, key)) {
+        deleteNestedObjectsWithHtMeta(currentLocusPart[key], currentLocusPart, key);
+      }
+    }
+  }
+};

package/src/locus-info/index.ts

@@ -37,8 +37,8 @@ import HashTreeParser, {
   isSelf,
   LocusInfoUpdateType,
 } from '../hashTree/hashTreeParser';
-import {ObjectType} from '../hashTree/types';
-import {LocusDTO} from './types';
+import {ObjectType, ObjectTypeToLocusKeyMap} from '../hashTree/types';
+import {LocusDTO, LocusFullState} from './types';
 
 export type LocusLLMEvent = {
   data: {
@@ -47,6 +47,8 @@ export type LocusLLMEvent = {
   };
 };
 
+// list of top level keys in Locus DTO relevant for Hash Tree DTOs processing
+// it does not contain fields specific to classic Locus DTOs like sequence or baseSequence
 const LocusDtoTopLevelKeys = [
   'controls',
   'fullState',
@@ -478,12 +480,19 @@ export default class LocusInfo extends EventsScope {
    */
   handleLocusAPIResponse(meeting, responseBody: LocusApiResponseBody): void {
     if (this.hashTreeParser) {
-      // API responses with hash tree are a bit problematic and not fully confirmed how they will look like
-      // we don't really need them, because all updates are guaranteed to come via Mercury or LLM messages anyway
-      // so it's OK to skip them for now
+      if (!responseBody.dataSets) {
+        this.sendClassicVsHashTreeMismatchMetric(
+          meeting,
+          `expected hash tree dataSets in API response but they are missing`
+        );
+        // continuing as we can still manage without responseBody.dataSets, but this is very suspicious
+      }
       LoggerProxy.logger.info(
-        'Locus-info:index#handleLocusAPIResponse: skipping handling of API http response with hashTreeParser'
+        'Locus-info:index#handleLocusAPIResponse --> passing Locus API response to HashTreeParser: ',
+        responseBody
       );
+      // update the data in our hash trees
+      this.hashTreeParser.handleLocusUpdate(responseBody);
     } else {
       if (responseBody.dataSets) {
         this.sendClassicVsHashTreeMismatchMetric(
@@ -511,23 +520,25 @@ export default class LocusInfo extends EventsScope {
           // not doing anything here, as we need Locus to always be there (at least some fields)
           // and that's already taken care of in updateFromHashTree()
           LoggerProxy.logger.info(
-            `Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object removed`
+            `Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object removed, version=${object.htMeta.elementId.version}`
           );
 
           return locus;
         }
         // replace the main locus
 
-        // The Locus object we receive from backend has empty participants, so removing them to avoid it overriding the ones in our current locus object
-        // Also, other fields like mediaShares are managed by other ObjectType updates, so removing them too
-        // BTW, it also doesn't have "self". That's OK as it won't override existing locus.self and also existing SDK code can handle that missing self in Locus updates
+        // The Locus object we receive from backend has empty participants array,
+        // and may have (although it shouldn't) other fields that are managed by other ObjectTypes
+        // like "fullState" or "info", so we're making sure to delete them here
         const locusObjectFromData = object.data;
-        delete locusObjectFromData.participants;
-        delete locusObjectFromData.mediaShares;
+
+        Object.values(ObjectTypeToLocusKeyMap).forEach((locusDtoKey) => {
+          delete locusObjectFromData[locusDtoKey];
+        });
 
         locus = {...locus, ...locusObjectFromData};
         LoggerProxy.logger.info(
-          `Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object updated`
+          `Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object updated to version=${object.htMeta.elementId.version}`
         );
         break;
       }
@@ -540,7 +551,7 @@ export default class LocusInfo extends EventsScope {
               object.data.name === 'content'
                 ? `floor=${object.data.floor?.disposition}, ${object.data.floor?.beneficiary?.id}`
                 : ''
-            }`
+            } version=${object.htMeta.elementId.version}`
           );
           const existingMediaShare = locus.mediaShares?.find(
             (ms) => ms.htMeta.elementId.id === object.htMeta.elementId.id
@@ -554,7 +565,7 @@ export default class LocusInfo extends EventsScope {
           }
         } else {
           LoggerProxy.logger.info(
-            `Locus-info:index#updateLocusFromHashTreeObject --> mediaShare id=${object.htMeta.elementId.id} removed`
+            `Locus-info:index#updateLocusFromHashTreeObject --> mediaShare id=${object.htMeta.elementId.id} removed, version=${object.htMeta.elementId.version}`
           );
           locus.mediaShares = locus.mediaShares?.filter(
             (ms) => ms.htMeta.elementId.id !== object.htMeta.elementId.id
@@ -565,7 +576,7 @@ export default class LocusInfo extends EventsScope {
         LoggerProxy.logger.info(
           `Locus-info:index#updateLocusFromHashTreeObject --> participant id=${
             object.htMeta.elementId.id
-          } ${object.data ? 'updated' : 'removed'}`
+          } ${object.data ? 'updated' : 'removed'} version=${object.htMeta.elementId.version}`
         );
         if (object.data) {
           if (!locus.participants) {
@@ -585,19 +596,22 @@ export default class LocusInfo extends EventsScope {
           this.hashTreeObjectId2ParticipantId.delete(object.htMeta.elementId.id);
         }
         break;
+      case ObjectType.info:
+      case ObjectType.fullState:
       case ObjectType.self:
         if (!object.data) {
           // self without data is handled inside HashTreeParser and results in LocusInfoUpdateType.MEETING_ENDED, so we should never get here
+          // other types like info or fullstate - Locus should never send them without data
           LoggerProxy.logger.warn(
-            `Locus-info:index#updateLocusFromHashTreeObject --> received SELF object without data, this is not expected!`
+            `Locus-info:index#updateLocusFromHashTreeObject --> received ${type} object without data, this is not expected! version=${object.htMeta.elementId.version}`
           );
-
-          return locus;
+        } else {
+          LoggerProxy.logger.info(
+            `Locus-info:index#updateLocusFromHashTreeObject --> ${type} object updated to version ${object.htMeta.elementId.version}`
+          );
+          const locusDtoKey = ObjectTypeToLocusKeyMap[type];
+          locus[locusDtoKey] = object.data;
         }
-        LoggerProxy.logger.info(
-          `Locus-info:index#updateLocusFromHashTreeObject --> SELF object updated`
-        );
-        locus.self = object.data;
         break;
       default:
         LoggerProxy.logger.warn(
@@ -704,19 +718,27 @@ export default class LocusInfo extends EventsScope {
 
         // if Locus object is unchanged or removed, we need to keep using the existing locus
         // because the rest of the locusInfo code expects locus to always be present (with at least some of the fields)
-        // if it gets updated, we don't need to do anything and we start with an empty one
-        // so that when it gets updated, if the new one is missing some field, that field will
+        // if it gets updated, we only need to have the fields that are not part of "locus" object (like "info" or "mediaShares")
+        // so that when Locus object gets updated, if the new one is missing some field, that field will
         // be removed from our locusInfo
         if (
           locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.unchanged ||
           locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.removed
         ) {
-          // copy over existing locus
+          // copy over all of existing locus except participants
           LocusDtoTopLevelKeys.forEach((key) => {
             if (key !== 'participants') {
               locus[key] = cloneDeep(this[key]);
             }
           });
+        } else {
+          // initialize only the fields that are not part of main "Locus" object
+          // (except participants, which need to stay empty - that means "no participant changes")
+          Object.values(ObjectTypeToLocusKeyMap).forEach((locusDtoKey) => {
+            if (locusDtoKey !== 'participants') {
+              locus[locusDtoKey] = cloneDeep(this[locusDtoKey]);
+            }
+          });
         }
 
         LoggerProxy.logger.info(
@@ -724,7 +746,7 @@ export default class LocusInfo extends EventsScope {
             data.updatedObjects.map((o) => ({
               type: o.htMeta.elementId.type,
               id: o.htMeta.elementId.id,
-              hasData: o.data !== undefined,
+              hasData: !!o.data,
             }))
           )}`
         );

package/src/locus-info/types.ts

@@ -1,18 +1,20 @@
 import {HtMeta} from '../hashTree/types';
 
+export type LocusFullState = {
+  active: boolean;
+  count: number;
+  lastActive: string;
+  locked: boolean;
+  sessionId: string;
+  seessionIds: string[];
+  startTime: number;
+  state: string;
+  type: string;
+};
+
 export type LocusDTO = {
   controls?: any;
-  fullState?: {
-    active: boolean;
-    count: number;
-    lastActive: string;
-    locked: boolean;
-    sessionId: string;
-    seessionIds: string[];
-    startTime: number;
-    state: string;
-    type: string;
-  };
+  fullState?: LocusFullState;
   host?: {
     id: string;
     incomingCallProtocols: any[];