@applicaster/zapp-react-native-utils 16.0.0-alpha.2434153375 → 16.0.0-alpha.2500443242

package/actionsExecutor/consts.ts

@@ -9,6 +9,9 @@ export const ACTION_TYPES = {
   PRESENT_SUB_MENU: "presentSubMenu",
   SEND_CLOUD_EVENT: "sendCloudEvent",
   NAVIGATE_TO_SCREEN: "navigateToScreen",
+  PRESENT_SCREEN: "presentScreen",
+  GO_BACK: "goBack",
+  GO_HOME: "goHome",
   SHOW_TOAST: "showToast",
   LOCAL_STORAGE_SET: "localStorageSet",
   LOCAL_STORAGE_REMOVE: "localStorageRemove",
@@ -20,6 +23,7 @@ export const ACTION_TYPES = {
   SWITCH_LAYOUT: "switchLayout",
   APP_RESTART: "appRestart",
   CONFIRM_DIALOG: "confirmDialog",
+  SHOW_ALERT: "showAlert",
   SCREEN_SET_VARIABLE: "screenSetVariable",
   SCREEN_TOGGLE_FLAG: "screenToggleFlag",
 } as const;

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.ts

@@ -1,9 +1,22 @@
 export const getUpcomingQueue = async (
   plugin?: QuickBrickPlugin | ZappPlugin
 ): Promise<unknown[] | null> => {
-  const QueueManager = (plugin as any)?.module?.QueueManager;
+  const module = (plugin as any)?.module;
+  const QueueManager = module?.QueueManager;
+  const setupQuickBrickQueue = module?.setupQuickBrickQueue;
 
-  if (!QueueManager?.instance) {
+  if (!QueueManager) {
+    return null;
+  }
+
+  if (
+    !QueueManager.isInitialized?.() &&
+    typeof setupQuickBrickQueue === "function"
+  ) {
+    setupQuickBrickQueue();
+  }
+
+  if (!QueueManager.isInitialized?.()) {
     return null;
   }
 

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -59,13 +59,10 @@ 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 availablePlugins = appStore.get("plugins");
 
   const queuePlugin = findPluginByIdentifier(
     "queue-action",

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

@@ -36,3 +36,79 @@ describe("PlayerNative.isAudioItem", () => {
     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();
+  });
+});

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

@@ -0,0 +1,97 @@
+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,
+  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.calls[0][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"
+    );
+  });
+
+  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/const.ts

@@ -59,6 +59,19 @@ export enum SharedPlayerCallBacksKeys {
   // PIP
   OnPlayerDetached = "onPlayerDetached",
   OnPlayerAttached = "onPlayerAttached",
+
+  OnRemoteCommand = "onRemoteCommand",
+}
+
+// Ids native sends in onRemoteCommand (lock screen / Control Center / CarPlay buttons)
+export enum RemoteCommand {
+  Play = "play",
+  Pause = "pause",
+  Stop = "stop",
+  NextTrack = "nextTrack",
+  PreviousTrack = "previousTrack",
+  SkipForward = "skipForward",
+  SkipBackward = "skipBackward",
 }
 
 export enum PlayerRole {

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);

package/appUtils/playerManager/player.ts

@@ -746,6 +746,13 @@ export class Player {
     });
   };
 
+  onRemoteCommand = (event: QuickBrickPlayer.RemoteCommandEvent) => {
+    this.invokeListenersUpdate({
+      callbackName: SharedPlayerCallBacksKeys.OnRemoteCommand,
+      event,
+    });
+  };
+
   getTracksState = (): QuickBrickPlayer.TracksState =>
     this.playerState.trackState;
 
@@ -823,6 +830,8 @@ export class Player {
     // PIP
     onPlayerDetached: this.onPlayerDetached,
     onPlayerAttached: this.onPlayerAttached,
+
+    onRemoteCommand: this.onRemoteCommand,
   });
 
   play = () => {};
@@ -832,6 +841,7 @@ export class Player {
   setPlaybackRate = (_rate) => {};
   startSleepTimer = (_timestamp) => {};
   cancelSleepTimer = () => {};
+  command = (_command: string, _userInfo?: Record<string, any>) => {};
 
   getPluginConfiguration = () => null;
   appStateChange = (_appState, _previousAppState) => {};

package/appUtils/playerManager/playerNative.ts

@@ -6,6 +6,7 @@ import { findNodeHandle } from "react-native";
 import { PlayerRole } from "./const";
 import { toBooleanWithDefaultFalse } from "../../booleanUtils";
 import { RNPlayerManager } from "./nativePlayerManager";
+import { isApplePlatform } from "../../reactUtils";
 
 const logger = createLogger({
   category: "PlayerNativeController",
@@ -27,6 +28,7 @@ interface PlayerMethods {
   appStateChange?: (appState: string, previousAppState: string) => void;
   closeNativePlayer?: () => void;
   togglePlayPause?: () => void;
+  command?: (command: string, userInfo?: Record<string, any>) => void;
 }
 
 type PlayerComponent = ReactComponent<PlayerRefProps> & PlayerMethods;
@@ -52,6 +54,7 @@ const PlayerModuleFuncNames = {
   startSleepTimer: "startSleepTimer",
   cancelSleepTimer: "cancelSleepTimer",
   getSleepTimerEnd: "getSleepTimerEnd",
+  command: "command",
 };
 
 export class PlayerNative extends Player {
@@ -206,6 +209,25 @@ export class PlayerNative extends Player {
     }
   };
 
+  command = (command: string, userInfo?: Record<string, any>) => {
+    if (isApplePlatform()) {
+      const module = this.getPlayerModule();
+      module?.command?.(command, this.playerId, userInfo);
+
+      return true;
+    }
+
+    if (
+      !this.invokeNativeFunction(
+        PlayerModuleFuncNames.command,
+        command,
+        userInfo
+      )
+    ) {
+      this.currentPlayerComponent()?.command?.(command, userInfo);
+    }
+  };
+
   disableBufferAnimation = (): boolean => false;
 
   selectTrack = (

package/appUtils/playerManager/playerNativeCommand.ts

@@ -1,14 +1,11 @@
 import { isApplePlatform } from "../../reactUtils";
 import { NativeModules } from "react-native";
 
-const NativePlayerModule = isApplePlatform()
-  ? NativeModules.PlayerModule
-  : NativeModules.QuickBrickDefaultPlayerModule;
-
 const PlayerNativeCommandTypes = {
   pause: "pause",
   clearPlayerData: "clearPlayerData",
   removeViewByNativeId: "removeViewByNativeId",
+  setPlayerControls: "setPlayerControls",
 };
 
 const PlayerNativeSendCommand = (
@@ -16,8 +13,8 @@ const PlayerNativeSendCommand = (
   playerId: string,
   userInfo?: Record<string, any>
 ) => {
-  if (playerId && command) {
-    NativePlayerModule?.command?.(command, playerId, userInfo);
+  if (isApplePlatform() && playerId && command) {
+    NativeModules.PlayerModule?.command?.(command, playerId, userInfo);
   }
 };