@applicaster/zapp-react-native-utils 12.0.0-alpha.4043183114 → 12.0.0-alpha.4155487673

package/analyticsUtils/AnalyticPlayerListener.ts

@@ -0,0 +1,141 @@
+import { PlayerAnalyticsTracker } from "./playerAnalyticsTracker";
+import { Player } from "../appUtils/playerManager/player";
+import { AD_EVENT, GENERAL_EVENT, PLAYBACK_EVENT, QOS_EVENT } from "./events";
+
+type Props = {
+  analyticsTracker: any;
+  player: any;
+};
+
+/* eslint brace-style: 0 */ // --> OFF
+export class AnalyticPlayerListener
+  implements QuickBrickPlayer.SharedPlayerCallBacks
+{
+  static analyticsListenerID = "analytics-listener";
+  private analyticsTracker: PlayerAnalyticsTracker;
+  private player: Player;
+
+  private onVideoLoadCalled; // android only
+
+  constructor(props: Props) {
+    this.analyticsTracker = props.analyticsTracker;
+    this.player = props.player;
+  }
+
+  handleAnalyticEvent = (event, data = {}) => {
+    if (this.analyticsTracker?.handleAnalyticEvent) {
+      this.analyticsTracker?.handleAnalyticEvent?.(event, {
+        ...data,
+        player_type: this.player.playerPluginId,
+      });
+    }
+  };
+
+  onVideoEnd = () => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.complete);
+  };
+
+  onError = (err: Error) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.error, err); // TODO: Check error format
+  };
+
+  onPlayerPause = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.pause, event);
+  };
+
+  onPlayerResume = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.play, event);
+  };
+
+  onPlayerSeekComplete = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.seek_complete, event);
+  };
+
+  onPlayerSeekStart = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.seek_start, event);
+  };
+
+  onBufferStart = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.buffer_start, event);
+  };
+
+  onBufferComplete = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.buffer_complete, event);
+  };
+
+  // Not implemented
+  onPlayerStop = (event) => {
+    this.handleAnalyticEvent(PLAYBACK_EVENT.stop, event);
+  };
+
+  // TODO: Implement method on native
+  onVideoBandwidthUpdate = (event) => {
+    this.handleAnalyticEvent(QOS_EVENT.bitrate_changed, event);
+  };
+
+  onAdBegin = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_start, event);
+  };
+
+  onAdBreakBegin = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_break_start, event);
+  };
+
+  onAdBreakEnd = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_break_completed, event);
+  };
+
+  onAdEnd = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_complete, event);
+  };
+
+  onAdError = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_error, event);
+  };
+
+  onAdRequest = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_request, event);
+  };
+
+  onAdClicked = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_clicked, event);
+  };
+
+  onAdTapped = (event) => {
+    this.handleAnalyticEvent(AD_EVENT.ad_tapped, event);
+  };
+
+  onVideoLoad = () => {
+    // if (!this.state.isAd && !this.onVideoLoadCalled) {
+    if (!this.player.isAd() && !this.onVideoLoadCalled) {
+      this.onVideoLoadCalled = true;
+
+      this.handleAnalyticEvent(PLAYBACK_EVENT.load_video, {
+        player_type: this.player.playerPluginId,
+      });
+    }
+  };
+
+  onPlayerSessionEnd = () => {
+    // TODO: Implement method on native android, ios exists
+    this.handleAnalyticEvent(GENERAL_EVENT.session_end);
+  };
+
+  onPlayerSessionStart = () => {
+    // TODO: Implement method on native android, ios exists
+
+    this.handleAnalyticEvent(GENERAL_EVENT.session_start);
+  };
+
+  onPlayerNext = ({ nativeEvent }) => {
+    // TODO: Implement method on native
+
+    this.handleAnalyticEvent(PLAYBACK_EVENT.next, nativeEvent);
+  };
+
+  onPlayerPrevious = ({ nativeEvent }) => {
+    // TODO: Implement method on native
+
+    this.handleAnalyticEvent(PLAYBACK_EVENT.previous, nativeEvent);
+  };
+}

package/analyticsUtils/PlayerAnalyticsManager.ts

@@ -0,0 +1,90 @@
+import {
+  PlayerAnalyticsTracker,
+  PlayerAnalyticsTrackerI,
+} from "./playerAnalyticsTracker";
+import {
+  PlayerLifecycleListener,
+  PlayerManager,
+} from "../appUtils/playerManager";
+import { Player } from "../appUtils/playerManager/player";
+import { AnalyticPlayerListener } from "./AnalyticPlayerListener";
+import { PlayerRole } from "../appUtils/playerManager/conts";
+
+enum PlayerAnalyticsTrackerType {
+  PlayerAnalyticsTracker = "PlayerAnalyticsTracker",
+}
+
+class PlayerAnalyticsTrackerFactory {
+  createTracker(type: PlayerAnalyticsTrackerType) {
+    switch (type) {
+      case PlayerAnalyticsTrackerType.PlayerAnalyticsTracker:
+        return new PlayerAnalyticsTracker();
+      default:
+        return new PlayerAnalyticsTracker();
+    }
+  }
+}
+
+export class PlayerAnalyticsManager implements PlayerLifecycleListener {
+  static instance: PlayerAnalyticsManager;
+  private trackers: Record<string, PlayerAnalyticsTrackerI> = {};
+  private trackerFactory: PlayerAnalyticsTrackerFactory;
+
+  public getTracker(
+    id: string,
+    type: PlayerAnalyticsTrackerType = PlayerAnalyticsTrackerType.PlayerAnalyticsTracker
+  ): PlayerAnalyticsTrackerI {
+    if (!this.trackers[id]) {
+      this.trackers[id] = this.trackerFactory.createTracker(type);
+    }
+
+    return this.trackers[id];
+  }
+
+  constructor(trackerFactory: PlayerAnalyticsTrackerFactory) {
+    this.trackerFactory = trackerFactory;
+    this.startListenPlayerManager();
+  }
+
+  static getInstance(
+    trackerFactory: PlayerAnalyticsTrackerFactory = new PlayerAnalyticsTrackerFactory()
+  ): PlayerAnalyticsManager {
+    if (!PlayerAnalyticsManager.instance) {
+      PlayerAnalyticsManager.instance = new PlayerAnalyticsManager(
+        trackerFactory
+      );
+    }
+
+    return PlayerAnalyticsManager.instance;
+  }
+
+  private startListenPlayerManager() {
+    PlayerManager.getInstance().addLifecycleListener(this);
+  }
+
+  // PlayerLifecycleListener
+
+  onRegistered = (player: Player) => {
+    if (player.playerRole !== PlayerRole.Primary) {
+      return;
+    }
+
+    const tracker = this.getTracker(player.playerId);
+    tracker.setPlayer(player);
+
+    const analyticsListener = new AnalyticPlayerListener({
+      analyticsTracker: tracker,
+      player,
+    });
+
+    player.addListener({
+      id: AnalyticPlayerListener.analyticsListenerID,
+      listener: analyticsListener,
+    });
+  };
+
+  onUnRegistered = (player: Player) => {
+    player.removeListener(AnalyticPlayerListener.analyticsListenerID);
+    delete this.trackers[player.playerId];
+  };
+}

package/analyticsUtils/{analyticsTracker.ts → playerAnalyticsTracker.ts}

@@ -5,16 +5,25 @@ import { postAnalyticEvent } from "./manager";
 import { isLive } from "../playerUtils";
 import { extensionsEvents } from "./AnalyticsEvents/helper";
 import { AD_EVENT, EVENT_TYPES, PLAYER_DISPLAY_STATES } from "./events";
+import { Player } from "../appUtils/playerManager/player";
 
-export class AnalyticsTracker {
+export interface PlayerAnalyticsTrackerI {
+  handleAnalyticEvent(
+    event: QuickBrickPlayer.Events,
+    eventData?: QuickBrickPlayer.EventData
+  ): void;
+  setPlayer(player: Player): void;
+}
+
+export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
   adTime: number | string;
   mediaTime: number | string;
-  entry: ZappEntry;
   eventType: string;
   playerState: QuickBrickPlayer.NativePlayerState;
+  private player: Player;
 
-  constructor(entry: any) {
-    this.entry = entry;
+  setPlayer(player: Player) {
+    this.player = player;
   }
 
   isAdBreak(event: string): boolean {
@@ -30,6 +39,10 @@ export class AnalyticsTracker {
     return !!isAdBreak;
   }
 
+  get entry(): ZappEntry {
+    return this.player?.getEntry();
+  }
+
   getDuration(
     event: QuickBrickPlayer.Events,
     eventData: QuickBrickPlayer.EventData
@@ -215,13 +228,9 @@ export class AnalyticsTracker {
 
   handleAnalyticEvent(
     event: QuickBrickPlayer.Events,
-    eventData: QuickBrickPlayer.EventData = {},
-    entry: ZappEntry,
-    playerState = null
+    eventData: QuickBrickPlayer.EventData = {}
   ) {
-    this.entry = entry;
-    this.playerState = playerState;
-
+    this.playerState = this.player?.getState();
     postAnalyticEvent(event, this.prepareAnalyticPayload(event, eventData));
   }
 }

package/appUtils/HooksManager/{Hook.ts → Hook.js}

@@ -4,7 +4,6 @@ import { isFunction } from "../../functionUtils";
 import { HOOKS_EVENTS, HOOKS_TRANSITION_TYPE } from "./constants";
 
 import { hooksManagerLogger } from "./logger";
-import type { Hook as HookInterface, HookIniObj } from "./types";
 
 const BASE_HOOK_PROPERTIES = ["screen_id", "identifier", "weight"];
 
@@ -15,9 +14,7 @@ const BASE_HOOK_PROPERTIES = ["screen_id", "identifier", "weight"];
  * @param {string} hookEventName
  * @returns {number} index
  */
-const hookState: (
-  arg0: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS]
-) => number = R.indexOf(R.__, R.values(HOOKS_EVENTS));
+const hookState = R.indexOf(R.__, R.values(HOOKS_EVENTS));
 
 /**
  * assigns property to a given context
@@ -31,20 +28,17 @@ function assignProp(context) {
 }
 
 /**
- * Representation of a hook plugin
+ * Representation of a hook plugin with full data
  */
-export class Hook implements HookInterface {
-  public manager;
-  public lastHook;
-  public state;
-  public screen_id;
-  public identifier;
-  public module;
-  public general;
-  public weight;
-  public configuration;
-
-  constructor({ hook, hooks, manager }: HookIniObj) {
+export class Hook {
+  /**
+   * constructs the hook
+   * @param {object} Options
+   * @param {object} Options.hook hook object
+   * @param {Array<Object>} Options.hooks array of hooks siblings in the current process
+   * @param {object} manager hook manager to process the hooks
+   */
+  constructor({ hook, hooks, manager }) {
     R.forEachObjIndexed(assignProp(this), hook);
     this.manager = manager;
 

package/appUtils/HooksManager/{constants.ts → constants.js}

@@ -12,7 +12,7 @@ export const HOOKS_EVENTS = {
   CANCEL: "cancel",
   SUCCESS: "success",
   COMPLETE: "complete",
-} as const;
+};
 
 export const HOOKS_TRANSITION_TYPE = {
   PUSH: "push",

package/appUtils/HooksManager/{index.ts → index.js}

@@ -10,68 +10,14 @@ import { Hook } from "./Hook";
 import { HOOKS_EVENTS, HOOKS_TYPE } from "./constants";
 
 import { hooksManagerLogger } from "./logger";
-import { HookManager, HookManagerArgs } from "./types";
-
-/**
- * orders the hooks according to their weight
- * @param {Array<object>} hooks to sort out
- * @returns {Array<object>} sorted hooks
- */
-function orderHooksByWeight(hooks) {
-  return R.sortBy(R.compose(Number, R.prop("weight")), hooks);
-}
-
-function executeOnNextHook(hooks, payload, callback) {
-  const [nextHook, ...restOfHooks] = orderHooksByWeight(hooks);
-
-  if (nextHook) {
-    nextHook.execute(payload, callback(nextHook, restOfHooks, payload));
-  }
-}
-
-/**
- * tells wether the current river is related to a player plugin, or the default player
- * @param {Object} river
- * @returns {boolean}
- */
-function riverIsPlayer(river, plugins) {
-  const { screenType, plugin_type } = river;
-
-  if (screenType || plugin_type) {
-    return screenType === "playable" || plugin_type === "player";
-  }
-
-  const { type } = river;
-
-  return R.compose(
-    R.propEq("type", "player"),
-    R.defaultTo({}),
-    R.find(R.propEq("identifier", type))
-  )(plugins);
-}
-
-/**
- * Injects the hooks for the player
- * @param _hookType type of hook
- * @param plugins plugins
- * @returns {Array<Object>}
- */
-function injectPlayerHooks(_hookType: string, plugins): Hook[] {
-  const playerhooks: Hook[] = R.compose(
-    R.sortBy(R.prop("weight")),
-    R.map((plugin) => ({
-      identifier: plugin.identifier,
-      weight: R.path(["module", "weight"], plugin) || 1,
-    })),
-    R.filter(R.pathEq(["module", "hasPlayerHook"], true))
-  )(plugins);
-
-  return playerhooks;
-}
 
 /**
  * creates a hooksManager object to handle the hooks process.
  * it is based on the `subscriber` object
+ * @param {object} options
+ * @param {object} rivers map of rivers in the app
+ * @param {object} targetScreen rivers which we are navigating to
+ * @param {Array<object>} plugins array of plugins in the app
  * @returns {object} hooksManager object - see Navigator for usage
  */
 export function HooksManager({
@@ -79,7 +25,7 @@ export function HooksManager({
   targetScreen,
   plugins,
   startUpHooksData = {},
-}: HookManagerArgs): HookManager {
+}) {
   hooksManagerLogger.addContext({ targetScreen });
 
   function logHookEvent(func, message, data) {
@@ -89,8 +35,7 @@ export function HooksManager({
     });
   }
 
-  const hooksManager: Partial<HookManager> = {};
-  hooksManager.subscriber = subscriber();
+  const hooksManager = subscriber();
 
   /**
    * attaches the screen data to the hook object if the hook
@@ -155,6 +100,15 @@ export function HooksManager({
     };
   }
 
+  /**
+   * orders the hooks according to their weight
+   * @param {Array<object>} hooks to sort out
+   * @returns {Array<object>} sorted hooks
+   */
+  function orderHooksByWeight(hooks) {
+    return R.sortBy(R.compose(Number, R.prop("weight")), hooks);
+  }
+
   /**
    * extracts the hooks form the target river. returns null if there are none
    * if there are hooks, gathers all required data and constructs a Hook object
@@ -163,10 +117,10 @@ export function HooksManager({
    * @returns {Array<Hooks>} list of hooks to go through
    */
   function getHooks(hookType, river) {
-    const playerhooks: Hook[] = [];
+    const playerhooks = [];
 
-    if (riverIsPlayer(river, plugins)) {
-      playerhooks.push(...injectPlayerHooks(hookType, plugins));
+    if (riverIsPlayer(river)) {
+      playerhooks.push(...injectPlayerHooks(hookType));
     }
 
     let hooks = R.concat(playerhooks, R.pathOr([], ["hooks", hookType], river));
@@ -176,10 +130,8 @@ export function HooksManager({
     const { startUpHooks, setStartUpHooks } = startUpHooksData;
 
     if (startUpHooks && startUpHooks !== "in_process") {
-      if (Array.isArray(startUpHooks)) {
-        hooks.unshift(...startUpHooks);
-        setStartUpHooks("in_process");
-      }
+      hooks.unshift(...startUpHooks);
+      setStartUpHooks("in_process");
     }
 
     if (!R.length(hooks)) {
@@ -206,6 +158,45 @@ export function HooksManager({
     )(hooks);
   }
 
+  /**
+   * tells wether the current river is related to a player plugin, or the default player
+   * @param {Object} river
+   * @returns {boolean}
+   */
+  function riverIsPlayer(river) {
+    const { screenType, plugin_type } = river;
+
+    if (screenType || plugin_type) {
+      return screenType === "playable" || plugin_type === "player";
+    }
+
+    const { type } = river;
+
+    return R.compose(
+      R.propEq("type", "player"),
+      R.defaultTo({}),
+      R.find(R.propEq("identifier", type))
+    )(plugins);
+  }
+
+  /**
+   * Injects the hooks for the player
+   * @param {String} hookType type of hook
+   * @returns {Array<Object>}
+   */
+  function injectPlayerHooks(_hookType) {
+    const playerhooks = R.compose(
+      R.sortBy(R.prop("weight")),
+      R.map((plugin) => ({
+        identifier: plugin.identifier,
+        weight: R.path(["module", "weight"], plugin) || 1,
+      })),
+      R.filter(R.pathEq(["module", "hasPlayerHook"], true))
+    )(plugins);
+
+    return playerhooks;
+  }
+
   /**
    * tells wether the given hook is the last one or not
    * @param {Hook} hookPlugin
@@ -218,32 +209,6 @@ export function HooksManager({
     return hookPlugin.lastHook;
   }
 
-  /**
-   * flags a hook as succeeded, and pass hook data along
-   * @param {Hook} hookPlugin
-   * @param {object} payload returned by the hook plugin
-   */
-  function completeHook(hookPlugin, payload, callback) {
-    logHookEvent(
-      hooksManagerLogger.info,
-      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
-      {
-        payload,
-        hook: hookPlugin,
-      }
-    );
-
-    // eslint-disable-next-line
-    // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
-    delete payload.getLoginProtocol;
-
-    hookPlugin.setStateAndNotify(HOOKS_EVENTS.COMPLETE, {
-      hookPlugin,
-      payload,
-      callback,
-    });
-  }
-
   /**
    * creates the callback to invoke in order to proceed to the next hook
    * covers the scenarios of failure & flow blocking
@@ -344,11 +309,37 @@ export function HooksManager({
 
         isLastHook(hookPlugin, restOfHooks)
           ? completeHook(hookPlugin, payload, callback)
-          : executeOnNextHook(restOfHooks, payload, callback);
+          : handleNextHook(restOfHooks, payload);
       }
     };
   }
 
+  /**
+   * flags a hook as succeeded, and pass hook data along
+   * @param {Hook} hookPlugin
+   * @param {object} payload returned by the hook plugin
+   */
+  function completeHook(hookPlugin, payload, callback) {
+    logHookEvent(
+      hooksManagerLogger.info,
+      `completeHook: hook sequence completed successfully: ${hookPlugin["identifier"]}`,
+      {
+        payload,
+        hook: hookPlugin,
+      }
+    );
+
+    // eslint-disable-next-line
+    // TODO: Temporary hack to pass getLoginProtocol to other plugins to refresh in case token expired, need be deleted later
+    delete payload.getLoginProtocol;
+
+    hookPlugin.setStateAndNotify(HOOKS_EVENTS.COMPLETE, {
+      hookPlugin,
+      payload,
+      callback,
+    });
+  }
+
   /**
    * presents a screen hook by triggering an event invoking the handler with
    * the appropriate route & payload
@@ -385,6 +376,9 @@ export function HooksManager({
 
   /**
    * executes a headless hook
+   * @param {Hook} hookPlugin to present
+   * @param {object} payload to pass to the hook module
+   * @param {function} callback to invoke when the hook is successful
    */
   hooksManager.executeHook = function (hookPlugin, payload, callback) {
     logHookEvent(
@@ -450,6 +444,23 @@ export function HooksManager({
     }
   };
 
+  /**
+   * handles the next hook in the list of provided hooks, passing the payload along
+   * @param {Array<Hook>} hooks to process
+   * @param {object} payload to pass to the hook
+   */
+  function handleNextHook(hooks, payload) {
+    const [hookPlugin, ...restOfHooks] = orderHooksByWeight(hooks);
+
+    /**
+     * Commenting out part of the code which is trying to run the next hook
+     * in parallel - it's not in use, and it's creating unexpected side
+     * effects
+     * */
+
+    hookPlugin.execute(payload, hookCallback(hookPlugin, restOfHooks, payload));
+  }
+
   /**
    * function exposes on the hooks manager to trigger the handling of the hooks for
    * the given targetScreen
@@ -471,9 +482,9 @@ export function HooksManager({
         }
       );
 
-      executeOnNextHook(preloadHooks, payload, hookCallback);
+      handleNextHook(preloadHooks, payload);
     } else {
-      hooksManager.subscriber.invokeHandler(HOOKS_EVENTS.COMPLETE, {
+      hooksManager.invokeHandler(HOOKS_EVENTS.COMPLETE, {
         hookPlugin: { lastHook: true },
         payload,
       });
@@ -482,5 +493,5 @@ export function HooksManager({
     return hooksManager;
   };
 
-  return hooksManager as HookManager;
+  return hooksManager;
 }