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

package/libEs6/components/LegacyMediaAnalytics/createMediaHelper.js

@@ -11,163 +11,176 @@ 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 = "^[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);
+      const stateDetails = {
+        name: result
+      };
+      return {
+        stateDetails
+      };
+    } 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);
+      const qoeDetails = {
+        bitrate: result.bitrate,
+        droppedFrames: result.droppedFrames,
+        fps: result.fps,
+        startupTime: result.startupTime
+      };
+      return {
+        qoeDetails
+      };
+    } catch (error) {
+      logger.warn(`An error occurred while creating the QOE Object.`, error);
+      return {};
+    }
+  };
+  return {
+    createMediaObject,
+    createAdBreakObject,
+    createAdObject,
+    createChapterObject,
+    createStateObject,
+    createQoEObject
+  };
+});

package/libEs6/components/LegacyMediaAnalytics/media/constants.js

@@ -10,11 +10,11 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-export const MediaType = {
+export const MEDIA_TYPE = {
   Video: "video",
   Audio: "audio"
 };
-export const StreamType = {
+export const STREAM_TYPE = {
   VOD: "vod",
   Live: "live",
   Linear: "linear",
@@ -22,14 +22,14 @@ export const StreamType = {
   Audiobook: "audiobook",
   AOD: "aod"
 };
-export const PlayerState = {
+export const PLAYER_STATE = {
   FullScreen: "fullScreen",
   ClosedCaption: "closedCaptioning",
   Mute: "mute",
   PictureInPicture: "pictureInPicture",
   InFocus: "inFocus"
 };
-export const Event = {
+export const EVENT = {
   /**
    * Constant defining event type for AdBreak start
    */
@@ -91,19 +91,19 @@ export const Event = {
    */
   StateEnd: "stateEnd"
 };
-export const mediaEvent = {
+export const MEDIA_EVENTS = {
   SessionStart: "sessionStart",
   SessionEnd: "sessionEnd",
   SessionComplete: "sessionComplete",
   Play: "play",
   Pause: "pauseStart",
-  ...Event
+  ...EVENT
 };
-export const MediaObjectKey = {
+export const MEDIA_OBJECT_KEYS = {
   MediaResumed: "media.resumed",
   GranularAdTracking: "media.granularadtracking"
 };
-export const VideoMetadataKeys = {
+export const VIDEO_METADATA_KEYS = {
   Show: "a.media.show",
   Season: "a.media.season",
   Episode: "a.media.episode",
@@ -122,7 +122,7 @@ export const VideoMetadataKeys = {
   Feed: "a.media.feed",
   StreamFormat: "a.media.format"
 };
-export const AudioMetadataKeys = {
+export const AUDIO_METADATA_KEYS = {
   Artist: "a.media.artist",
   Album: "a.media.album",
   Label: "a.media.label",
@@ -130,7 +130,7 @@ export const AudioMetadataKeys = {
   Station: "a.media.station",
   Publisher: "a.media.publisher"
 };
-export const AdMetadataKeys = {
+export const AD_METADATA_KEYS = {
   Advertiser: "a.media.ad.advertiser",
   CampaignId: "a.media.ad.campaign",
   CreativeId: "a.media.ad.creative",

package/libEs6/components/MediaCollection/constants/eventTypes.js

@@ -0,0 +1,21 @@
+/*
+Copyright 2023 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.
+*/
+export default {
+  PAUSE: "media.pauseStart",
+  PLAY: "media.play",
+  BUFFERING: "media.buffering",
+  AD_START: "media.adStart",
+  SESSION_END: "media.sessionEnd",
+  SESSION_START: "media.sessionStart",
+  SESSION_COMPLETE: "media.sessionComplete",
+  PING: "media.ping"
+};

package/libEs6/components/MediaCollection/createHeartbeatEngine.js

@@ -11,6 +11,12 @@ governing permissions and limitations under the License.
 */
 
 import toInteger from "../../utils/toInteger";
+import MediaEvent from "./constants/eventTypes";
+const ACTION = "ping";
+const getCurrentInterval = playerSession => {
+  const currentTime = Date.now();
+  return Math.abs(currentTime - playerSession.latestTriggeredEvent) / 1000;
+};
 export default (({
   config,
   mediaEventManager,
@@ -21,18 +27,18 @@ export default (({
     sessionId,
     onBeforeMediaEvent
   }) => {
-    const currentTime = Date.now();
     const {
       mainPingInterval
     } = config.mediaCollection;
     const playerSession = mediaSessionCacheManager.getSession(playerId);
-    if (Math.abs(currentTime - playerSession.latestTriggeredEvent) / 1000 > mainPingInterval) {
+    const currentInterval = getCurrentInterval(playerSession);
+    if (currentInterval > mainPingInterval) {
       const {
         playhead,
         qoeDataDetails
       } = onBeforeMediaEvent(playerId);
       const xdm = {
-        eventType: "media.ping",
+        eventType: MediaEvent.PING,
         mediaCollection: {
           playhead: toInteger(playhead),
           sessionID: sessionId,
@@ -45,7 +51,8 @@ export default (({
         }
       });
       return mediaEventManager.trackMediaEvent({
-        event
+        event,
+        action: ACTION
       }).then(() => {
         mediaSessionCacheManager.updateLastTriggeredEventTS({
           playerId

package/libEs6/components/MediaCollection/createMediaEventManager.js

@@ -11,11 +11,11 @@ governing permissions and limitations under the License.
 */
 /* eslint-disable import/no-restricted-paths */
 
-import MediaEvents from "./mediaConstants/mediaEvents";
-import createMediaRequestPayload from "./createMediaRequestPayload";
+import MediaEvents from "./constants/eventTypes";
 import createMediaRequest from "./createMediaRequest";
 import injectTimestamp from "../Context/injectTimestamp";
-import { deepAssign, toInteger } from "../../utils";
+import { toInteger } from "../../utils";
+import { createDataCollectionRequestPayload } from "../../utils/request";
 export default (({
   config,
   eventManager,
@@ -26,14 +26,13 @@ export default (({
     createMediaEvent({
       options
     }) {
+      const event = eventManager.createEvent();
       const {
-        xdm = {}
-      } = options;
-      const event = {
         xdm
-      };
+      } = options;
       const timestamp = injectTimestamp(() => new Date());
-      timestamp(event.xdm);
+      timestamp(xdm);
+      event.setUserXdm(xdm);
       return event;
     },
     createMediaSession(options) {
@@ -43,14 +42,17 @@ export default (({
         version
       } = config.mediaCollection;
       const event = eventManager.createEvent();
+      const {
+        sessionDetails
+      } = options.xdm.mediaCollection;
       event.setUserXdm(options.xdm);
       event.mergeXdm({
         eventType: MediaEvents.SESSION_START,
         mediaCollection: {
           sessionDetails: {
-            playerName: options.xdm.mediaCollection.sessionDetails.playerName || playerName,
-            channel: options.xdm.mediaCollection.sessionDetails.channel || channel,
-            appVersion: options.xdm.mediaCollection.sessionDetails.appVersion || version
+            playerName: sessionDetails.playerName || playerName,
+            channel: sessionDetails.channel || channel,
+            appVersion: sessionDetails.appVersion || version
           }
         }
       });
@@ -71,24 +73,14 @@ export default (({
       } = onBeforeMediaEvent({
         playerId
       });
-      if (event.mergeXdm) {
-        event.mergeXdm({
-          mediaCollection: {
-            playhead: toInteger(playhead),
-            qoeDataDetails
-          }
-        });
-        return event;
-      }
-      return deepAssign(event, {
-        xdm: {
-          mediaCollection: {
-            playhead: toInteger(playhead),
-            qoeDataDetails,
-            sessionID
-          }
+      event.mergeXdm({
+        mediaCollection: {
+          playhead: toInteger(playhead),
+          qoeDataDetails,
+          sessionID
         }
       });
+      return event;
     },
     trackMediaSession({
       event,
@@ -101,15 +93,16 @@ export default (({
       });
     },
     trackMediaEvent({
-      event
+      event,
+      action
     }) {
-      const action = event.xdm.eventType.split(".")[1];
-      const mediaRequestPayload = createMediaRequestPayload();
+      const mediaRequestPayload = createDataCollectionRequestPayload();
       const request = createMediaRequest({
         mediaRequestPayload,
         action
       });
       mediaRequestPayload.addEvent(event);
+      event.finalize();
       return consent.awaitConsent().then(() => {
         return sendEdgeNetworkRequest({
           request

package/libEs6/components/MediaCollection/createMediaSessionCacheManager.js

@@ -19,30 +19,30 @@ export default (() => {
     playerId,
     heartbeatId
   }) => {
-    const mediaSession = mediaSessionCache[playerId];
-    if (!mediaSession) {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
       return;
     }
-    mediaSession.heartbeatId = heartbeatId;
+    sessionDetails.heartbeatId = heartbeatId;
   };
   const stopHeartbeat = ({
     playerId
   }) => {
-    const mediaSession = mediaSessionCache[playerId];
-    if (!mediaSession) {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
       return;
     }
-    clearInterval(mediaSession.heartbeatId);
-    mediaSession.heartbeatId = null;
+    clearInterval(sessionDetails.heartbeatId);
+    sessionDetails.heartbeatId = null;
   };
   const updateLastTriggeredEventTS = ({
     playerId
   }) => {
-    const player = mediaSessionCache[playerId];
-    if (!player) {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
       return;
     }
-    player.latestTriggeredEvent = Date.now();
+    sessionDetails.latestTriggeredEvent = Date.now();
   };
   const storeSession = ({
     playerId,

package/libEs6/components/MediaCollection/createUpdateMediaSessionState.js

@@ -10,20 +10,14 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-import MediaEvents from "./mediaConstants/mediaEvents";
+import MediaEvents from "./constants/eventTypes";
 export default (({
   mediaSessionCacheManager
 }) => {
   return ({
     playerId,
-    xdm
+    eventType
   }) => {
-    if (!playerId) {
-      return;
-    }
-    const {
-      eventType
-    } = xdm;
     if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
       mediaSessionCacheManager.stopHeartbeat({
         playerId

package/libEs6/components/MediaCollection/index.js

@@ -118,26 +118,32 @@ const createMediaCollection = ({
             options
           });
           const {
-            playerId
+            playerId,
+            xdm
           } = options;
+          const eventType = xdm.eventType;
+          const action = eventType.split(".")[1];
           const {
             onBeforeMediaEvent,
             sessionPromise
           } = mediaSessionCacheManager.getSession(playerId);
           sessionPromise.then(result => {
-            const finalEvent = mediaEventManager.augmentMediaEvent({
+            mediaEventManager.augmentMediaEvent({
               event,
               playerId,
               onBeforeMediaEvent,
               sessionID: result.sessionId
             });
             return mediaEventManager.trackMediaEvent({
-              event: finalEvent
+              event,
+              action
             }).then(() => {
               updateMediaSessionState({
                 playerId,
-                xdm: finalEvent.xdm
+                eventType
               });
+            }).catch(error => {
+              logger.warn(`The Media Event of type ${action} failed.`, error);
             });
           });
         }
@@ -151,8 +157,8 @@ createMediaCollection.configValidators = objectOf({
     channel: string().nonEmpty().required(),
     playerName: string().nonEmpty().required(),
     version: string(),
-    mainPingInterval: number().minimum(10).maximum(60).default(10),
-    adPingInterval: number().minimum(10).maximum(60).default(10)
+    mainPingInterval: number().minimum(10).maximum(50).default(10),
+    adPingInterval: number().minimum(10).maximum(50).default(10)
   }).noUnknownFields()
 });
 export default createMediaCollection;