@adobe/alloy 2.19.2 → 2.20.0-alpha.1

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

@@ -0,0 +1,64 @@
+/*
+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.
+*/
+
+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,
+  mediaSessionCacheManager
+}) => {
+  return ({
+    playerId,
+    sessionId,
+    onBeforeMediaEvent
+  }) => {
+    const {
+      mainPingInterval
+    } = config.mediaCollection;
+    const playerSession = mediaSessionCacheManager.getSession(playerId);
+    const currentInterval = getCurrentInterval(playerSession);
+    if (currentInterval > mainPingInterval) {
+      const {
+        playhead,
+        qoeDataDetails
+      } = onBeforeMediaEvent(playerId);
+      const xdm = {
+        eventType: MediaEvent.PING,
+        mediaCollection: {
+          playhead: toInteger(playhead),
+          sessionID: sessionId,
+          qoeDataDetails
+        }
+      };
+      const event = mediaEventManager.createMediaEvent({
+        options: {
+          xdm
+        }
+      });
+      return mediaEventManager.trackMediaEvent({
+        event,
+        action: ACTION
+      }).then(() => {
+        mediaSessionCacheManager.updateLastTriggeredEventTS({
+          playerId
+        });
+      });
+    }
+    return Promise.resolve();
+  };
+});

package/libEs6/components/MediaCollection/createMediaEventManager.js

@@ -0,0 +1,115 @@
+/*
+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.
+*/
+/* eslint-disable import/no-restricted-paths */
+
+import MediaEvents from "./constants/eventTypes";
+import createMediaRequest from "./createMediaRequest";
+import injectTimestamp from "../Context/injectTimestamp";
+import { toInteger } from "../../utils";
+import { createDataCollectionRequestPayload } from "../../utils/request";
+export default (({
+  config,
+  eventManager,
+  consent,
+  sendEdgeNetworkRequest
+}) => {
+  return {
+    createMediaEvent({
+      options
+    }) {
+      const event = eventManager.createEvent();
+      const {
+        xdm
+      } = options;
+      const timestamp = injectTimestamp(() => new Date());
+      timestamp(xdm);
+      event.setUserXdm(xdm);
+      return event;
+    },
+    createMediaSession(options) {
+      const {
+        playerName,
+        channel,
+        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: sessionDetails.playerName || playerName,
+            channel: sessionDetails.channel || channel,
+            appVersion: sessionDetails.appVersion || version
+          }
+        }
+      });
+      return event;
+    },
+    augmentMediaEvent({
+      event,
+      playerId,
+      onBeforeMediaEvent,
+      sessionID
+    }) {
+      if (!playerId || !onBeforeMediaEvent) {
+        return event;
+      }
+      const {
+        playhead,
+        qoeDataDetails
+      } = onBeforeMediaEvent({
+        playerId
+      });
+      event.mergeXdm({
+        mediaCollection: {
+          playhead: toInteger(playhead),
+          qoeDataDetails,
+          sessionID
+        }
+      });
+      return event;
+    },
+    trackMediaSession({
+      event,
+      playerId,
+      onBeforeMediaEvent
+    }) {
+      return eventManager.sendEvent(event, {
+        playerId,
+        onBeforeMediaEvent
+      });
+    },
+    trackMediaEvent({
+      event,
+      action
+    }) {
+      const mediaRequestPayload = createDataCollectionRequestPayload();
+      const request = createMediaRequest({
+        mediaRequestPayload,
+        action
+      });
+      mediaRequestPayload.addEvent(event);
+      event.finalize();
+      return consent.awaitConsent().then(() => {
+        return sendEdgeNetworkRequest({
+          request
+        }).then(() => {
+          return {};
+        });
+      });
+    }
+  };
+});

package/libEs6/components/MediaCollection/createMediaRequest.js

@@ -0,0 +1,28 @@
+/*
+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.
+*/
+
+import { createRequest } from "../../utils/request";
+export default (({
+  mediaRequestPayload,
+  action
+}) => {
+  return createRequest({
+    payload: mediaRequestPayload,
+    edgeSubPath: "/va",
+    getAction() {
+      return action;
+    },
+    getUseSendBeacon() {
+      return false;
+    }
+  });
+});

package/libEs6/components/MediaCollection/createMediaSessionCacheManager.js

@@ -0,0 +1,63 @@
+/*
+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 (() => {
+  let mediaSessionCache;
+  const getSession = playerId => {
+    return mediaSessionCache[playerId] || {};
+  };
+  const saveHeartbeat = ({
+    playerId,
+    heartbeatId
+  }) => {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
+      return;
+    }
+    sessionDetails.heartbeatId = heartbeatId;
+  };
+  const stopHeartbeat = ({
+    playerId
+  }) => {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
+      return;
+    }
+    clearInterval(sessionDetails.heartbeatId);
+    sessionDetails.heartbeatId = null;
+  };
+  const updateLastTriggeredEventTS = ({
+    playerId
+  }) => {
+    const sessionDetails = mediaSessionCache[playerId];
+    if (!sessionDetails) {
+      return;
+    }
+    sessionDetails.latestTriggeredEvent = Date.now();
+  };
+  const storeSession = ({
+    playerId,
+    sessionDetails
+  }) => {
+    if (mediaSessionCache === undefined) {
+      mediaSessionCache = {};
+    }
+    mediaSessionCache[playerId] = sessionDetails;
+  };
+  return {
+    getSession,
+    stopHeartbeat,
+    updateLastTriggeredEventTS,
+    storeSession,
+    saveHeartbeat
+  };
+});

package/libEs6/components/MediaCollection/createUpdateMediaSessionState.js

@@ -0,0 +1,30 @@
+/*
+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.
+*/
+
+import MediaEvents from "./constants/eventTypes";
+export default (({
+  mediaSessionCacheManager
+}) => {
+  return ({
+    playerId,
+    eventType
+  }) => {
+    if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
+      mediaSessionCacheManager.stopHeartbeat({
+        playerId
+      });
+    }
+    mediaSessionCacheManager.updateLastTriggeredEventTS({
+      playerId
+    });
+  };
+});

package/libEs6/components/MediaCollection/index.js

@@ -0,0 +1,164 @@
+/*
+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.
+*/
+
+import { string, number, objectOf } from "../../utils/validation";
+import createMediaSessionCacheManager from "./createMediaSessionCacheManager";
+import validateMediaEventOptions from "./validateMediaEventOptions";
+import validateSessionOptions from "./validateMediaSessionOptions";
+import createMediaEventManager from "./createMediaEventManager";
+import { noop } from "../../utils";
+import createHeartbeatEngine from "./createHeartbeatEngine";
+import createUpdateMediaSessionState from "./createUpdateMediaSessionState";
+const createMediaCollection = ({
+  config,
+  logger,
+  eventManager,
+  sendEdgeNetworkRequest,
+  consent
+}) => {
+  const mediaSessionCacheManager = createMediaSessionCacheManager({
+    config
+  });
+  const mediaEventManager = createMediaEventManager({
+    config,
+    eventManager,
+    logger,
+    consent,
+    sendEdgeNetworkRequest
+  });
+  const heartbeatTicker = createHeartbeatEngine({
+    config,
+    mediaEventManager,
+    mediaSessionCacheManager
+  });
+  const updateMediaSessionState = createUpdateMediaSessionState({
+    mediaSessionCacheManager
+  });
+  return {
+    lifecycle: {
+      onBeforeEvent({
+        playerId,
+        onBeforeMediaEvent,
+        onResponse = noop
+      }) {
+        onResponse(({
+          response
+        }) => {
+          const sessionId = response.getPayloadsByType("media-analytics:new-session");
+          logger.info("Media session ID returned: ", sessionId);
+          if (sessionId.length > 0) {
+            if (playerId && onBeforeMediaEvent) {
+              const heartbeatId = setInterval(() => {
+                heartbeatTicker({
+                  sessionId: sessionId[0].sessionId,
+                  playerId,
+                  onBeforeMediaEvent
+                });
+              }, 1000);
+              mediaSessionCacheManager.saveHeartbeat({
+                playerId,
+                heartbeatId
+              });
+            }
+            return {
+              sessionId: sessionId[0].sessionId
+            };
+          }
+          return {};
+        });
+      }
+    },
+    commands: {
+      createMediaSession: {
+        optionsValidator: options => validateSessionOptions({
+          options
+        }),
+        run: options => {
+          const {
+            playerId,
+            onBeforeMediaEvent
+          } = options;
+          const event = mediaEventManager.createMediaSession(options);
+          mediaEventManager.augmentMediaEvent({
+            event,
+            playerId,
+            onBeforeMediaEvent
+          });
+          const sessionPromise = mediaEventManager.trackMediaSession({
+            event,
+            playerId,
+            onBeforeMediaEvent
+          });
+          mediaSessionCacheManager.storeSession({
+            playerId,
+            sessionDetails: {
+              sessionPromise,
+              onBeforeMediaEvent,
+              latestTriggeredEvent: Date.now()
+            }
+          });
+          return sessionPromise;
+        }
+      },
+      sendMediaEvent: {
+        optionsValidator: options => validateMediaEventOptions({
+          options
+        }),
+        run: options => {
+          const event = mediaEventManager.createMediaEvent({
+            options
+          });
+          const {
+            playerId,
+            xdm
+          } = options;
+          const eventType = xdm.eventType;
+          const action = eventType.split(".")[1];
+          const {
+            onBeforeMediaEvent,
+            sessionPromise
+          } = mediaSessionCacheManager.getSession(playerId);
+          sessionPromise.then(result => {
+            mediaEventManager.augmentMediaEvent({
+              event,
+              playerId,
+              onBeforeMediaEvent,
+              sessionID: result.sessionId
+            });
+            return mediaEventManager.trackMediaEvent({
+              event,
+              action
+            }).then(() => {
+              updateMediaSessionState({
+                playerId,
+                eventType
+              });
+            }).catch(error => {
+              logger.warn(`The Media Event of type ${action} failed.`, error);
+            });
+          });
+        }
+      }
+    }
+  };
+};
+createMediaCollection.namespace = "Media Collection";
+createMediaCollection.configValidators = objectOf({
+  mediaCollection: objectOf({
+    channel: string().nonEmpty().required(),
+    playerName: string().nonEmpty().required(),
+    version: string(),
+    mainPingInterval: number().minimum(10).maximum(50).default(10),
+    adPingInterval: number().minimum(10).maximum(50).default(10)
+  }).noUnknownFields()
+});
+export default createMediaCollection;

package/libEs6/components/MediaCollection/validateMediaEventOptions.js

@@ -0,0 +1,32 @@
+/*
+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.
+*/
+import { anyOf, anything, number, objectOf, string } from "../../utils/validation";
+export default (({
+  options
+}) => {
+  const validator = anyOf([objectOf({
+    playerId: string().required(),
+    xdm: objectOf({
+      eventType: string().required(),
+      mediaCollection: objectOf(anything())
+    }).required()
+  }).required(), objectOf({
+    xdm: objectOf({
+      eventType: string().required(),
+      mediaCollection: objectOf({
+        playhead: number().integer().required(),
+        sessionID: string().required()
+      }).required()
+    }).required()
+  }).required()], "Error validating the sendMediaEvent command options.");
+  return validator(options);
+});

package/libEs6/components/MediaCollection/validateMediaSessionOptions.js

@@ -0,0 +1,34 @@
+/*
+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.
+*/
+
+import { anyOf, anything, callback, number, objectOf, string } from "../../utils/validation";
+export default (({
+  options
+}) => {
+  const sessionValidator = anyOf([objectOf({
+    playerId: string().required(),
+    onBeforeMediaEvent: callback().required(),
+    xdm: objectOf({
+      mediaCollection: objectOf({
+        sessionDetails: objectOf(anything()).required()
+      })
+    })
+  }).required(), objectOf({
+    xdm: objectOf({
+      mediaCollection: objectOf({
+        playhead: number().required(),
+        sessionDetails: objectOf(anything()).required()
+      })
+    })
+  }).required()], "Error validating the createMediaSession command options.");
+  return sessionValidator(options);
+});

package/libEs6/components/Personalization/createFetchDataHandler.js

@@ -32,10 +32,7 @@ export default (({
       showContainers();
     }
     mergeQuery(event, personalizationDetails.createQueryDetails());
-
-    // This needs to be called before the response so that future sendEvent calls
-    // can know to wait until this request is complete for pending display notifications.
-    const handleNotifications = notificationHandler(personalizationDetails.isRenderDecisions(), personalizationDetails.isSendDisplayEvent(), personalizationDetails.getViewName());
+    const handleNotifications = notificationHandler(personalizationDetails.isSendDisplayEvent(), personalizationDetails.getViewName());
     onResponse(({
       response
     }) => {

package/libEs6/components/Personalization/createNotificationHandler.js

@@ -11,12 +11,8 @@ governing permissions and limitations under the License.
 */
 import { defer } from "../../utils";
 export default ((collect, renderedPropositions) => {
-  return (isRenderDecisions, isSendDisplayEvent, viewName) => {
-    if (!isRenderDecisions) {
-      // If we aren't rendering anything, then we don't need to sendDisplayEvents.
-      return () => undefined;
-    }
-    if (!isSendDisplayEvent) {
+  return (sendDisplayEvent, viewName) => {
+    if (!sendDisplayEvent) {
       const renderedPropositionsDeferred = defer();
       renderedPropositions.concat(renderedPropositionsDeferred.promise);
       return renderedPropositionsDeferred.resolve;

package/libEs6/components/Personalization/createOnDecisionHandler.js

@@ -33,7 +33,7 @@ export default (({
       render,
       returnedPropositions
     } = processPropositions(propositionsToExecute);
-    const handleNotifications = notificationHandler(renderDecisions, sendDisplayEvent, viewName);
+    const handleNotifications = notificationHandler(sendDisplayEvent, viewName);
     render().then(handleNotifications);
     return Promise.resolve({
       propositions: returnedPropositions

package/libEs6/constants/libraryVersion.js

@@ -13,4 +13,4 @@ governing permissions and limitations under the License.
 // The __VERSION__ keyword will be replace at alloy build time with the package.json version.
 // see babel-plugin-version
 
-export default "2.19.2";
+export default "2.20.0-alpha.1";

package/libEs6/core/componentCreators.js

@@ -23,7 +23,9 @@ import createEventMerge from "../components/EventMerge";
 import createLibraryInfo from "../components/LibraryInfo";
 import createDecisioningEngine from "../components/DecisioningEngine";
 import createMachineLearning from "../components/MachineLearning";
+import createMediaCollection from "../components/MediaCollection";
+import createLegacyMediaAnalytics from "../components/LegacyMediaAnalytics";
 
 // TODO: Register the Components here statically for now. They might be registered differently.
 // TODO: Figure out how sub-components will be made available/registered
-export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine];
+export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine, createLegacyMediaAnalytics, createMediaCollection];

package/libEs6/core/edgeNetwork/injectSendEdgeNetworkRequest.js

@@ -53,7 +53,7 @@ export default (({
     }).then(() => {
       const endpointDomain = request.getUseIdThirdPartyDomain() ? ID_THIRD_PARTY_DOMAIN : edgeDomain;
       const locationHint = getLocationHint();
-      const edgeBasePathWithLocationHint = locationHint ? `${edgeBasePath}/${locationHint}` : edgeBasePath;
+      const edgeBasePathWithLocationHint = locationHint ? `${edgeBasePath}/${locationHint}${request.getEdgeSubPath()}` : `${edgeBasePath}${request.getEdgeSubPath()}`;
       const configId = request.getDatastreamIdOverride() || datastreamId;
       const payload = request.getPayload();
       if (configId !== datastreamId) {

package/libEs6/utils/debounce.js

@@ -0,0 +1,22 @@
+/*
+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 ((fn, delay = 150) => {
+  let timer;
+  return (...args) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      fn(...args);
+    }, delay);
+  };
+});

package/libEs6/utils/request/createRequest.js

@@ -18,7 +18,8 @@ export default (options => {
     payload,
     getAction,
     getUseSendBeacon,
-    datastreamIdOverride
+    datastreamIdOverride,
+    edgeSubPath
   } = options;
   const id = uuid();
   let shouldUseThirdPartyDomain = false;
@@ -43,6 +44,12 @@ export default (options => {
         isIdentityEstablished
       });
     },
+    getEdgeSubPath() {
+      if (edgeSubPath) {
+        return edgeSubPath;
+      }
+      return "";
+    },
     getUseIdThirdPartyDomain() {
       return shouldUseThirdPartyDomain;
     },