@adobe/alloy 2.20.0-alpha.0 → 2.20.0-beta.0

package/libEs6/components/LegacyMediaAnalytics/createGetInstance.js

@@ -0,0 +1,240 @@
+/*
+Copyright 2024 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { EVENT, MEDIA_EVENTS_INTERNAL } from "./constants/constants";
+import { includes, isEmptyObject, isNonEmptyArray, isNumber } from "../../utils";
+import { adsToXdmKeys, mediaToXdmKeys } from "./constants/mediaKeysToXdmConverter";
+export default (({
+  logger,
+  trackMediaSession,
+  trackMediaEvent,
+  uuid
+}) => {
+  let trackerState = {
+    qoe: null,
+    lastPlayhead: 0,
+    playerId: uuid()
+  };
+  const getEventType = ({
+    eventType
+  }) => {
+    if (eventType === EVENT.BufferComplete || eventType === EVENT.SeekComplete) {
+      return MEDIA_EVENTS_INTERNAL.Play;
+    }
+    if (eventType === EVENT.StateStart || eventType === EVENT.StateEnd) {
+      return MEDIA_EVENTS_INTERNAL.StateUpdate;
+    }
+    if (eventType === EVENT.SeekStart) {
+      return MEDIA_EVENTS_INTERNAL.Pause;
+    }
+    return eventType;
+  };
+  const createXdmObject = ({
+    eventType,
+    mediaDetails = {},
+    contextData = []
+  }) => {
+    const action = getEventType({
+      eventType
+    });
+    if (eventType === EVENT.StateStart) {
+      const xdm = {
+        eventType: `media.${action}`,
+        mediaCollection: {
+          statesStart: [mediaDetails]
+        }
+      };
+      return xdm;
+    }
+    if (eventType === EVENT.StateEnd) {
+      const xdm = {
+        eventType: `media.${action}`,
+        mediaCollection: {
+          statesEnd: [mediaDetails]
+        }
+      };
+      return xdm;
+    }
+    const xdm = {
+      eventType: `media.${action}`,
+      mediaCollection: {
+        ...mediaDetails
+      }
+    };
+    const customMetadata = [];
+    Object.keys(contextData).forEach(key => {
+      if (mediaToXdmKeys[key]) {
+        xdm.mediaCollection.sessionDetails[mediaToXdmKeys[key]] = contextData[key];
+      } else if (adsToXdmKeys[key]) {
+        xdm.mediaCollection.advertisingDetails[adsToXdmKeys[key]] = contextData[key];
+      } else {
+        customMetadata.push({
+          name: key,
+          value: contextData[key]
+        });
+      }
+    });
+    if (isNonEmptyArray(customMetadata)) {
+      xdm.mediaCollection.customMetadata = customMetadata;
+    }
+    return xdm;
+  };
+  return {
+    trackSessionStart: (mediaObject, contextData = {}) => {
+      if (isEmptyObject(mediaObject)) {
+        logger.warn("Invalid media object");
+        return {};
+      }
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed. Restarting a new session.");
+        trackerState = {
+          qoe: null,
+          lastPlayhead: 0,
+          playerId: uuid()
+        };
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.SessionStart,
+        mediaDetails: mediaObject,
+        contextData
+      });
+      return trackMediaSession({
+        playerId: trackerState.playerId,
+        getPlayerDetails: () => {
+          return {
+            playhead: trackerState.lastPlayhead,
+            qoeDataDetails: trackerState.qoe
+          };
+        },
+        xdm
+      });
+    },
+    trackPlay: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.Play
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackPause: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.Pause
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackSessionEnd: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.SessionEnd
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackComplete: () => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.SessionComplete
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackError: errorId => {
+      logger.warn(`trackError(${errorId})`);
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      const errorDetails = {
+        name: errorId,
+        source: "player"
+      };
+      const xdm = createXdmObject({
+        eventType: MEDIA_EVENTS_INTERNAL.Error,
+        mediaDetails: {
+          errorDetails
+        }
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    trackEvent: (eventType, info, context) => {
+      if (isEmptyObject(info)) {
+        logger.warn("Invalid media object.");
+        return {};
+      }
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return {};
+      }
+      if (!includes(Object.values(EVENT), eventType)) {
+        logger.warn("Invalid event type");
+        return {};
+      }
+      const xdm = createXdmObject({
+        eventType,
+        mediaDetails: info,
+        contextData: context
+      });
+      return trackMediaEvent({
+        playerId: trackerState.playerId,
+        xdm
+      });
+    },
+    updatePlayhead: time => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return;
+      }
+      if (isNumber(time)) {
+        trackerState.lastPlayhead = parseInt(time, 10);
+      }
+    },
+    updateQoEObject: qoeObject => {
+      if (trackerState === null) {
+        logger.warn("The Media Session was completed.");
+        return;
+      }
+      if (!qoeObject) {
+        return;
+      }
+      trackerState.qoe = qoeObject;
+    },
+    destroy: () => {
+      logger.warn("Destroy called, destroying the tracker.");
+      trackerState = null;
+    }
+  };
+});

package/libEs6/components/LegacyMediaAnalytics/createLegacyMediaComponent.js

@@ -0,0 +1,85 @@
+/*
+Copyright 2024 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { noop, uuid } from "../../utils";
+import { AD_METADATA_KEYS as AdMetadataKeys, AUDIO_METADATA_KEYS as AudioMetadataKeys, EVENT as Event, MEDIA_OBJECT_KEYS as MediaObjectKey, MEDIA_TYPE as MediaType, PLAYER_STATE as PlayerState, STREAM_TYPE as StreamType, VIDEO_METADATA_KEYS as VideoMetadataKeys } from "./constants/constants";
+export default (({
+  trackMediaEvent,
+  trackMediaSession,
+  mediaResponseHandler,
+  logger,
+  createMediaHelper,
+  createGetInstance,
+  config
+}) => {
+  return {
+    lifecycle: {
+      onBeforeEvent({
+        mediaOptions,
+        onResponse = noop
+      }) {
+        if (!mediaOptions) {
+          return;
+        }
+        const {
+          legacy,
+          playerId,
+          getPlayerDetails
+        } = mediaOptions;
+        if (!legacy) {
+          return;
+        }
+        onResponse(({
+          response
+        }) => {
+          return mediaResponseHandler({
+            playerId,
+            getPlayerDetails,
+            response
+          });
+        });
+      }
+    },
+    commands: {
+      getMediaAnalyticsTracker: {
+        run: () => {
+          if (!config.streamingMedia) {
+            return Promise.reject(new Error("Streaming media is not configured."));
+          }
+          logger.info("Streaming media is configured in legacy mode.");
+          const mediaAnalyticsHelper = createMediaHelper({
+            logger
+          });
+          return Promise.resolve({
+            getInstance: () => {
+              return createGetInstance({
+                logger,
+                trackMediaEvent,
+                trackMediaSession,
+                uuid
+              });
+            },
+            Event,
+            MediaType,
+            PlayerState,
+            StreamType,
+            MediaObjectKey,
+            VideoMetadataKeys,
+            AudioMetadataKeys,
+            AdMetadataKeys,
+            ...mediaAnalyticsHelper
+          });
+        }
+      }
+    }
+  };
+});

package/libEs6/components/LegacyMediaAnalytics/createMediaHelper.js

@@ -11,163 +11,170 @@ governing permissions and limitations under the License.
 */
 
 import { number, objectOf, string } from "../../utils/validation";
-export const createMediaObject = (friendlyName, name, length, contentType, streamType) => {
-  const mediaObject = {
-    friendlyName,
-    name,
-    length,
-    streamType,
-    contentType
-  };
-  const validate = objectOf({
-    friendlyName: string().nonEmpty(),
-    name: string().nonEmpty(),
-    length: number().required(),
-    streamType: string().nonEmpty(),
-    contentType: string().nonEmpty()
-  });
-  try {
-    const result = validate(mediaObject);
-    const sessionDetails = {
-      name: result.name,
-      friendlyName: result.friendlyName,
-      length: result.length,
-      streamType: result.streamType,
-      contentType: result.contentType
-    };
-    return {
-      sessionDetails
+export default (({
+  logger
+}) => {
+  const createMediaObject = (friendlyName, name, length, contentType, streamType) => {
+    const mediaObject = {
+      friendlyName,
+      name,
+      length,
+      streamType,
+      contentType
     };
-  } catch (error) {
-    return {};
-  }
-};
-export const createAdBreakObject = (name, position, startTime) => {
-  const adBreakObject = {
-    friendlyName: name,
-    offset: position,
-    index: startTime
+    const validate = objectOf({
+      friendlyName: string().nonEmpty(),
+      name: string().nonEmpty(),
+      length: number().required(),
+      streamType: string().nonEmpty(),
+      contentType: string().nonEmpty()
+    });
+    try {
+      const result = validate(mediaObject);
+      const sessionDetails = {
+        name: result.name,
+        friendlyName: result.friendlyName,
+        length: result.length,
+        streamType: result.streamType,
+        contentType: result.contentType
+      };
+      return {
+        sessionDetails
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the Media Object.`, error);
+      return {};
+    }
   };
-  const validator = objectOf({
-    friendlyName: string().nonEmpty(),
-    offset: number(),
-    index: number()
-  });
-  try {
-    const result = validator(adBreakObject);
-    const advertisingPodDetails = {
-      friendlyName: result.friendlyName,
-      offset: result.offset,
-      index: result.index
-    };
-    return {
-      advertisingPodDetails
+  const createAdBreakObject = (name, position, startTime) => {
+    const adBreakObject = {
+      friendlyName: name,
+      offset: position,
+      index: startTime
     };
-  } catch (error) {
-    return {};
-  }
-};
-export const createAdObject = (name, id, position, length) => {
-  const adObject = {
-    friendlyName: name,
-    name: id,
-    podPosition: position,
-    length
+    const validator = objectOf({
+      friendlyName: string().nonEmpty(),
+      offset: number(),
+      index: number()
+    });
+    try {
+      const result = validator(adBreakObject);
+      const advertisingPodDetails = {
+        friendlyName: result.friendlyName,
+        offset: result.offset,
+        index: result.index
+      };
+      return {
+        advertisingPodDetails
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the Ad Break Object.`, error);
+      return {};
+    }
   };
-  const validator = objectOf({
-    friendlyName: string().nonEmpty(),
-    name: string().nonEmpty(),
-    podPosition: number(),
-    length: number()
-  });
-  try {
-    const result = validator(adObject);
-    const advertisingDetails = {
-      friendlyName: result.friendlyName,
-      name: result.name,
-      podPosition: result.podPosition,
-      length: result.length
+  const createAdObject = (name, id, position, length) => {
+    const adObject = {
+      friendlyName: name,
+      name: id,
+      podPosition: position,
+      length
     };
-    return {
-      advertisingDetails
-    };
-  } catch (error) {
-    return {};
-  }
-};
-export const createChapterObject = (name, position, length, startTime) => {
-  const chapterDetailsObject = {
-    friendlyName: name,
-    offset: position,
-    length,
-    index: startTime
+    const validator = objectOf({
+      friendlyName: string().nonEmpty(),
+      name: string().nonEmpty(),
+      podPosition: number(),
+      length: number()
+    });
+    try {
+      const result = validator(adObject);
+      const advertisingDetails = {
+        friendlyName: result.friendlyName,
+        name: result.name,
+        podPosition: result.podPosition,
+        length: result.length
+      };
+      return {
+        advertisingDetails
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the Advertising Object.`, error);
+      return {};
+    }
   };
-  const validator = objectOf({
-    friendlyName: string().nonEmpty(),
-    offset: number(),
-    length: number(),
-    index: number()
-  });
-  try {
-    const result = validator(chapterDetailsObject);
-    const chapterDetails = {
-      friendlyName: result.friendlyName,
-      offset: result.offset,
-      index: result.index,
-      length: result.length
-    };
-    return {
-      chapterDetails
+  const createChapterObject = (name, position, length, startTime) => {
+    const chapterDetailsObject = {
+      friendlyName: name,
+      offset: position,
+      length,
+      index: startTime
     };
-  } catch (error) {
-    return {};
-  }
-};
-export const createStateObject = stateName => {
-  const STATE_NAME_REGEX = new RegExp("^[a-zA-Z0-9_\\.]{1,64}$");
-  const state = {
-    state: stateName
+    const validator = objectOf({
+      friendlyName: string().nonEmpty(),
+      offset: number(),
+      length: number(),
+      index: number()
+    });
+    try {
+      const result = validator(chapterDetailsObject);
+      const chapterDetails = {
+        friendlyName: result.friendlyName,
+        offset: result.offset,
+        index: result.index,
+        length: result.length
+      };
+      return {
+        chapterDetails
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the Chapter Object.`, error);
+      return {};
+    }
   };
-  const validator = objectOf({
-    state: string().regexp(STATE_NAME_REGEX)
-  });
-  try {
-    const result = validator(state);
-    const stateDetails = {
-      name: result.name
-    };
-    return {
-      stateDetails
-    };
-  } catch (error) {
-    return {};
-  }
-};
-export const createQoEObject = (bitrate, droppedFrames, fps, startupTime) => {
-  const qoeObject = {
-    bitrate,
-    droppedFrames,
-    fps,
-    startupTime
+  const createStateObject = stateName => {
+    const STATE_NAME_REGEX = new RegExp("^[a-zA-Z0-9_]{1,64}$");
+    const validator = string().matches(STATE_NAME_REGEX, "This is not a valid state name.");
+    try {
+      const result = validator(stateName);
+      return {
+        name: result
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the State Object.`, error);
+      return {};
+    }
   };
-  const validator = objectOf({
-    bitrate: number(),
-    droppedFrames: number(),
-    fps: number(),
-    startupTime: number()
-  });
-  try {
-    const result = validator(qoeObject);
-    const qoeDetails = {
-      bitrate: result.bitrate,
-      droppedFrames: result.droppedFrames,
-      fps: result.fps,
-      startupTime: result.startupTime
-    };
-    return {
-      qoeDetails
+  const createQoEObject = (bitrate, droppedFrames, fps, startupTime) => {
+    const qoeObject = {
+      bitrate,
+      droppedFrames,
+      fps,
+      startupTime
     };
-  } catch (error) {
-    return {};
-  }
-};
+    const validator = objectOf({
+      bitrate: number(),
+      droppedFrames: number(),
+      fps: number(),
+      startupTime: number()
+    });
+    try {
+      const result = validator(qoeObject);
+      return {
+        bitrate: result.bitrate,
+        droppedFrames: result.droppedFrames,
+        framesPerSecond: result.fps,
+        timeToStart: result.startupTime
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the QOE Object.`, error);
+      return {};
+    }
+  };
+  return {
+    createMediaObject,
+    createAdBreakObject,
+    createAdObject,
+    createChapterObject,
+    createStateObject,
+    createQoEObject
+  };
+});