@applicaster/zapp-react-native-utils 12.0.0-rc.76 → 12.0.0-rc.78

package/appUtils/platform/const.ts

@@ -16,3 +16,10 @@ export const PLATFORMS = {
   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

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

package/appUtils/platform/platformUtils.ts

@@ -1 +1,223 @@
-export {};
+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/index.ts

@@ -366,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) {
@@ -376,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) {
@@ -441,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() {

package/appUtils/playerManager/player.ts

@@ -684,9 +684,6 @@ export class Player {
   play = () => {};
   pause = () => {};
   disableBufferAnimation = (): boolean => true;
-  setLanguage = (
-    _selected?: QuickBrickPlayer.TextTrack | QuickBrickPlayer.AudioTrack
-  ) => {};
 
   setPlaybackRate = (_rate) => {};
   startSleepTimer = (_timestamp) => {};

package/appUtils/playerManager/playerNative.ts

@@ -188,10 +188,10 @@ export class PlayerNative extends Player {
 
   disableBufferAnimation = (): boolean => false;
 
-  setLanguage = (
+  selectTrack = (
     selected: QuickBrickPlayer.TextTrack | QuickBrickPlayer.AudioTrack
   ) => {
-    this.currentPlayerComponent()?.["setLanguage"]?.(selected);
+    this.currentPlayerComponent()?.["selectTrack"]?.(selected);
   };
 
   setPlaybackRate = (rate: number) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "12.0.0-rc.76",
+  "version": "12.0.0-rc.78",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "12.0.0-rc.76",
+    "@applicaster/applicaster-types": "12.0.0-rc.78",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

package/reactUtils/index.ts

@@ -186,6 +186,10 @@ export const isSamsungPlatform = () => {
 export const isVizioPlatform = () => {
   const userAgent = getUserAgent();
 
+  if (!userAgent) {
+    return false;
+  }
+
   const isVizioAgent =
     userAgent.includes(PLATFORMS.vizio) ||
     userAgent.includes(PLATFORMS.smartcast) ||

package/appUtils/platform/platformUtils.web.ts

@@ -1,49 +0,0 @@
-import { PLATFORMS } from "./const";
-
-declare global {
-  interface Window {
-    applicaster: {
-      vizioLibraryDidLoad: boolean;
-      useOnScreenKeyboard: boolean;
-    };
-    VIZIO?: {
-      exitApplication: () => void;
-      setClosedCaptionHandler: (
-        callback: (isCCEnabled: boolean) => void
-      ) => void;
-    };
-  }
-}
-
-export const getUserAgent = () =>
-  window?.navigator?.userAgent || global?.navigator?.userAgent;
-
-/**
- * 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;
-};