@24i/bigscreen-sdk 1.0.39 → 1.0.40-alpha.2687

package/packages/adobe-heartbeat/src/AdobeHeartbeat.ts

@@ -1,244 +1,244 @@
-/// <reference path='./__external__/Adobe/Adobe.d.ts' />
-import { IErrorEvent, PlayerBase } from '@24i/bigscreen-players-engine-base';
-import { time } from '@24i/bigscreen-sdk/time';
-import { SECOND_IN_MS } from '@24i/bigscreen-sdk/utils';
-import { va as Adobe } from './__external__/Adobe/MediaSDK.min';
-import {
-    CustomerMetadata, HeartbeatConfig,
-    StandardMetadata, AdBreakMetadata, AdMetadata,
-} from './types';
-
-/**
- * Wrapper class for version 2.x of Adobe Media Analytics SDK
- * @typeparam CustomMetadata - defaults to void, as in no custom metadata are used
- */
-export class AdobeHeartbeat<CustomMetadata extends CustomerMetadata | void = void> {
-    static StreamType = Adobe.MediaHeartbeat.StreamType;
-
-    private player?: PlayerBase;
-
-    /**
-     * Heartbeat configuration object
-     */
-    config: HeartbeatConfig;
-
-    /**
-     * Heartbeat tracker instance
-     */
-    tracker?: Adobe.MediaHeartbeat;
-
-    /**
-     * Initializes Adobe Heartbeat tracker
-     * @param config - Heartbeat configuration object
-     * @param player - 24i universal player instance
-     */
-    constructor(config: HeartbeatConfig, player?: PlayerBase) {
-        if (!window.s || !AppMeasurement) throw new Error('Missing Adobe Launch library!');
-        this.config = config;
-        this.player = player;
-
-        const {
-            visitor, pageName, charSet, trackingServer, trackingServerSecure, ssl,
-        } = window.s;
-        const appMeasurementOptions = {
-            visitor, pageName, charSet, trackingServer, trackingServerSecure, ssl,
-        };
-        // enable SSL forcefuly because default doesn't even if secure server is available
-        appMeasurementOptions.ssl = true;
-
-        const appMeasurement = AppMeasurement.getInstance(s.account);
-        Object.assign(appMeasurement, appMeasurementOptions);
-
-        const mediaConfig = new Adobe.MediaHeartbeatConfig();
-        Object.assign(mediaConfig, config);
-
-        const mediaDelegate = new Adobe.MediaHeartbeatDelegate();
-        Object.assign(mediaDelegate, this.getMediaDelegateMethods());
-
-        try {
-            this.tracker = new Adobe.MediaHeartbeat(mediaDelegate, mediaConfig, appMeasurement);
-        } catch (err) {}
-        if (!this.tracker) throw new Error('Failed to initialise Adobe Heartbeat tracking object!');
-
-        if (this.player) this.attachPlayerListeners(this.player);
-    }
-
-    private getMediaDelegateMethods() {
-        return {
-            getCurrentPlaybackTime: () => {
-                if (!this.player) return 0;
-                const { currentTime } = this.player.mediaInfo || {};
-                if (this.player.live) {
-                    try {
-                        const { programEnd = NaN } = this.player.metadata;
-                        return Math.floor((programEnd - currentTime) / SECOND_IN_MS)
-                            || time.getCurrentUnixTime();
-                    } catch (e) {
-                        return time.getCurrentUnixTime();
-                    }
-                }
-                return Math.floor(currentTime / SECOND_IN_MS) || 0;
-            },
-            getQoSObject: () => {
-                if (!this.player) return Adobe.MediaHeartbeat.createQoSObject();
-                const { bitrate, droppedVideoFrames } = this.player.mediaInfo || {};
-                return Adobe.MediaHeartbeat.createQoSObject(
-                    bitrate, undefined, undefined, droppedVideoFrames,
-                );
-            },
-        };
-    }
-
-    private attachPlayerListeners(player: PlayerBase) {
-        player.addEventListener('play', this.onPlay);
-        player.addEventListener('pause', this.onPause);
-        player.addEventListener('ended', this.onEnded);
-        player.addEventListener('seeking', this.onSeekStart);
-        player.addEventListener('seeked', this.onSeekEnd);
-        player.addEventListener('error', this.onError);
-    }
-
-    private dettachPlayerListeners(player: PlayerBase) {
-        player.removeEventListener('play', this.onPlay);
-        player.removeEventListener('pause', this.onPause);
-        player.removeEventListener('ended', this.onEnded);
-        player.removeEventListener('seeking', this.onSeekStart);
-        player.removeEventListener('seeked', this.onSeekEnd);
-        player.removeEventListener('error', this.onError);
-    }
-
-    private readonly onPlay = () => this.tracker?.trackPlay();
-
-    private readonly onPause = () => this.tracker?.trackPause();
-
-    private readonly onEnded = () => this.tracker?.trackComplete();
-
-    private readonly onSeekStart = () => (
-        this.tracker?.trackEvent(Adobe.MediaHeartbeat.Event.SeekStart)
-    );
-
-    private readonly onSeekEnd = () => (
-        this.tracker?.trackEvent(Adobe.MediaHeartbeat.Event.SeekComplete)
-    );
-
-    private readonly onError = (e: IErrorEvent) => this.tracker?.trackError(
-        e.error.code?.toString?.() ?? '',
-    );
-
-    private stringifyValues(
-        customMetadata: CustomerMetadata | void,
-    ): Record<string, string> | undefined {
-        if (!customMetadata) return undefined;
-        const result = {} as Record<string, string>;
-        Object.entries(customMetadata as Record<string, string>).forEach(([key, value]) => {
-            result[key] = String(value);
-        });
-        return result;
-    }
-
-    /**
-     * Provide a player instance to listen to for tracking events. Used if the player instance
-     * is only available after user's intent to start playback should be tracked and it wasnt
-     * provided in constructor. Alternatively if for some reason you have new player instance
-     * this will replace the old one.
-     * @param player - 24i universal player instance
-     */
-    attachPlayer(player: PlayerBase) {
-        if (this.player) this.dettachPlayerListeners(this.player);
-        this.player = player;
-        if (this.player) this.attachPlayerListeners(this.player);
-    }
-
-    /**
-     * Starts the tracking session. Should be used to track the users
-     * intention to start playback, not the beginning of actual playback
-     * @param metadata - Media info metadata
-     * @param customMetadata - Optional, Additional metadata specific for customer
-     */
-    startSession(metadata: StandardMetadata, customMetadata: CustomMetadata) {
-        if (!this.tracker) return;
-        const mediaObject = Adobe.MediaHeartbeat.createMediaObject(
-            metadata.name,
-            metadata.mediaId,
-            metadata.lengthSec,
-            metadata.streamType,
-            Adobe.MediaHeartbeat.MediaType.Video, // only support video for now
-        );
-        // eslint-disable-next-line no-underscore-dangle
-        this.tracker._config.channel = metadata.channel;
-        this.tracker.trackSessionStart(
-            mediaObject,
-            this.stringifyValues(customMetadata),
-        );
-    }
-
-    /**
-     * Stops the tracking session.
-     */
-    stopSession() {
-        if (!this.tracker) return;
-        this.tracker.trackSessionEnd();
-    }
-
-    /**
-     * Starts the tracking session for ad break.
-     * @param metadata - AdBreak info metadata
-     */
-    adBreakStarted(metadata: AdBreakMetadata) {
-        if (!this.tracker) return;
-        const adBreakObject = Adobe.MediaHeartbeat.createAdBreakObject(
-            metadata.name,
-            metadata.position,
-            metadata.startTime,
-        );
-        this.tracker.trackEvent(
-            Adobe.MediaHeartbeat.Event.AdBreakStart,
-            adBreakObject,
-        );
-    }
-
-    /**
-     * Starts the tracking for a single ad in ad break.
-     * @param metadata - Ad info metadata
-     * @param customMetadata - Optional, Additional metadata specific for customer
-     */
-    adStarted(metadata: AdMetadata, customMetadata?: CustomerMetadata) {
-        if (!this.tracker) return;
-        const adObject = Adobe.MediaHeartbeat.createAdObject(
-            metadata.name,
-            metadata.adId,
-            metadata.position,
-            metadata.length,
-        );
-        this.tracker.trackEvent(
-            Adobe.MediaHeartbeat.Event.AdStart,
-            adObject,
-            this.stringifyValues(customMetadata),
-        );
-    }
-
-    /**
-     * To be called when ad playback reaches the end.
-     */
-    adCompleted() {
-        if (!this.tracker) return;
-        this.tracker.trackEvent(Adobe.MediaHeartbeat.Event.AdComplete);
-    }
-
-    /**
-     * To be called when ad playback didn't reach the end
-     * because the user skipped it.
-     */
-    adSkipped() {
-        if (!this.tracker) return;
-        this.tracker.trackEvent(Adobe.MediaHeartbeat.Event.AdSkip);
-    }
-
-    /**
-     * Tracks the end of ad break.
-     */
-    adBreakComplete() {
-        if (!this.tracker) return;
-        this.tracker.trackEvent(Adobe.MediaHeartbeat.Event.AdBreakComplete);
-    }
-}
+/// <reference path='./__external__/Adobe/Adobe.d.ts' />
+import { IErrorEvent, PlayerBase } from '@24i/bigscreen-players-engine-base';
+import { time } from '@24i/bigscreen-sdk/time';
+import { SECOND_IN_MS } from '@24i/bigscreen-sdk/utils';
+import { va as Adobe } from './__external__/Adobe/MediaSDK.min';
+import {
+    CustomerMetadata, HeartbeatConfig,
+    StandardMetadata, AdBreakMetadata, AdMetadata,
+} from './types';
+
+/**
+ * Wrapper class for version 2.x of Adobe Media Analytics SDK
+ * @typeparam CustomMetadata - defaults to void, as in no custom metadata are used
+ */
+export class AdobeHeartbeat<CustomMetadata extends CustomerMetadata | void = void> {
+    static StreamType = Adobe.MediaHeartbeat.StreamType;
+
+    private player?: PlayerBase;
+
+    /**
+     * Heartbeat configuration object
+     */
+    config: HeartbeatConfig;
+
+    /**
+     * Heartbeat tracker instance
+     */
+    tracker?: Adobe.MediaHeartbeat;
+
+    /**
+     * Initializes Adobe Heartbeat tracker
+     * @param config - Heartbeat configuration object
+     * @param player - 24i universal player instance
+     */
+    constructor(config: HeartbeatConfig, player?: PlayerBase) {
+        if (!window.s || !AppMeasurement) throw new Error('Missing Adobe Launch library!');
+        this.config = config;
+        this.player = player;
+
+        const {
+            visitor, pageName, charSet, trackingServer, trackingServerSecure, ssl,
+        } = window.s;
+        const appMeasurementOptions = {
+            visitor, pageName, charSet, trackingServer, trackingServerSecure, ssl,
+        };
+        // enable SSL forcefuly because default doesn't even if secure server is available
+        appMeasurementOptions.ssl = true;
+
+        const appMeasurement = AppMeasurement.getInstance(s.account);
+        Object.assign(appMeasurement, appMeasurementOptions);
+
+        const mediaConfig = new Adobe.MediaHeartbeatConfig();
+        Object.assign(mediaConfig, config);
+
+        const mediaDelegate = new Adobe.MediaHeartbeatDelegate();
+        Object.assign(mediaDelegate, this.getMediaDelegateMethods());
+
+        try {
+            this.tracker = new Adobe.MediaHeartbeat(mediaDelegate, mediaConfig, appMeasurement);
+        } catch (err) {}
+        if (!this.tracker) throw new Error('Failed to initialise Adobe Heartbeat tracking object!');
+
+        if (this.player) this.attachPlayerListeners(this.player);
+    }
+
+    private getMediaDelegateMethods() {
+        return {
+            getCurrentPlaybackTime: () => {
+                if (!this.player) return 0;
+                const { currentTime } = this.player.mediaInfo || {};
+                if (this.player.live) {
+                    try {
+                        const { programEnd = NaN } = this.player.metadata;
+                        return Math.floor((programEnd - currentTime) / SECOND_IN_MS)
+                            || time.getCurrentUnixTime();
+                    } catch (e) {
+                        return time.getCurrentUnixTime();
+                    }
+                }
+                return Math.floor(currentTime / SECOND_IN_MS) || 0;
+            },
+            getQoSObject: () => {
+                if (!this.player) return Adobe.MediaHeartbeat.createQoSObject();
+                const { bitrate, droppedVideoFrames } = this.player.mediaInfo || {};
+                return Adobe.MediaHeartbeat.createQoSObject(
+                    bitrate, undefined, undefined, droppedVideoFrames,
+                );
+            },
+        };
+    }
+
+    private attachPlayerListeners(player: PlayerBase) {
+        player.addEventListener('play', this.onPlay);
+        player.addEventListener('pause', this.onPause);
+        player.addEventListener('ended', this.onEnded);
+        player.addEventListener('seeking', this.onSeekStart);
+        player.addEventListener('seeked', this.onSeekEnd);
+        player.addEventListener('error', this.onError);
+    }
+
+    private dettachPlayerListeners(player: PlayerBase) {
+        player.removeEventListener('play', this.onPlay);
+        player.removeEventListener('pause', this.onPause);
+        player.removeEventListener('ended', this.onEnded);
+        player.removeEventListener('seeking', this.onSeekStart);
+        player.removeEventListener('seeked', this.onSeekEnd);
+        player.removeEventListener('error', this.onError);
+    }
+
+    private readonly onPlay = () => this.tracker?.trackPlay();
+
+    private readonly onPause = () => this.tracker?.trackPause();
+
+    private readonly onEnded = () => this.tracker?.trackComplete();
+
+    private readonly onSeekStart = () => (
+        this.tracker?.trackEvent(Adobe.MediaHeartbeat.Event.SeekStart)
+    );
+
+    private readonly onSeekEnd = () => (
+        this.tracker?.trackEvent(Adobe.MediaHeartbeat.Event.SeekComplete)
+    );
+
+    private readonly onError = (e: IErrorEvent) => this.tracker?.trackError(
+        e.error.code?.toString?.() ?? '',
+    );
+
+    private stringifyValues(
+        customMetadata: CustomerMetadata | void,
+    ): Record<string, string> | undefined {
+        if (!customMetadata) return undefined;
+        const result = {} as Record<string, string>;
+        Object.entries(customMetadata as Record<string, string>).forEach(([key, value]) => {
+            result[key] = String(value);
+        });
+        return result;
+    }
+
+    /**
+     * Provide a player instance to listen to for tracking events. Used if the player instance
+     * is only available after user's intent to start playback should be tracked and it wasnt
+     * provided in constructor. Alternatively if for some reason you have new player instance
+     * this will replace the old one.
+     * @param player - 24i universal player instance
+     */
+    attachPlayer(player: PlayerBase) {
+        if (this.player) this.dettachPlayerListeners(this.player);
+        this.player = player;
+        if (this.player) this.attachPlayerListeners(this.player);
+    }
+
+    /**
+     * Starts the tracking session. Should be used to track the users
+     * intention to start playback, not the beginning of actual playback
+     * @param metadata - Media info metadata
+     * @param customMetadata - Optional, Additional metadata specific for customer
+     */
+    startSession(metadata: StandardMetadata, customMetadata: CustomMetadata) {
+        if (!this.tracker) return;
+        const mediaObject = Adobe.MediaHeartbeat.createMediaObject(
+            metadata.name,
+            metadata.mediaId,
+            metadata.lengthSec,
+            metadata.streamType,
+            Adobe.MediaHeartbeat.MediaType.Video, // only support video for now
+        );
+        // eslint-disable-next-line no-underscore-dangle
+        this.tracker._config.channel = metadata.channel;
+        this.tracker.trackSessionStart(
+            mediaObject,
+            this.stringifyValues(customMetadata),
+        );
+    }
+
+    /**
+     * Stops the tracking session.
+     */
+    stopSession() {
+        if (!this.tracker) return;
+        this.tracker.trackSessionEnd();
+    }
+
+    /**
+     * Starts the tracking session for ad break.
+     * @param metadata - AdBreak info metadata
+     */
+    adBreakStarted(metadata: AdBreakMetadata) {
+        if (!this.tracker) return;
+        const adBreakObject = Adobe.MediaHeartbeat.createAdBreakObject(
+            metadata.name,
+            metadata.position,
+            metadata.startTime,
+        );
+        this.tracker.trackEvent(
+            Adobe.MediaHeartbeat.Event.AdBreakStart,
+            adBreakObject,
+        );
+    }
+
+    /**
+     * Starts the tracking for a single ad in ad break.
+     * @param metadata - Ad info metadata
+     * @param customMetadata - Optional, Additional metadata specific for customer
+     */
+    adStarted(metadata: AdMetadata, customMetadata?: CustomerMetadata) {
+        if (!this.tracker) return;
+        const adObject = Adobe.MediaHeartbeat.createAdObject(
+            metadata.name,
+            metadata.adId,
+            metadata.position,
+            metadata.length,
+        );
+        this.tracker.trackEvent(
+            Adobe.MediaHeartbeat.Event.AdStart,
+            adObject,
+            this.stringifyValues(customMetadata),
+        );
+    }
+
+    /**
+     * To be called when ad playback reaches the end.
+     */
+    adCompleted() {
+        if (!this.tracker) return;
+        this.tracker.trackEvent(Adobe.MediaHeartbeat.Event.AdComplete);
+    }
+
+    /**
+     * To be called when ad playback didn't reach the end
+     * because the user skipped it.
+     */
+    adSkipped() {
+        if (!this.tracker) return;
+        this.tracker.trackEvent(Adobe.MediaHeartbeat.Event.AdSkip);
+    }
+
+    /**
+     * Tracks the end of ad break.
+     */
+    adBreakComplete() {
+        if (!this.tracker) return;
+        this.tracker.trackEvent(Adobe.MediaHeartbeat.Event.AdBreakComplete);
+    }
+}

package/packages/adobe-heartbeat/src/__external__/Adobe/Adobe.d.ts

@@ -1,24 +1,24 @@
-declare namespace s {
-    const account: string;
-    const visitor: any;
-    const pageName: any;
-    const charSet: any;
-    const trackingServer: any;
-    const trackingServerSecure: any;
-    const ssl: any;
-}
-
-declare interface VisitorAPIInstance {}
-
-declare interface AppMeasurementInstance {
-    trackingServer: string;
-    trackingServerSecure: string;
-    visitor: VisitorAPIInstance;
-    pageName: string;
-    charSet: string;
-    ssl: boolean;
-}
-
-declare class AppMeasurement {
-    static getInstance: (account: string) => AppMeasurementInstance;
-}
+declare namespace s {
+    const account: string;
+    const visitor: any;
+    const pageName: any;
+    const charSet: any;
+    const trackingServer: any;
+    const trackingServerSecure: any;
+    const ssl: any;
+}
+
+declare interface VisitorAPIInstance {}
+
+declare interface AppMeasurementInstance {
+    trackingServer: string;
+    trackingServerSecure: string;
+    visitor: VisitorAPIInstance;
+    pageName: string;
+    charSet: string;
+    ssl: boolean;
+}
+
+declare class AppMeasurement {
+    static getInstance: (account: string) => AppMeasurementInstance;
+}