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

package/libEs6/components/{MediaCollection/constants/eventTypes.js → StreamingMedia/constants/playbackState.js}

@@ -1,5 +1,5 @@
 /*
-Copyright 2023 Adobe. All rights reserved.
+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
@@ -10,12 +10,7 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 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"
+  MAIN: "main",
+  AD: "ad",
+  COMPLETED: "completed"
 };

package/libEs6/components/{MediaCollection → StreamingMedia}/createMediaEventManager.js

@@ -9,18 +9,16 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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
+  sendEdgeNetworkRequest,
+  setTimestamp
 }) => {
   return {
     createMediaEvent({
@@ -30,17 +28,28 @@ export default (({
       const {
         xdm
       } = options;
-      const timestamp = injectTimestamp(() => new Date());
-      timestamp(xdm);
+      setTimestamp(xdm);
       event.setUserXdm(xdm);
+      if (xdm.eventType === MediaEvents.AD_START) {
+        const {
+          advertisingDetails
+        } = options.xdm.mediaCollection;
+        event.mergeXdm({
+          mediaCollection: {
+            advertisingDetails: {
+              playerName: advertisingDetails.playerName || config.streamingMedia.playerName
+            }
+          }
+        });
+      }
       return event;
     },
     createMediaSession(options) {
       const {
         playerName,
         channel,
-        version
-      } = config.mediaCollection;
+        appVersion
+      } = config.streamingMedia;
       const event = eventManager.createEvent();
       const {
         sessionDetails
@@ -52,7 +61,7 @@ export default (({
           sessionDetails: {
             playerName: sessionDetails.playerName || playerName,
             channel: sessionDetails.channel || channel,
-            appVersion: sessionDetails.appVersion || version
+            appVersion: sessionDetails.appVersion || appVersion
           }
         }
       });
@@ -61,16 +70,16 @@ export default (({
     augmentMediaEvent({
       event,
       playerId,
-      onBeforeMediaEvent,
+      getPlayerDetails,
       sessionID
     }) {
-      if (!playerId || !onBeforeMediaEvent) {
+      if (!playerId || !getPlayerDetails) {
         return event;
       }
       const {
         playhead,
         qoeDataDetails
-      } = onBeforeMediaEvent({
+      } = getPlayerDetails({
         playerId
       });
       event.mergeXdm({
@@ -84,12 +93,10 @@ export default (({
     },
     trackMediaSession({
       event,
-      playerId,
-      onBeforeMediaEvent
+      mediaOptions
     }) {
       return eventManager.sendEvent(event, {
-        playerId,
-        onBeforeMediaEvent
+        mediaOptions
       });
     },
     trackMediaEvent({

package/libEs6/components/StreamingMedia/createMediaResponseHandler.js

@@ -0,0 +1,58 @@
+/*
+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 isBlankString from "../../utils/isBlankString";
+import MediaEvents from "./constants/eventTypes";
+import { isNonEmptyArray } from "../../utils";
+import PlaybackState from "./constants/playbackState";
+export default (({
+  mediaSessionCacheManager,
+  config,
+  trackMediaEvent
+}) => {
+  return ({
+    response,
+    playerId,
+    getPlayerDetails
+  }) => {
+    const mediaPayload = response.getPayloadsByType("media-analytics:new-session");
+    if (isNonEmptyArray(mediaPayload)) {
+      const {
+        sessionId
+      } = mediaPayload[0];
+      if (isBlankString(sessionId)) {
+        return {};
+      }
+      if (!playerId || !getPlayerDetails) {
+        return {
+          sessionId
+        };
+      }
+      const pingId = setTimeout(() => {
+        trackMediaEvent({
+          playerId,
+          xdm: {
+            eventType: MediaEvents.PING
+          }
+        });
+      }, config.streamingMedia.mainPingInterval * 1000);
+      mediaSessionCacheManager.savePing({
+        playerId,
+        pingId,
+        playbackState: PlaybackState.MAIN
+      });
+      return {
+        sessionId
+      };
+    }
+    return {};
+  };
+});

package/libEs6/components/{MediaCollection → StreamingMedia}/createMediaSessionCacheManager.js

@@ -10,39 +10,36 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
+import PlaybackState from "./constants/playbackState";
 export default (() => {
   let mediaSessionCache;
   const getSession = playerId => {
     return mediaSessionCache[playerId] || {};
   };
-  const saveHeartbeat = ({
+  const savePing = ({
     playerId,
-    heartbeatId
+    pingId,
+    playbackState
   }) => {
-    const sessionDetails = mediaSessionCache[playerId];
-    if (!sessionDetails) {
+    if (!mediaSessionCache[playerId]) {
       return;
     }
-    sessionDetails.heartbeatId = heartbeatId;
-  };
-  const stopHeartbeat = ({
-    playerId
-  }) => {
-    const sessionDetails = mediaSessionCache[playerId];
-    if (!sessionDetails) {
-      return;
+    if (mediaSessionCache[playerId].pingId) {
+      clearTimeout(mediaSessionCache[playerId].pingId);
     }
-    clearInterval(sessionDetails.heartbeatId);
-    sessionDetails.heartbeatId = null;
+    mediaSessionCache[playerId].pingId = pingId;
+    mediaSessionCache[playerId].playbackState = playbackState;
   };
-  const updateLastTriggeredEventTS = ({
+  const stopPing = ({
     playerId
   }) => {
     const sessionDetails = mediaSessionCache[playerId];
     if (!sessionDetails) {
       return;
     }
-    sessionDetails.latestTriggeredEvent = Date.now();
+    clearTimeout(sessionDetails.pingId);
+    sessionDetails.pingId = null;
+    sessionDetails.playbackState = PlaybackState.COMPLETED;
   };
   const storeSession = ({
     playerId,
@@ -55,9 +52,8 @@ export default (() => {
   };
   return {
     getSession,
-    stopHeartbeat,
-    updateLastTriggeredEventTS,
     storeSession,
-    saveHeartbeat
+    stopPing,
+    savePing
   };
 });

package/libEs6/components/StreamingMedia/createStreamingMediaComponent.js

@@ -0,0 +1,69 @@
+/*
+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 } from "../../utils";
+import validateSessionOptions from "./validateMediaSessionOptions";
+import validateMediaEventOptions from "./validateMediaEventOptions";
+export default (({
+  config,
+  trackMediaEvent,
+  trackMediaSession,
+  mediaResponseHandler
+}) => {
+  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: {
+      createMediaSession: {
+        optionsValidator: options => validateSessionOptions({
+          options
+        }),
+        run: trackMediaSession
+      },
+      sendMediaEvent: {
+        optionsValidator: options => validateMediaEventOptions({
+          options
+        }),
+        run: options => {
+          if (!config.streamingMedia) {
+            return Promise.reject(new Error("Streaming media is not configured."));
+          }
+          return trackMediaEvent(options);
+        }
+      }
+    }
+  };
+});

package/libEs6/components/StreamingMedia/createTrackMediaEvent.js

@@ -0,0 +1,88 @@
+/*
+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 MediaEvents from "./constants/eventTypes";
+const getContentState = (eventType, sessionContentState) => {
+  if (eventType === MediaEvents.AD_START || eventType === MediaEvents.Ad_BREAK_START || eventType === MediaEvents.AD_SKIP || eventType === MediaEvents.AD_COMPLETE) {
+    return "ad";
+  }
+  if (eventType === MediaEvents.AD_BREAK_COMPLETE || eventType === MediaEvents.CHAPTER_COMPLETE || eventType === MediaEvents.CHAPTER_START || eventType === MediaEvents.CHAPTER_SKIP || eventType === MediaEvents.SESSION_START) {
+    return "main";
+  }
+  if (eventType === MediaEvents.SESSION_END || eventType === MediaEvents.SESSION_COMPLETE) {
+    return "completed";
+  }
+  return sessionContentState;
+};
+export default (({
+  mediaEventManager,
+  mediaSessionCacheManager,
+  config
+}) => {
+  const sendMediaEvent = options => {
+    const event = mediaEventManager.createMediaEvent({
+      options
+    });
+    const {
+      playerId,
+      xdm
+    } = options;
+    const eventType = xdm.eventType;
+    const action = eventType.split(".")[1];
+    const {
+      getPlayerDetails,
+      sessionPromise,
+      playbackState
+    } = mediaSessionCacheManager.getSession(playerId);
+    return sessionPromise.then(result => {
+      mediaEventManager.augmentMediaEvent({
+        event,
+        eventType,
+        playerId,
+        getPlayerDetails,
+        sessionID: result.sessionId
+      });
+      return mediaEventManager.trackMediaEvent({
+        event,
+        action
+      }).then(() => {
+        if (playerId) {
+          if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
+            mediaSessionCacheManager.stopPing({
+              playerId
+            });
+          } else {
+            const sessionPlaybackState = getContentState(eventType, playbackState);
+            if (sessionPlaybackState === "completed") {
+              return;
+            }
+            const interval = sessionPlaybackState === "ad" ? config.streamingMedia.adPingInterval : config.streamingMedia.mainPingInterval;
+            const pingId = setTimeout(() => {
+              const pingOptions = {
+                playerId,
+                xdm: {
+                  eventType: MediaEvents.PING
+                }
+              };
+              sendMediaEvent(pingOptions);
+            }, interval * 1000);
+            mediaSessionCacheManager.savePing({
+              playerId,
+              pingId,
+              playbackState: sessionPlaybackState
+            });
+          }
+        }
+      });
+    });
+  };
+  return options => sendMediaEvent(options);
+});

package/libEs6/components/StreamingMedia/createTrackMediaSession.js

@@ -0,0 +1,51 @@
+/*
+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 PlaybackState from "./constants/playbackState";
+export default (({
+  config,
+  mediaEventManager,
+  mediaSessionCacheManager,
+  legacy = false
+}) => {
+  return options => {
+    if (!config.streamingMedia) {
+      return Promise.reject(new Error("Streaming media is not configured."));
+    }
+    const {
+      playerId,
+      getPlayerDetails
+    } = options;
+    const event = mediaEventManager.createMediaSession(options);
+    mediaEventManager.augmentMediaEvent({
+      event,
+      playerId,
+      getPlayerDetails
+    });
+    const sessionPromise = mediaEventManager.trackMediaSession({
+      event,
+      mediaOptions: {
+        playerId,
+        getPlayerDetails,
+        legacy
+      }
+    });
+    mediaSessionCacheManager.storeSession({
+      playerId,
+      sessionDetails: {
+        sessionPromise,
+        getPlayerDetails,
+        playbackState: PlaybackState.MAIN
+      }
+    });
+    return sessionPromise;
+  };
+});

package/libEs6/components/StreamingMedia/index.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.
+*/
+/* eslint-disable import/no-restricted-paths */
+import createMediaSessionCacheManager from "./createMediaSessionCacheManager";
+import createMediaEventManager from "./createMediaEventManager";
+import createTrackMediaEvent from "./createTrackMediaEvent";
+import configValidators from "./configValidators";
+import createStreamingMediaComponent from "./createStreamingMediaComponent";
+import createTrackMediaSession from "./createTrackMediaSession";
+import createMediaResponseHandler from "./createMediaResponseHandler";
+import injectTimestamp from "../Context/injectTimestamp";
+const createStreamingMedia = ({
+  config,
+  logger,
+  eventManager,
+  sendEdgeNetworkRequest,
+  consent
+}) => {
+  const mediaSessionCacheManager = createMediaSessionCacheManager({
+    config
+  });
+  const mediaEventManager = createMediaEventManager({
+    config,
+    eventManager,
+    logger,
+    consent,
+    sendEdgeNetworkRequest,
+    setTimestamp: injectTimestamp(() => new Date())
+  });
+  const trackMediaEvent = createTrackMediaEvent({
+    mediaSessionCacheManager,
+    mediaEventManager,
+    config
+  });
+  const trackMediaSession = createTrackMediaSession({
+    config,
+    mediaEventManager,
+    mediaSessionCacheManager
+  });
+  const mediaResponseHandler = createMediaResponseHandler({
+    mediaSessionCacheManager,
+    config,
+    trackMediaEvent
+  });
+  return createStreamingMediaComponent({
+    config,
+    trackMediaEvent,
+    mediaEventManager,
+    mediaResponseHandler,
+    trackMediaSession
+  });
+};
+createStreamingMedia.namespace = "Streaming media";
+createStreamingMedia.configValidators = configValidators;
+export default createStreamingMedia;

package/libEs6/components/{MediaCollection → StreamingMedia}/validateMediaEventOptions.js

@@ -9,19 +9,20 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 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";
+import { anyOf, anything, enumOf, number, objectOf, string } from "../../utils/validation";
+import EventTypes from "./constants/eventTypes";
 export default (({
   options
 }) => {
   const validator = anyOf([objectOf({
     playerId: string().required(),
     xdm: objectOf({
-      eventType: string().required(),
+      eventType: enumOf(...Object.values(EventTypes)).required(),
       mediaCollection: objectOf(anything())
     }).required()
   }).required(), objectOf({
     xdm: objectOf({
-      eventType: string().required(),
+      eventType: enumOf(...Object.values(EventTypes)).required(),
       mediaCollection: objectOf({
         playhead: number().integer().required(),
         sessionID: string().required()

package/libEs6/components/{MediaCollection → StreamingMedia}/validateMediaSessionOptions.js

@@ -16,7 +16,7 @@ export default (({
 }) => {
   const sessionValidator = anyOf([objectOf({
     playerId: string().required(),
-    onBeforeMediaEvent: callback().required(),
+    getPlayerDetails: callback().required(),
     xdm: objectOf({
       mediaCollection: objectOf({
         sessionDetails: objectOf(anything()).required()

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.20.0-alpha.1";
+export default "2.20.0-beta.0";

package/libEs6/core/componentCreators.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Adobe. All rights reserved.
+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
@@ -9,23 +9,39 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
+
 // This is the only place where core is allowed to import from components.
 // This makes sure that each component could be removed without breaking the library
+
 /* eslint-disable import/no-restricted-paths */
+
 import createDataCollector from "../components/DataCollector";
+
+/* @skipwhen ENV.alloy_activitycollector === false */
 import createActivityCollector from "../components/ActivityCollector";
 import createIdentity from "../components/Identity";
+
+/* @skipwhen ENV.alloy_audiences === false */
 import createAudiences from "../components/Audiences";
+
+/* @skipwhen ENV.alloy_personalization === false */
 import createPersonalization from "../components/Personalization";
 import createContext from "../components/Context";
 import createPrivacy from "../components/Privacy";
+
+/* @skipwhen ENV.alloy_eventmerge === false */
 import createEventMerge from "../components/EventMerge";
 import createLibraryInfo from "../components/LibraryInfo";
+
+/* @skipwhen ENV.alloy_decisioningengine === false */
 import createDecisioningEngine from "../components/DecisioningEngine";
+
+/* @skipwhen ENV.alloy_machinelearning === false */
 import createMachineLearning from "../components/MachineLearning";
-import createMediaCollection from "../components/MediaCollection";
+import createStreamingMedia from "../components/StreamingMedia";
 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, createLegacyMediaAnalytics, createMediaCollection];
+
+export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine, createLegacyMediaAnalytics, createStreamingMedia];

package/libEs6/core/consent/createConsent.js

@@ -52,6 +52,9 @@ export default (({
     },
     withConsent() {
       return generalConsentState.withConsent();
+    },
+    current() {
+      return generalConsentState.current();
     }
   };
 });

package/libEs6/core/consent/createConsentStateMachine.js

@@ -86,6 +86,40 @@ export default (({
     awaitConsent: awaitInitial,
     withConsent() {
       return this.awaitConsent(true);
+    },
+    current() {
+      switch (this.awaitConsent) {
+        case awaitInDefault:
+          return {
+            state: "in",
+            wasSet: false
+          };
+        case awaitIn:
+          return {
+            state: "in",
+            wasSet: true
+          };
+        case awaitOutDefault:
+          return {
+            state: "out",
+            wasSet: false
+          };
+        case awaitOut:
+          return {
+            state: "out",
+            wasSet: true
+          };
+        case awaitPending:
+          return {
+            state: "pending",
+            wasSet: false
+          };
+        default:
+          return {
+            state: "in",
+            wasSet: false
+          };
+      }
     }
   };
 });

package/libEs6/core/createComponentRegistry.js

@@ -75,6 +75,9 @@ export default (() => {
     },
     getLifecycleCallbacks(hookName) {
       return lifecycleCallbacksByName[hookName] || [];
+    },
+    getComponentNames() {
+      return Object.keys(componentsByNamespace);
     }
   };
 });