@applicaster/zapp-react-native-utils 12.0.0-alpha.5000126055 → 12.0.0-alpha.5001350756

package/appUtils/focusManagerAux/index.ts

@@ -0,0 +1,76 @@
+import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
+import { find, path } from "ramda";
+
+import {
+  waitForActiveScreen,
+  waitForContent,
+  getContentNode,
+  getNavbarNode,
+} from "./utils";
+
+import { coreLogger } from "../../logger";
+
+const logger = coreLogger.addSubsystem("focusManagerAux");
+
+export async function setFocusOnMenu(currentRoute: string) {
+  const { setFocus, focusableTree } = focusManager;
+
+  try {
+    await waitForActiveScreen(currentRoute, focusableTree);
+
+    const navbar = getNavbarNode(focusableTree);
+
+    const selectedMenuItemId = find(
+      (child) => child.component.props.selected,
+      navbar.children
+    )?.id;
+
+    if (selectedMenuItemId) {
+      // set focus on selected menu item
+      setFocus(selectedMenuItemId);
+
+      return;
+    }
+
+    const firstMenuItemId = path(["children", 0, "id"], navbar);
+
+    if (firstMenuItemId) {
+      // set focus on first menu item
+      setFocus(firstMenuItemId);
+    }
+  } catch (error) {
+    logger.log({
+      message: "setFocusOnMenu – failed to put focus on top-menu",
+      data: {
+        currentRoute,
+        error,
+      },
+    });
+  }
+}
+
+export async function setFocusOnContent(currentRoute: string) {
+  // we need to put focus on content here
+  // For doing it we have to wait registration of first focusable node into focusableTree
+  // we wait until content node starts having children
+
+  const { setInitialFocus, focusableTree } = focusManager;
+
+  try {
+    await waitForActiveScreen(currentRoute, focusableTree);
+    await waitForContent(focusableTree);
+
+    const content = getContentNode(focusableTree);
+
+    const { success } = setInitialFocus(content);
+
+    if (!success) {
+      // we've failed to put initial focus on content, re-run "setFocusOnContent" again as a fallback
+      throw Error(
+        "we've failed to put initial focus on content, re-run 'setFocusOnContent' again as a fallback"
+      );
+    }
+  } catch (error) {
+    setFocusOnContent(currentRoute);
+  }
+}

package/appUtils/focusManagerAux/utils/index.ts

@@ -0,0 +1,100 @@
+import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { find, last, startsWith, pathOr } from "ramda";
+import {
+  QUICK_BRICK_NAVBAR,
+  QUICK_BRICK_CONTENT,
+} from "@applicaster/quick-brick-core/const";
+
+// run check each 300 ms
+// run this check too often could lead to performance penalty on low-end devices
+const HOW_OFTEN_TO_CHECK_CONDITION = 300; // ms
+
+type Props = {
+  maxTimeout: number;
+  conditionFn: () => boolean;
+};
+
+export const waitUntil = ({ maxTimeout, conditionFn }: Props) => {
+  let interval;
+  let timeout;
+
+  return new Promise((resolve, reject) => {
+    // run interval check
+    interval = setInterval(() => {
+      if (conditionFn()) {
+        clearInterval(interval);
+        clearTimeout(timeout);
+
+        resolve(undefined);
+      }
+    }, HOW_OFTEN_TO_CHECK_CONDITION);
+
+    // max timeout when we need to stop interval check
+    timeout = setTimeout(() => {
+      clearInterval(interval);
+      clearTimeout(timeout);
+
+      const error = Error(
+        "Failed to wait satisfy condition. Max timeout is reached."
+      );
+
+      reject(error);
+    }, maxTimeout);
+  });
+};
+
+export const waitForActiveScreen = (currentRoute: string, focusableTree) => {
+  const isActiveScreenAvailableToFocus = (): boolean => {
+    const routes = focusableTree.root.children;
+
+    const route = find((route) => route.id === currentRoute, routes);
+
+    return isNotNil(route);
+  };
+
+  return waitUntil({
+    maxTimeout: HOW_OFTEN_TO_CHECK_CONDITION * 10, // ms
+    conditionFn: isActiveScreenAvailableToFocus,
+  });
+};
+
+const getActiveScreenChildren = (focusableTree) => {
+  return pathOr([], ["children"], last(focusableTree.root.children));
+};
+
+export const getContentNode = (focusableTree) => {
+  const content = find(
+    (child) =>
+      startsWith(QUICK_BRICK_CONTENT, child.id) ||
+      startsWith("player", child.id),
+    getActiveScreenChildren(focusableTree)
+  );
+
+  return content;
+};
+
+export const getNavbarNode = (focusableTree) => {
+  const navbar = find(
+    (child) => startsWith(QUICK_BRICK_NAVBAR, child.id),
+    getActiveScreenChildren(focusableTree)
+  );
+
+  return navbar;
+};
+
+export const waitForContent = (focusableTree) => {
+  const contentHasAnyChildren = (): boolean => {
+    const countOfChildren = pathOr(
+      0,
+      ["children", "length"],
+      getContentNode(focusableTree)
+    );
+
+    return countOfChildren > 0;
+  };
+
+  return waitUntil({
+    maxTimeout: HOW_OFTEN_TO_CHECK_CONDITION * 10, // ms
+    conditionFn: contentHasAnyChildren,
+  });
+};

package/appUtils/keyCodes/keys.web.js

@@ -1,6 +1,7 @@
 /* global tizen */
 const isTizen = typeof tizen !== "undefined";
 
+import { isVizioPlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
 import * as platformKeys from "./keysByPlatform";
 import { Platform } from "react-native";
 
@@ -21,6 +22,13 @@ export const ARROW_KEYS = [
   KEYS.ArrowRight,
 ];
 
+/**
+ * Platform.OS currently identifies Vizio as LG_TV, therefore we are using isVizioPlatform to identify platform and add keys.
+ */
+if (isVizioPlatform()) {
+  Object.assign(KEYS, platformKeys.vizio);
+}
+
 /**
  * In TizenOS we need to register all of the keys that we are going to use.
  * You need to register using the name Tizen has for the key.

package/appUtils/keyCodes/keysByPlatform.js

@@ -102,4 +102,14 @@ const tvos = {
   Menu: { code: "Menu", eventType: "menu" },
 };
 
-export { lg_tv, samsung_tv, web, tvos, android_tv };
+const vizio = {
+  ...samsung_tv,
+  Exit: { code: "Exit", keyCode: 27 },
+  PageUp: { code: "PageUp", keyCode: 33 },
+  PageDown: { code: "PageDown", keyCode: 34 },
+  MediaTrackNext: { code: "MediaTrackNext", keyCode: 418 },
+  MediaTrackPrevious: { code: "MediaTrackPrevious", keyCode: 419 },
+  PrevCh: { code: "PrevCh", keyCode: 500 },
+};
+
+export { lg_tv, samsung_tv, web, tvos, android_tv, vizio };

package/appUtils/platform/const.ts

@@ -0,0 +1,25 @@
+/**
+ * Platforms found in userAgent string, please note that simulators
+ * might not have the same agents that the devices have
+ */
+export const PLATFORMS = {
+  webos: "Web0S",
+  tizen: "Tizen",
+  samsung: "SMART-TV",
+  mac: "Mac",
+  win: "Win",
+  linux: "Linux",
+  iphone: "iPhone",
+  android: "Android",
+  mobile: "Mobile",
+  vizio: "VIZIO",
+  smartcast: "SmartCast",
+  conjure: "Conjure",
+};
+
+/**
+ * Keys used to store the platform / device state in the session storage
+ */
+export const PLATFORM_KEYS = {
+  deviceClosedCaptioningEnabled: "device_closed_captioning_enabled",
+};

package/appUtils/platform/index.ts

@@ -0,0 +1,3 @@
+export * from "./platformUtils";
+
+export * from "./const";

package/appUtils/platform/platformUtils.ts

@@ -0,0 +1,223 @@
+import { BehaviorSubject } from "rxjs";
+
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { PlayerWebController } from "@applicaster/zapp-react-native-default-player/src/playerFactory/players/playerWebController";
+
+import { PLATFORM_KEYS, PLATFORMS } from "./const";
+import { createLogger, utilsLogger } from "../../logger";
+
+declare global {
+  interface Window {
+    VIZIO?: {
+      exitApplication: () => void;
+      setClosedCaptionHandler: (
+        callback: (isCCEnabled: boolean) => void
+      ) => void;
+    };
+  }
+}
+
+const { log_debug, log_error } = createLogger({
+  category: "General",
+  subsystem: "PlatformUtils",
+  parent: utilsLogger,
+});
+
+export const getUserAgent = () =>
+  window?.navigator?.userAgent || global?.navigator?.userAgent;
+
+/** VIZIO UTILS */
+
+/**
+ * Checks if we are on the Vizio platform by using the userAgent string
+ *
+ * Use this method when you need to identify the platform on runtime
+ * before the VIZIO Companion Library has loaded
+ */
+export const isVizioPlatform = () => {
+  const userAgent = getUserAgent();
+
+  const isVizioAgent =
+    userAgent.includes(PLATFORMS.vizio) ||
+    userAgent.includes(PLATFORMS.smartcast) ||
+    userAgent.includes(PLATFORMS.conjure);
+
+  return isVizioAgent;
+};
+
+/**
+ * Checks if we are on the Vizio platform by checking for the global VIZIO object
+ * and the VIZIO Companion Library. This method does not use the userAgent string,
+ * because it mainly checks whether we have access to apis, which may not be available yet
+ */
+export const hasVizioAPIs = () => {
+  const hasAPIs =
+    typeof window.VIZIO !== "undefined" &&
+    window?.applicaster?.vizioLibraryDidLoad;
+
+  return hasAPIs;
+};
+
+/**
+ * Manages device based closed captioning state
+ * Returns an observable that emits the current state and updates whenever it changes
+ */
+class ClosedCaptioningManager {
+  private ccState$ = new BehaviorSubject<boolean>(false);
+  private static ccManagerInstance: ClosedCaptioningManager;
+
+  private constructor() {
+    this.initialize();
+  }
+
+  static getInstance(): ClosedCaptioningManager {
+    if (!ClosedCaptioningManager.ccManagerInstance) {
+      ClosedCaptioningManager.ccManagerInstance = new ClosedCaptioningManager();
+    }
+
+    return ClosedCaptioningManager.ccManagerInstance;
+  }
+
+  async initialize() {
+    const existingState = await sessionStorage.getItem(
+      PLATFORM_KEYS.deviceClosedCaptioningEnabled
+    );
+
+    log_debug("Initializing closed captioning manager", { existingState });
+
+    if (existingState !== null) {
+      this.ccState$.next(existingState === "true" || existingState === true);
+    }
+
+    if (hasVizioAPIs()) {
+      window.VIZIO!.setClosedCaptionHandler((isCCEnabled) => {
+        log_debug("CC state changed", { isCCEnabled });
+
+        sessionStorage.setItem(
+          PLATFORM_KEYS.deviceClosedCaptioningEnabled,
+          isCCEnabled
+        );
+
+        this.ccState$.next(isCCEnabled);
+      });
+    }
+  }
+
+  getCurrentState(): boolean {
+    return this.ccState$.getValue();
+  }
+
+  getStateAsObservable() {
+    return this.ccState$.asObservable();
+  }
+}
+
+/**
+ * Subscribe to closed captioning state changes
+ * @returns Observable<boolean>
+ * @example
+ * const subscription = getClosedCaptionState().subscribe(
+ *   isEnabled => setClosedCaptionState(isEnabled)
+ * );
+ * subscription.unsubscribe(), []);
+ */
+export const getClosedCaptionState = () => {
+  const ccManager = ClosedCaptioningManager.getInstance();
+
+  return ccManager.getStateAsObservable();
+};
+
+export class TextTrackManager {
+  private controller?: PlayerWebController;
+  private static instance: TextTrackManager;
+
+  private constructor() {}
+
+  static getInstance(): TextTrackManager {
+    if (!TextTrackManager.instance) {
+      TextTrackManager.instance = new TextTrackManager();
+    }
+
+    return TextTrackManager.instance;
+  }
+
+  initialize(controller: PlayerWebController) {
+    if (!controller) {
+      throw new Error(
+        "Controller is required for TextTrackManager initialization"
+      );
+    }
+
+    this.controller = controller;
+  }
+
+  async setTextTrackBasedOnCaptions(closedCaptionsState: boolean) {
+    if (!this.controller) {
+      log_error("Controller is not initialized");
+
+      return;
+    }
+
+    if (closedCaptionsState) {
+      const textTracks = this.controller.getTracksState().textTracks;
+      const preferredTextTrack = await this.getPreferredTextTrack(textTracks);
+
+      if (preferredTextTrack) {
+        this.controller.selectTrack(preferredTextTrack);
+      }
+    } else {
+      this.controller.selectTrack(null);
+    }
+  }
+
+  async getPreferredTextTrack(
+    textTracks: QuickBrickPlayer.TextTrack[]
+  ): Promise<QuickBrickPlayer.TextTrack | undefined> {
+    if (!this.controller) return;
+
+    const userPreferredTextLanguageLocalStorage = await localStorage.getItem(
+      "preferred_text_language",
+      "user_preferences"
+    );
+
+    let userPreferredTextLanguage;
+
+    if (userPreferredTextLanguageLocalStorage) {
+      userPreferredTextLanguage = textTracks.find(
+        (track) => track.language === userPreferredTextLanguageLocalStorage
+      );
+    }
+
+    if (userPreferredTextLanguage?.id) {
+      return userPreferredTextLanguage;
+    }
+
+    const enableAutoTextTrackSelection =
+      this.controller.getPluginConfiguration()
+        ?.enable_auto_text_track_selection ||
+      this.controller.getTracksState().textTracks.length > 0;
+
+    if (enableAutoTextTrackSelection) {
+      const languageCode = await sessionStorage.getItem("languageCode");
+
+      if (languageCode) {
+        const chosenTextTrackBySystemLanguage = textTracks.find(
+          (track) => track.language === languageCode
+        );
+
+        if (chosenTextTrackBySystemLanguage?.id) {
+          return chosenTextTrackBySystemLanguage;
+        }
+      }
+    }
+
+    return textTracks?.[0];
+  }
+
+  isTextTrackEnabled(): boolean {
+    if (!this.controller) return false;
+
+    return this.controller.getTracksState().textTrackId !== null;
+  }
+}

package/appUtils/playerManager/conts.ts

@@ -7,6 +7,7 @@ export enum SharedPlayerCallBacksKeys {
   OnPlayerPause = "onPlayerPause",
   OnLoad = "onLoad",
   OnError = "onError",
+  OnVideoError = "onVideoError",
   OnVideoEnd = "onVideoEnd",
   OnPlaybackRateChange = "onPlaybackRateChange",
   OnVideoLoad = "onVideoLoad",

package/appUtils/playerManager/index.ts

@@ -3,6 +3,7 @@ import * as R from "ramda";
 import { subscriber } from "../../functionUtils";
 import { utilsLogger, createLogger } from "../../logger";
 import { Player } from "./player";
+import { AnalyticsTracker } from "../../analyticsUtils/analyticsTracker";
 import {
   hasTizenAPIs,
   subscribeToDeviceNetworkChanges,
@@ -10,6 +11,7 @@ import {
 } from "@applicaster/quick-brick-core/App/NetworkStatusProvider/utils";
 import { setUserLanguagePreference } from "./userLanguagePreference";
 import { PlayerRole } from "./conts";
+import { RNPlayerManager } from "./nativePlayerManager";
 
 const { log_error, log_debug, log_warning } = createLogger({
   category: "General",
@@ -35,10 +37,7 @@ export interface PlayerLifecycleListener {
 }
 
 type PlayersMap = {
-  [id: string]: {
-    player: Player;
-    isInViewport: boolean;
-  };
+  [id: string]: { player: Player; isInViewport: boolean };
 };
 
 export class PlayerManager {
@@ -47,6 +46,7 @@ export class PlayerManager {
   private playersMap: PlayersMap = {};
   private manager = subscriber();
   private castingReceiver: Player;
+  private analyticsTracker: AnalyticsTracker;
   private lifecycleListeners: PlayerLifecycleListener[] = [];
 
   public static getInstance() {
@@ -57,7 +57,7 @@ export class PlayerManager {
     return PlayerManager.instance;
   }
 
-  public getActivePlayerId = (): string | null => {
+  public getActivePlayerId = (): String | null => {
     return this.activePlayerId;
   };
 
@@ -102,10 +102,7 @@ export class PlayerManager {
   }
 
   private addPlayer = (id: string, player: Player) => {
-    this.playersMap[id] = {
-      player: player,
-      isInViewport: false,
-    };
+    this.playersMap[id] = { player: player, isInViewport: false };
   };
 
   public isPlayerRegistered = (id: string) => !!this.playersMap[id];
@@ -168,6 +165,10 @@ export class PlayerManager {
     this.addPlayer(id, playerController);
 
     if (playerController.playerRole === PlayerRole.Primary) {
+      if (playerController.playerPluginId !== "QuickBrickPlayerPlugin") {
+        RNPlayerManager?.["QuickBrickPlayerPlugin"]?.stopBackgroundPlayback?.();
+      }
+
       playerController.addListener({
         id: this.getPlayerListenerId(id),
         listener: {
@@ -250,6 +251,28 @@ export class PlayerManager {
     this.castingReceiver = null;
   }
 
+  /**
+   * Handles analytic events, generates a new analytics tracker and transmits events
+   * Passes entry data, and playerState to the tracker for additional context
+   * The end result is an event formatted and passed to AnalyticsBridge.postEvent
+   * When we get the synthetic event we need to pull the data in the e object
+   * e contains the return value from native
+   */
+  public handleAnalyticEvent(event, data = {}, entry: ZappEntry) {
+    const playerState = this.getActivePlayer()?.getState();
+
+    if (!this.analyticsTracker?.handleAnalyticEvent) {
+      this.analyticsTracker = new AnalyticsTracker(entry);
+    }
+
+    this.analyticsTracker?.handleAnalyticEvent?.(
+      event,
+      data,
+      entry,
+      playerState
+    );
+  }
+
   /**
    * Method retrieves the instantiated player instance controller
    * Instance controller exposes methods like getContentDuration, getContentPosision
@@ -343,9 +366,9 @@ export class PlayerManager {
     // TODO: Remove
     if (this.castingReceiver) {
       this.castingReceiver.rewind(deltaTime);
+    } else {
+      this.getActivePlayer()?.rewind(deltaTime);
     }
-
-    this.getActivePlayer()?.rewind(deltaTime);
   }
 
   public forward(deltaTime = null) {
@@ -353,9 +376,9 @@ export class PlayerManager {
 
     if (this.castingReceiver) {
       this.castingReceiver.forward(deltaTime);
+    } else {
+      this.getActivePlayer()?.forward(deltaTime);
     }
-
-    this.getActivePlayer()?.forward(deltaTime);
   }
 
   public seeking(time) {
@@ -418,7 +441,7 @@ export class PlayerManager {
     }
 
     // Call method on player just in case
-    return this.getActivePlayer()?.setLanguage(track);
+    return this.getActivePlayer()?.selectTrack(track);
   }
 
   public isRegistered() {
@@ -443,6 +466,7 @@ export class PlayerManager {
     if (this.castingReceiver) {
       this.castingReceiver.closeNativePlayer();
     } else {
+      this.getActivePlayer().closeNativePlayer();
       this.invokeHandler("close");
     }
   }

package/appUtils/playerManager/nativePlayerManager.ts

@@ -0,0 +1,12 @@
+import { NativeModules } from "react-native";
+import { isApplePlatform } from "../../reactUtils";
+
+export const RNPlayerManager = {
+  QuickBrickPlayerPlugin: isApplePlatform()
+    ? NativeModules.PlayerModule
+    : NativeModules.QuickBrickDefaultPlayerModule,
+  KalturaPlayerPlugin: isApplePlatform()
+    ? NativeModules.KalturaPlayerModule
+    : NativeModules.QBKalturaPlayerModule,
+  "quick-brick-player-brightcove": NativeModules.BrightcovePlayerModule,
+};