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

package/libEs6/components/LegacyMediaAnalytics/createMediaAnalyticsTracker.js

@@ -1,276 +0,0 @@
-/*
-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 defer from "../../utils/defer";
-import { AD_METADATA_KEYS as AdMetadataKeys, AUDIO_METADATA_KEYS as AudioMetadataKeys, EVENT as Event, PLAYER_STATE as PlayerState, STREAM_TYPE as StreamType, MEDIA_OBJECT_KEYS as MediaObjectKey, VIDEO_METADATA_KEYS as VideoMetadataKeys, MEDIA_TYPE as MediaType, MEDIA_EVENTS } from "./media/constants";
-import { deepAssign, isEmptyObject, isNumber } from "../../utils";
-import { adsToXdmKeys, mediaToXdmKeys } from "./media/mediaKeysToXdmConverter";
-import createMediaHelper from "./createMediaHelper";
-const convertSessionDetailsMetadataToXDM = contextData => {
-  const customMetadata = [];
-  const sessionDetails = {};
-  Object.keys(contextData).forEach(key => {
-    if (mediaToXdmKeys[key]) {
-      sessionDetails[mediaToXdmKeys[key]] = contextData[key];
-    } else {
-      customMetadata.push({
-        name: key,
-        value: contextData[key]
-      });
-    }
-  });
-  return {
-    sessionDetails,
-    customMetadata
-  };
-};
-const createMediaDetailsObject = ({
-  eventType,
-  info,
-  context
-}) => {
-  const mediaDetails = info;
-  const customMetadata = [];
-  if (context && !isEmptyObject(context)) {
-    if (eventType === MEDIA_EVENTS.AdStart) {
-      Object.keys(context).forEach(key => {
-        if (adsToXdmKeys[key]) {
-          mediaDetails.advertisingDetails[mediaToXdmKeys[key]] = context[key];
-        } else {
-          customMetadata.push({
-            name: key,
-            value: context[key]
-          });
-        }
-      });
-    } else {
-      Object.keys(context).forEach(key => {
-        customMetadata.push({
-          name: key,
-          value: context[key]
-        });
-      });
-    }
-    mediaDetails.customMetadata = customMetadata;
-  }
-  return mediaDetails;
-};
-const createHeartbeat = ({
-  mainPingInterval,
-  playerState,
-  trackEvent
-}) => {
-  // eslint-disable-next-line consistent-return
-  return () => {
-    const currentTime = Date.now();
-    if (Math.abs(currentTime - playerState.latestTriggeredEvent) / 1000 > mainPingInterval) {
-      return trackEvent({
-        eventType: "ping"
-      });
-    }
-  };
-};
-const createGetInstance = ({
-  config,
-  logger,
-  mediaEventManager
-}) => {
-  const {
-    mainPingInterval
-  } = config.mediaCollection;
-  const trackerState = {
-    qoe: null,
-    lastPlayhead: 0,
-    latestTriggeredEvent: null
-  };
-  let ticker;
-  let deferSession = defer();
-  const updateLastTimeEventTriggered = () => {
-    trackerState.latestTriggeredEvent = Date.now();
-  };
-  const getEventType = ({
-    eventType
-  }) => {
-    if (eventType === MEDIA_EVENTS.BufferComplete) {
-      return MEDIA_EVENTS.Play;
-    }
-    return eventType;
-  };
-  const trackEvent = ({
-    eventType,
-    mediaDetails
-  }) => {
-    return deferSession.promise.then(sessionID => {
-      const action = getEventType({
-        eventType
-      });
-      const xdm = {
-        eventType: `media.${action}`,
-        mediaCollection: {
-          sessionID,
-          playhead: trackerState.lastPlayhead
-        }
-      };
-      deepAssign(xdm.mediaCollection, mediaDetails);
-      const event = mediaEventManager.createMediaEvent({
-        options: {
-          xdm
-        }
-      });
-      return mediaEventManager.trackMediaEvent({
-        event,
-        action
-      }).then(() => {
-        updateLastTimeEventTriggered();
-      });
-    }).catch(error => {
-      logger.warn(`An error occurred while sending ${eventType} Media Event.`, error);
-    });
-  };
-  const heartbeatEngine = createHeartbeat({
-    mainPingInterval,
-    deferSession,
-    playerState: trackerState,
-    trackEvent
-  });
-  return {
-    trackSessionStart: (mediaObject, contextData = {}) => {
-      if (isEmptyObject(mediaObject)) {
-        deferSession.reject("invalid media object");
-        return {};
-      }
-      const mediaCollection = {
-        playhead: 0
-      };
-      const {
-        sessionDetails,
-        customMetadata
-      } = convertSessionDetailsMetadataToXDM(contextData);
-      deepAssign(mediaCollection, mediaObject, {
-        sessionDetails
-      }, {
-        customMetadata
-      });
-      const event = mediaEventManager.createMediaSession({
-        xdm: {
-          mediaCollection
-        }
-      });
-      return mediaEventManager.trackMediaSession({
-        event
-      }).then(result => {
-        updateLastTimeEventTriggered();
-        deferSession.resolve(result.sessionId);
-        ticker = setInterval(() => {
-          heartbeatEngine();
-        }, 1000);
-      });
-    },
-    trackPlay: () => {
-      return trackEvent({
-        eventType: MEDIA_EVENTS.Play
-      });
-    },
-    trackPause: () => {
-      return trackEvent({
-        eventType: MEDIA_EVENTS.Pause
-      });
-    },
-    trackSessionEnd: () => {
-      clearInterval(ticker);
-      return trackEvent({
-        eventType: MEDIA_EVENTS.SessionEnd
-      }).then(() => {
-        deferSession = null;
-      });
-    },
-    trackComplete: () => {
-      clearInterval(ticker);
-      return trackEvent({
-        eventType: MEDIA_EVENTS.SessionComplete
-      });
-    },
-    trackError: errorId => {
-      logger.info(`trackError(${errorId})`);
-      const errorDetails = {
-        name: errorId,
-        source: "player"
-      };
-      const mediaDetails = {
-        errorDetails
-      };
-      return trackEvent({
-        eventType: MEDIA_EVENTS.SessionEnd,
-        mediaDetails
-      });
-    },
-    trackEvent: (eventType, info, context) => {
-      if (isEmptyObject(info)) {
-        logger.info("invalid media object");
-        return {};
-      }
-      const mediaDetails = createMediaDetailsObject({
-        eventType,
-        info,
-        context
-      });
-      return trackEvent({
-        eventType,
-        mediaDetails
-      });
-    },
-    updatePlayhead: time => {
-      if (isNumber(time)) {
-        trackerState.lastPlayhead = parseInt(time, 10);
-      }
-    },
-    updateQoEObject: qoeObject => {
-      if (!qoeObject) {
-        return;
-      }
-      trackerState.qoe = qoeObject;
-    },
-    destroy: () => {
-      logger.info("Destroy called, destroying the tracker");
-      clearInterval(ticker);
-      deferSession = null;
-    }
-  };
-};
-export const createMediaAnalyticsTracker = ({
-  config,
-  logger,
-  mediaEventManager
-}) => {
-  logger.info("Media Analytics Component was configured");
-  const mediaAnalyticsHelper = createMediaHelper({
-    logger
-  });
-  return {
-    getInstance: () => {
-      return createGetInstance({
-        config,
-        logger,
-        mediaEventManager
-      });
-    },
-    Event,
-    MediaType,
-    PlayerState,
-    StreamType,
-    MediaObjectKey,
-    VideoMetadataKeys,
-    AudioMetadataKeys,
-    AdMetadataKeys,
-    ...mediaAnalyticsHelper
-  };
-};

package/libEs6/components/MediaCollection/createHeartbeatEngine.js

@@ -1,64 +0,0 @@
-/*
-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/createUpdateMediaSessionState.js

@@ -1,30 +0,0 @@
-/*
-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

@@ -1,164 +0,0 @@
-/*
-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;