@applicaster/zapp-react-native-utils 16.0.0-alpha.1701179921 → 16.0.0-alpha.1733304298

package/appUtils/contextKeysManager/index.ts

@@ -1,6 +1,6 @@
 import { isNil } from "@applicaster/zapp-react-native-utils/utils";
 
-import { StorageLevel, StorageType } from "./consts";
+import { StorageLevel } from "./consts";
 import {
   getNamespaceAndKey,
   keyIsValid,
@@ -59,18 +59,14 @@ type Setup = {
   sessionStorage?: Storage;
   localStorage?: Storage;
   secureStorage?: Storage;
-  referenceStorage?: Storage;
 };
 
-export const REFERENCE_NAMESPACE = "applicaster.v2.references";
-
 export class ContextKeysManager {
   private static _instance: ContextKeysManager;
   private _logger: Logger;
   private _sessionStorage: Storage;
   private _localStorage: Storage;
   private _secureStorage: Storage;
-  private _referenceStorage: Storage;
 
   public static get instance() {
     if (!this._instance) {
@@ -79,7 +75,6 @@ export class ContextKeysManager {
         sessionStorage: SessionStorage,
         localStorage: LocalStorage,
         secureStorage: SecureStorage,
-        referenceStorage: SessionStorage,
       });
 
       this._instance = instance;
@@ -94,13 +89,11 @@ export class ContextKeysManager {
     sessionStorage = SessionStorage,
     localStorage = LocalStorage,
     secureStorage = SecureStorage,
-    referenceStorage = SessionStorage,
-  }: Setup) {
+  }: Setup = {}) {
     this._logger = logger;
     this._sessionStorage = sessionStorage;
     this._localStorage = localStorage;
     this._secureStorage = secureStorage;
-    this._referenceStorage = referenceStorage;
   }
 
   private parseKey(key: KeyName): ParsedKeyAndNamespace {
@@ -119,41 +112,6 @@ export class ContextKeysManager {
     return { isValid: true, ...parsedKey };
   }
 
-  // GET
-  public async getKeyByReference(
-    key: string,
-    namespace: string
-  ): Promise<ValueOrNothing> {
-    // 1) look for storage
-    // 2) if storage found - look value in it
-    // 3) if storage not found return NOTHING
-
-    return this._referenceStorage
-      .getItem(buildNamespaceKey(key, namespace), REFERENCE_NAMESPACE)
-      .then((storage: StorageType | unknown) => {
-        switch (storage) {
-          case StorageType.session:
-            return this._sessionStorage.getItem(key, namespace);
-          case StorageType.local:
-            return this._localStorage.getItem(key, namespace);
-          case StorageType.secure:
-            return this._secureStorage.getItem(key, namespace);
-          default:
-            // unknown storage
-            return NOTHING;
-        }
-      })
-      .catch((error) => {
-        // something went wrong
-        this._logger.warn({
-          message: error.message,
-          data: { key, namespace },
-        });
-
-        return NOTHING;
-      });
-  }
-
   public async getKeys(
     keys: Array<KeyName>,
     contextObj?: { key: string; required?: boolean }[]
@@ -228,19 +186,7 @@ export class ContextKeysManager {
       return NOTHING;
     }
 
-    // at first - try to find by reference
-    // if not found, look in session > local > secure
-
-    const resultByReference = await this.getKeyByReference(
-      parsedKey,
-      parsedNamespace
-    );
-
-    if (!isNil(resultByReference)) {
-      return resultByReference;
-    }
-
-    // try to full-search
+    // look in session > local > secure
     try {
       const resultFromSessionStorage = await this._sessionStorage.getItem(
         parsedKey,
@@ -284,41 +230,6 @@ export class ContextKeysManager {
   // GET
 
   // SET
-  public async setReferenceForKey(
-    key: string,
-    namespace: string,
-    storageLevel: StorageLevel
-  ): Promise<boolean> {
-    return this._referenceStorage
-      .setItem(
-        buildNamespaceKey(key, namespace),
-        storageLevel,
-        REFERENCE_NAMESPACE
-      )
-      .then((result) => {
-        if (savingResultIsSuccess(result)) {
-          return true;
-        }
-
-        this._logger.warn({
-          message:
-            "While saving reference - reference storage return non expected value: true",
-          data: { key, namespace, storageLevel },
-        });
-
-        return false;
-      })
-      .catch((error) => {
-        // something went wrong
-        this._logger.warn({
-          message: error.message,
-          data: { key, namespace, storageLevel },
-        });
-
-        return false;
-      });
-  }
-
   // for all keys where saving were succeed return true
   // for others return false
   public async setKeys(
@@ -352,29 +263,36 @@ export class ContextKeysManager {
     }
 
     try {
+      let setItemResult: boolean;
+
       switch (storageLevel) {
         case StorageLevel.persisted:
-          return await Promise.all([
-            this._localStorage.setItem(parsedKey, value, parsedNamespace),
-            this.setReferenceForKey(parsedKey, parsedNamespace, storageLevel),
-          ]).then(([setItemResult]) => {
-            return savingResultIsSuccess(setItemResult);
-          });
+          setItemResult = await this._localStorage.setItem(
+            parsedKey,
+            value,
+            parsedNamespace
+          );
+
+          break;
         case StorageLevel.secure:
-          return await Promise.all([
-            this._secureStorage.setItem(parsedKey, value, parsedNamespace),
-            this.setReferenceForKey(parsedKey, parsedNamespace, storageLevel),
-          ]).then(([setItemResult]) => {
-            return savingResultIsSuccess(setItemResult);
-          });
+          setItemResult = await this._secureStorage.setItem(
+            parsedKey,
+            value,
+            parsedNamespace
+          );
+
+          break;
         default:
-          return await Promise.all([
-            this._sessionStorage.setItem(parsedKey, value, parsedNamespace),
-            this.setReferenceForKey(parsedKey, parsedNamespace, storageLevel),
-          ]).then(([setItemResult]) => {
-            return savingResultIsSuccess(setItemResult);
-          });
+          setItemResult = await this._sessionStorage.setItem(
+            parsedKey,
+            value,
+            parsedNamespace
+          );
+
+          break;
       }
+
+      return savingResultIsSuccess(setItemResult);
     } catch (error) {
       // something went wrong
       this._logger.warn({
@@ -388,24 +306,6 @@ export class ContextKeysManager {
   // SET
 
   // REMOVE
-  public async removeReferenceForKey(
-    key: string,
-    namespace: string
-  ): Promise<boolean> {
-    return this._referenceStorage
-      .removeItem(buildNamespaceKey(key, namespace), REFERENCE_NAMESPACE)
-      .then(() => true)
-      .catch((error) => {
-        // something went wrong
-        this._logger.warn({
-          message: error.message,
-          data: { key, namespace },
-        });
-
-        return false;
-      });
-  }
-
   public async removeKey(key: KeyName): Promise<boolean> {
     const {
       isValid: isValidKey,
@@ -422,7 +322,6 @@ export class ContextKeysManager {
       this._sessionStorage.removeItem(parsedKey, parsedNamespace),
       this._localStorage.removeItem(parsedKey, parsedNamespace),
       this._secureStorage.removeItem(parsedKey, parsedNamespace),
-      this.removeReferenceForKey(parsedKey, parsedNamespace),
     ])
       .then(() => true)
       .catch((error) => {

package/appUtils/playerManager/__tests__/playerDiagnostics.test.ts

@@ -0,0 +1,62 @@
+import { Player } from "../player";
+
+const entry = (id: string) => ({ id, title: id }) as unknown as ZappEntry;
+
+const makePlayer = () => {
+  const player = new Player({ playerId: "test-player" });
+  player.entry = entry("first");
+
+  return player;
+};
+
+describe("Player per-entry diagnostics", () => {
+  it("keeps the latest of onError and onVideoError, and clears it when a new entry loads", () => {
+    const player = makePlayer();
+    const second = { message: "second" };
+
+    player.onError({ message: "first" } as any);
+    player.onVideoError(second as any);
+
+    expect(player.lastError).toBe(second);
+
+    player.entry = entry("second");
+
+    expect(player.lastError).toBeNull();
+  });
+
+  it("reads the next entry without creating the overlay observer", () => {
+    const player = makePlayer();
+
+    expect(player.getPlayNextEntry()).toBeNull();
+
+    jest
+      .spyOn(player.getOverlayObservable(), "getPlayNextEntry")
+      .mockReturnValue(entry("next"));
+
+    expect(player.getPlayNextEntry()).toEqual(entry("next"));
+  });
+
+  it("keeps the content clock while a client-side ad plays", () => {
+    const player = makePlayer();
+
+    player.onVideoProgress({
+      currentTime: 300,
+      duration: 1800,
+      seekableDuration: 1800,
+    });
+
+    player.onAdBegin({});
+
+    player.onVideoProgress({
+      currentTime: 5,
+      duration: 15,
+      seekableDuration: 15,
+    });
+
+    expect(player.getPosition()).toBe(5);
+    expect(player.getDuration()).toBe(15);
+    expect(player.getContentPosition()).toBe(300);
+    expect(player.getContentDuration()).toBe(1800);
+    expect(player.getSeekableDuration()).toBe(1800);
+  });
+});

package/appUtils/playerManager/__tests__/playerToolbox.test.ts

@@ -0,0 +1,281 @@
+const mockRegister = jest.fn();
+let mockXray: Record<string, unknown> | null = {};
+
+jest.mock("../../../logger", () => ({
+  getXray: () => mockXray,
+}));
+
+const loadToolbox = () => {
+  let module;
+
+  jest.isolateModules(() => {
+    module = require("../playerToolbox");
+  });
+
+  return module as typeof import("../playerToolbox");
+};
+
+const player = (overrides = {}) => ({
+  getSeekableDuration: () => 100,
+  getContentPosition: () => 40,
+  isLive: () => false,
+  getPlayNextEntry: () => null,
+  playNextHandler: jest.fn(),
+  seekTo: jest.fn(),
+  ...overrides,
+});
+
+const manager = (active) =>
+  ({ getActivePlayer: () => active, isCasting: () => false }) as any;
+
+const registeredTools = async (active) => {
+  mockRegister.mockResolvedValue(undefined);
+  mockXray = { registerReactToolbox: mockRegister };
+  await loadToolbox().registerPlayerToolbox(manager(active));
+
+  const { tools } = mockRegister.mock.lastCall[0];
+
+  return Object.fromEntries(tools.map((tool) => [tool.name, tool.handler]));
+};
+
+describe("playerToolbox", () => {
+  beforeEach(() => {
+    mockRegister.mockReset();
+  });
+
+  it("does nothing when X-Ray has no React toolbox API", async () => {
+    mockXray = {};
+
+    await expect(
+      loadToolbox().registerPlayerToolbox(manager(null))
+    ).resolves.toBe(false);
+  });
+
+  it("does nothing when getXray returns null", async () => {
+    mockXray = null;
+
+    await expect(
+      loadToolbox().registerPlayerToolbox(manager(null))
+    ).resolves.toBe(false);
+  });
+
+  it("swallows a failed registration", async () => {
+    mockRegister.mockRejectedValue(new Error("no native bridge"));
+    mockXray = { registerReactToolbox: mockRegister };
+
+    await expect(
+      loadToolbox().registerPlayerToolbox(manager(null))
+    ).resolves.toBe(false);
+  });
+
+  it("seeks to an absolute position, from the end when negative, clamped", async () => {
+    const active = player();
+    const tools = await registeredTools(active);
+
+    expect(tools.seek({ position: 30 })).toEqual({ position: 30 });
+    expect(tools.seek({ position: -10 })).toEqual({ position: 90 });
+    expect(tools.seek({ position: 500 })).toEqual({ position: 100 });
+    expect(tools.seek({ position: -500 })).toEqual({ position: 0 });
+    expect(active.seekTo.mock.calls).toEqual([[30], [90], [100], [0]]);
+  });
+
+  it("offsets from the current position and refuses zero", async () => {
+    const tools = await registeredTools(player());
+
+    expect(tools.offset({ seconds: 15 })).toEqual({ from: 40, position: 55 });
+    expect(tools.offset({ seconds: -60 })).toEqual({ from: 40, position: 0 });
+
+    expect(() => tools.offset({ seconds: 0 })).toThrow(
+      "Ignored zero relative seek"
+    );
+  });
+
+  describe("state", () => {
+    const playing = (overrides = {}, entry: any = { id: "e1", title: "T" }) =>
+      player({
+        playerId: "p1",
+        playerRole: "Primary",
+        getEntry: () => entry,
+        getPosition: () => 40,
+        getDuration: () => 100,
+        getContentDuration: () => 100,
+        isReadyToPlay: () => true,
+        isPlaying: () => true,
+        isBuffering: () => false,
+        isAd: () => false,
+        isLive: () => false,
+        getIsMuted: () => false,
+        ...overrides,
+      });
+
+    const state = async (overrides = {}, entry?: any) =>
+      (await registeredTools(playing(overrides, entry))).state();
+
+    it("reports inactive when nothing plays", async () => {
+      expect((await registeredTools(null)).state()).toEqual({
+        active: false,
+        casting: false,
+      });
+    });
+
+    it("keeps the existing fields and adds the content clock for a VOD", async () => {
+      expect(await state()).toEqual({
+        active: true,
+        playerId: "p1",
+        entry: { id: "e1", title: "T" },
+        position: 40,
+        duration: 100,
+        playing: true,
+        buffering: false,
+        readyToPlay: true,
+        ad: false,
+        live: false,
+        muted: false,
+        role: "Primary",
+        plugin: null,
+        engine: null,
+        casting: false,
+        seekableDuration: 100,
+        contentPosition: 40,
+        contentDuration: 100,
+        drm: null,
+        lastError: null,
+        next: null,
+      });
+    });
+
+    it("reports the content's clock next to the ad's during a client-side ad", async () => {
+      const result = await state({
+        isAd: () => true,
+        getPosition: () => 5,
+        getDuration: () => 15,
+        getContentPosition: () => 300,
+        getContentDuration: () => 1800,
+      });
+
+      expect(result).toMatchObject({
+        ad: true,
+        position: 5,
+        duration: 15,
+        contentPosition: 300,
+        contentDuration: 1800,
+      });
+    });
+
+    it("reports non-finite numbers as null", async () => {
+      expect(
+        await state({
+          getSeekableDuration: () => NaN,
+          getContentPosition: () => null,
+          getContentDuration: () => Infinity,
+        })
+      ).toMatchObject({
+        seekableDuration: null,
+        contentPosition: null,
+        contentDuration: null,
+      });
+    });
+
+    it("reports the player plugin and its web engine", async () => {
+      expect(
+        await state({
+          playerPluginId: "QuickBrickPlayerPlugin",
+          engine: "hls.js",
+        })
+      ).toMatchObject({ plugin: "QuickBrickPlayerPlugin", engine: "hls.js" });
+    });
+
+    it("lists the entry's DRM key systems, or null", async () => {
+      const drm = { widevine: { license_url: "w" }, playready: {} };
+
+      expect((await state({}, { id: "e", extensions: { drm } })).drm).toEqual([
+        "widevine",
+        "playready",
+      ]);
+
+      expect((await state({}, { id: "e", extensions: { drm: {} } })).drm).toBe(
+        null
+      );
+
+      expect((await state({}, { id: "e", extensions: {} })).drm).toBe(null);
+      expect((await state({}, null)).drm).toBe(null);
+    });
+
+    it("reports no last error as null", async () => {
+      expect((await state({ lastError: null })).lastError).toBeNull();
+    });
+  });
+
+  describe("play next", () => {
+    const nextEntry = { id: "n1", title: "Next", extensions: {} };
+
+    const stateWith = async (overrides) =>
+      (
+        await registeredTools(
+          player({
+            getEntry: () => null,
+            getPosition: () => 0,
+            getDuration: () => 0,
+            getContentDuration: () => 0,
+            isReadyToPlay: () => true,
+            isPlaying: () => true,
+            isBuffering: () => false,
+            isAd: () => false,
+            getIsMuted: () => false,
+            ...overrides,
+          })
+        )
+      ).state();
+
+    it("reports the entry Play Next would play", async () => {
+      expect(
+        (await stateWith({ getPlayNextEntry: () => nextEntry })).next
+      ).toEqual({ id: "n1", title: "Next" });
+    });
+
+    it("reports no next entry as null", async () => {
+      expect((await stateWith({})).next).toBeNull();
+    });
+
+    it("plays the next entry through the player's Play Next action", async () => {
+      const active = player({ getPlayNextEntry: () => nextEntry });
+      const tools = await registeredTools(active);
+
+      expect(tools.next()).toEqual({ id: "n1", title: "Next" });
+      expect(active.playNextHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it("fails without a next entry", async () => {
+      const active = player();
+      const tools = await registeredTools(active);
+
+      expect(() => tools.next()).toThrow("No next item");
+      expect(active.playNextHandler).not.toHaveBeenCalled();
+    });
+
+    it("fails when no Play Next action is registered", async () => {
+      const tools = await registeredTools(
+        player({
+          getPlayNextEntry: () => nextEntry,
+          playNextHandler: null,
+        })
+      );
+
+      expect(() => tools.next()).toThrow("No next item");
+    });
+
+    it("fails without an active player", async () => {
+      const tools = await registeredTools(null);
+
+      expect(() => tools.next()).toThrow("No active player");
+    });
+  });
+
+  it("refuses to seek a stream that is not seekable", async () => {
+    const tools = await registeredTools(
+      player({ getSeekableDuration: () => 0 })
+    );
+
+    expect(() => tools.seek({ position: 10 })).toThrow("Seek is not supported");
+  });
+});

package/appUtils/playerManager/__tests__/usePlayerControllerSetup.test.tsx

@@ -0,0 +1,62 @@
+import { renderHook } from "@testing-library/react-native";
+
+import { usePlayerControllerSetup } from "../usePlayerControllerSetup";
+import { PlayerAnalyticsManager } from "../../../analyticsUtils/PlayerAnalyticsManager";
+
+const calls: string[] = [];
+
+jest.mock("../index", () => ({
+  playerManager: {
+    isPlayerRegistered: jest.fn(() => false),
+    registerPlayer: jest.fn(() => calls.push("registerPlayer")),
+    unregisterPlayer: jest.fn(),
+  },
+}));
+
+jest.mock("../../../analyticsUtils/PlayerAnalyticsManager", () => ({
+  PlayerAnalyticsManager: {
+    getInstance: jest.fn(() => calls.push("analyticsManager")),
+  },
+}));
+
+jest.mock("../../../reactHooks/useConfiguration", () => ({
+  useConfiguration: () => ({}),
+}));
+
+jest.mock("../../../playerUtils/useValidatePlayerConfig", () => ({
+  useValidatePlayerConfig: jest.fn(),
+}));
+
+jest.mock("../../../reactUtils", () => ({
+  isTV: () => false,
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Helpers/Platform",
+  () => ({
+    isAppleTV: () => false,
+  })
+);
+
+class Controller {
+  destroy = jest.fn();
+}
+
+describe("usePlayerControllerSetup", () => {
+  it("creates the analytics manager before the player registers", () => {
+    renderHook(() =>
+      usePlayerControllerSetup({
+        props: { playerId: "player-1", entry: { id: "entry-1" } },
+        ControllerType: Controller,
+        ref: null,
+        manifest: {},
+        pluginId: "plugin",
+      })
+    );
+
+    // The manager attaches analytics to players as they register, so a player
+    // registered before it exists would send no player analytics events
+    expect(PlayerAnalyticsManager.getInstance).toHaveBeenCalled();
+    expect(calls).toEqual(["analyticsManager", "registerPlayer"]);
+  });
+});

package/appUtils/playerManager/index.ts

@@ -11,6 +11,7 @@ import {
 import { setUserLanguagePreference } from "./userLanguagePreference";
 import { PlayerRole } from "./const";
 import { RNPlayerManager } from "./nativePlayerManager";
+import { registerPlayerToolbox } from "./playerToolbox";
 
 const { log_error, log_debug, log_warning } = createLogger({
   category: "General",
@@ -54,6 +55,7 @@ export class PlayerManager {
   public static getInstance() {
     if (!PlayerManager.instance) {
       PlayerManager.instance = new PlayerManager();
+      registerPlayerToolbox(PlayerManager.instance);
     }
 
     return PlayerManager.instance;
@@ -395,6 +397,11 @@ export class PlayerManager {
     return this.manager.removeHandler(event, handler);
   }
 
+  /** Whether anything handles `event` now, e.g. a mounted PlayerContainer for "toggleFullscreen". */
+  public hasHandler(event: string) {
+    return this.manager.handlers[event]?.length > 0;
+  }
+
   // TODO: should not be
   public invokeHandler(event, ...args) {
     return this.manager.invokeHandler(event, ...args);