@applicaster/zapp-react-native-utils 16.0.0-alpha.2663208063 → 16.0.0-alpha.2710214351

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/OverlayObserver/OverlaysObserver.ts

@@ -2,8 +2,7 @@ import { BehaviorSubject, Observable } from "rxjs";
 import { distinctUntilChanged } from "rxjs/operators";
 import { Player } from "../player";
 import { createLogger, utilsLogger } from "../../../logger";
-import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
-import { findPluginByIdentifier } from "../../../pluginUtils";
+import { getPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
 import {
   loadFeedEntry,
   loadFeedAndPrefetchThumbnailImage,
@@ -237,11 +236,8 @@ export class OverlaysObserver {
 
   preparePlayNext = async () => {
     try {
-      const plugins = appStore.get("plugins");
-
-      const playNextPlugin: any = findPluginByIdentifier(
-        "QuickBrickPlayNextOverlay",
-        plugins
+      const playNextPlugin: any = getPluginByIdentifier(
+        "QuickBrickPlayNextOverlay"
       );
 
       if (!playNextPlugin) {
@@ -252,10 +248,7 @@ export class OverlaysObserver {
         return;
       }
 
-      const playNextFeedUrl: string = await retrieveFeedUrl(
-        this.entry,
-        plugins
-      );
+      const playNextFeedUrl: string = await retrieveFeedUrl(this.entry);
 
       if (!playNextFeedUrl || typeof playNextFeedUrl !== "string") {
         log_debug(

package/appUtils/playerManager/OverlayObserver/__tests__/getUpcomingQueue.test.ts

@@ -0,0 +1,67 @@
+import { getUpcomingQueue } from "../getUpcomingQueue";
+
+describe("getUpcomingQueue", () => {
+  it("returns null when plugin is not provided or has no module", async () => {
+    expect(await getUpcomingQueue(undefined)).toBeNull();
+    expect(await getUpcomingQueue({} as any)).toBeNull();
+  });
+
+  it("returns null when QueueManager is not present on module", async () => {
+    const plugin = {
+      identifier: "queue-action",
+      module: {},
+    } as any;
+
+    expect(await getUpcomingQueue(plugin)).toBeNull();
+  });
+
+  it("calls setupQuickBrickQueue when QueueManager is not initialized", async () => {
+    const setupQuickBrickQueue = jest.fn();
+    const mockUpcoming = [{ id: "item_1" }];
+
+    const QueueManager = {
+      isInitialized: jest
+        .fn()
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(true),
+      instance: {
+        getUpcomingQueue: jest.fn().mockResolvedValue(mockUpcoming),
+      },
+    };
+
+    const plugin = {
+      identifier: "queue-action",
+      module: {
+        QueueManager,
+        setupQuickBrickQueue,
+      },
+    } as any;
+
+    const result = await getUpcomingQueue(plugin);
+
+    expect(setupQuickBrickQueue).toHaveBeenCalled();
+    expect(result).toEqual(mockUpcoming);
+  });
+
+  it("returns upcoming items when QueueManager is already initialized", async () => {
+    const mockUpcoming = [{ id: "item_1" }, { id: "item_2" }];
+
+    const QueueManager = {
+      isInitialized: jest.fn().mockReturnValue(true),
+      instance: {
+        getUpcomingQueue: jest.fn().mockResolvedValue(mockUpcoming),
+      },
+    };
+
+    const plugin = {
+      identifier: "queue-action",
+      module: {
+        QueueManager,
+      },
+    } as any;
+
+    const result = await getUpcomingQueue(plugin);
+
+    expect(result).toEqual(mockUpcoming);
+  });
+});

package/appUtils/playerManager/OverlayObserver/__tests__/utils.test.ts

@@ -1,5 +1,12 @@
 import { retrieveFeedUrl, retrievePlayPreviousFeedUrl } from "../utils";
 
+// mock for import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: {
+    get: jest.fn(() => []),
+  },
+}));
+
 const entryWith = (extensions: Record<string, unknown>): ZappEntry =>
   ({ id: "1", type: { value: "video" }, extensions }) as ZappEntry;
 
@@ -7,14 +14,14 @@ describe("playlist feed url accessors", () => {
   it("returns the next feed url when present", async () => {
     const entry = entryWith({ play_next_feed_url: "https://feeds/next.json" });
 
-    await expect(retrieveFeedUrl(entry, [])).resolves.toBe(
+    await expect(retrieveFeedUrl(entry)).resolves.toBe(
       "https://feeds/next.json"
     );
   });
 
   it("resolves to null for a missing entry", async () => {
     await expect(
-      retrieveFeedUrl(undefined as unknown as ZappEntry, [])
+      retrieveFeedUrl(undefined as unknown as ZappEntry)
     ).resolves.toBeNull();
   });
 

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.android.tv.ts

@@ -1 +1,4 @@
-export const getUpcomingQueue = async (): Promise<unknown[] | null> => null;
+/** `queue-action` is not supported on this platform. See getUpcomingQueue.ts */
+export const getUpcomingQueue = async (
+  _plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => null;

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.ios.tv.ts

@@ -1 +1,4 @@
-export const getUpcomingQueue = async (): Promise<unknown[] | null> => null;
+/** `queue-action` is not supported on this platform. See getUpcomingQueue.ts */
+export const getUpcomingQueue = async (
+  _plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => null;

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.ts

@@ -1,5 +1,24 @@
-export const getUpcomingQueue = async () => {
-  const { QueueManager } = require("@applicaster/queue-action/src/Manager");
+export const getUpcomingQueue = async (
+  plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => {
+  const module = (plugin as any)?.module;
+  const QueueManager = module?.QueueManager;
+  const setupQuickBrickQueue = module?.setupQuickBrickQueue;
+
+  if (!QueueManager) {
+    return null;
+  }
+
+  if (
+    !QueueManager.isInitialized?.() &&
+    typeof setupQuickBrickQueue === "function"
+  ) {
+    setupQuickBrickQueue();
+  }
+
+  if (!QueueManager.isInitialized?.()) {
+    return null;
+  }
 
   return QueueManager.instance.getUpcomingQueue();
 };

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.web.ts

@@ -1 +1,4 @@
-export const getUpcomingQueue = async (): Promise<unknown[] | null> => null;
+/** `queue-action` is not supported on this platform. See getUpcomingQueue.ts */
+export const getUpcomingQueue = async (
+  _plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => null;

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -59,18 +59,20 @@ export const parseTimeToSeconds = (timeStr: string): number => {
  * on playerManager, decoupling Queue playback logic entirely from OverlaysObserver (which should
  * strictly focus on recommendation visuals and chapter markers).
  */
-export const retrieveFeedUrl = async (
-  entry: ZappEntry,
-  plugins?: ZappPlugin[]
-): Promise<string> => {
+export const retrieveFeedUrl = async (entry: ZappEntry): Promise<string> => {
   if (!entry) return null;
 
-  const availablePlugins = plugins || appStore.get("plugins");
-  const queuePlugin = findPluginByIdentifier("queue-action", availablePlugins);
+  const availablePlugins = appStore.get("plugins");
+
+  const queuePlugin = findPluginByIdentifier(
+    "queue-action",
+    availablePlugins,
+    true
+  );
 
   if (queuePlugin) {
     try {
-      const upcomingQueue = await getUpcomingQueue();
+      const upcomingQueue = await getUpcomingQueue(queuePlugin);
 
       if (upcomingQueue && upcomingQueue.length > 0) {
         const queueItemId = entry?.extensions?.queueItemId || entry?.id;

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__/playerNative.test.ts

@@ -0,0 +1,114 @@
+import { PlayerNative } from "../playerNative";
+
+const playerWithEntry = (entry: any) =>
+  new PlayerNative({
+    entry,
+    player: null as any,
+    playerId: "test-player",
+  });
+
+describe("PlayerNative.isAudioItem", () => {
+  it.each(["audio", "audio-player", "audio-detail", "audio-show", "audio-hub"])(
+    "treats the %s content type as audio",
+    (type) => {
+      expect(playerWithEntry({ type: { value: type } }).isAudioItem()).toBe(
+        true
+      );
+    }
+  );
+
+  it.each(["video", "video-detail", "comic-detail", "article-show"])(
+    "does not treat the %s content type as audio",
+    (type) => {
+      expect(playerWithEntry({ type: { value: type } }).isAudioItem()).toBe(
+        false
+      );
+    }
+  );
+
+  it("falls back to the media type when the content type says nothing", () => {
+    const entry = { content: { type: "audio/mpeg" }, type: { value: "link" } };
+
+    expect(playerWithEntry(entry).isAudioItem()).toBe(true);
+  });
+
+  it("returns false when there is no entry", () => {
+    expect(playerWithEntry(null).isAudioItem()).toBe(false);
+  });
+});
+
+describe("PlayerNative.command", () => {
+  it("invokes native function with playerId on iOS platform", () => {
+    const player = new PlayerNative({
+      entry: null,
+      player: { current: {} } as any,
+      playerId: "test-player",
+      playerPluginId: "QuickBrickPlayerPlugin",
+    });
+
+    const commandSpy = jest.fn();
+
+    jest.spyOn(player, "getPlayerModule").mockReturnValue({
+      command: commandSpy,
+    } as any);
+
+    player.command("setPlayerControls", { transport: ["play"] });
+
+    expect(commandSpy).toHaveBeenCalledWith(
+      "setPlayerControls",
+      "test-player",
+      {
+        transport: ["play"],
+      }
+    );
+  });
+
+  it("invokes native function with view tag on Android when method exists", () => {
+    const reactUtils = require("../../../reactUtils");
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(false);
+
+    const player = new PlayerNative({
+      entry: null,
+      player: { current: {} } as any,
+      playerId: "test-player",
+      playerPluginId: "QuickBrickPlayerPlugin",
+    });
+
+    const commandSpy = jest.fn();
+
+    jest.spyOn(player, "getPlayerModule").mockReturnValue({
+      command: commandSpy,
+    } as any);
+
+    jest.spyOn(player, "getComponentNode").mockReturnValue(12345 as any);
+
+    player.command("setPlayerControls", { transport: ["play"] });
+
+    expect(commandSpy).toHaveBeenCalledWith(12345, "setPlayerControls", {
+      transport: ["play"],
+    });
+
+    (reactUtils.isApplePlatform as jest.Mock).mockRestore();
+  });
+
+  it("handles when native module does not have command method on Android", () => {
+    const reactUtils = require("../../../reactUtils");
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(false);
+
+    const player = new PlayerNative({
+      entry: null,
+      player: { current: {} } as any,
+      playerId: "test-player",
+      playerPluginId: "KalturaPlayerPlugin",
+    });
+
+    jest.spyOn(player, "getPlayerModule").mockReturnValue({} as any);
+    jest.spyOn(player, "getComponentNode").mockReturnValue(12345 as any);
+
+    expect(() => {
+      player.command("setPlayerControls", { transport: ["play"] });
+    }).not.toThrow();
+
+    (reactUtils.isApplePlatform as jest.Mock).mockRestore();
+  });
+});

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

@@ -0,0 +1,62 @@
+import { NativeModules } from "react-native";
+import {
+  PlayerNativeCommandTypes,
+  PlayerNativeSendCommand,
+} from "../playerNativeCommand";
+
+describe("PlayerNativeSendCommand", () => {
+  const reactUtils = require("../../../reactUtils");
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("calls NativeModules.PlayerModule.command on Apple platform with playerId", () => {
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(true);
+
+    NativeModules.PlayerModule = {
+      command: jest.fn(),
+    };
+
+    PlayerNativeSendCommand(
+      PlayerNativeCommandTypes.setPlayerControls,
+      "player-123",
+      { transport: ["play"] }
+    );
+
+    expect(NativeModules.PlayerModule.command).toHaveBeenCalledWith(
+      "setPlayerControls",
+      "player-123",
+      { transport: ["play"] }
+    );
+  });
+
+  it("does not call NativeModules.PlayerModule.command on non-Apple platform", () => {
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(false);
+
+    NativeModules.PlayerModule = {
+      command: jest.fn(),
+    };
+
+    PlayerNativeSendCommand(
+      PlayerNativeCommandTypes.setPlayerControls,
+      "player-123",
+      { transport: ["play"] }
+    );
+
+    expect(NativeModules.PlayerModule.command).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when playerId or command is missing", () => {
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(true);
+
+    NativeModules.PlayerModule = {
+      command: jest.fn(),
+    };
+
+    PlayerNativeSendCommand("", "player-123");
+    PlayerNativeSendCommand("setPlayerControls", "");
+
+    expect(NativeModules.PlayerModule.command).not.toHaveBeenCalled();
+  });
+});