@applicaster/quick-brick-player 16.0.0-rc.8 → 16.0.0-rc.80

package/src/Player/AudioLayer/__tests__/usePlaylistNavigation.test.ts

@@ -0,0 +1,387 @@
+import { renderHook, act } from "@testing-library/react-native";
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { usePlayer } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer";
+import { loadFeedEntry } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils";
+
+import { usePlaylistNavigation } from "../usePlaylistNavigation";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
+  useNavigation: jest.fn(),
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer",
+  () => ({ usePlayer: jest.fn() })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils",
+  () => ({
+    loadFeedEntry: jest.fn(),
+    retrieveFeedUrl: async (entry) => entry?.extensions?.play_next_feed_url,
+    retrievePlayPreviousFeedUrl: (entry) =>
+      entry?.extensions?.play_previous_feed_url,
+  })
+);
+
+const useNavigationMock = useNavigation as jest.Mock;
+const loadFeedEntryMock = loadFeedEntry as jest.Mock;
+const usePlayerMock = usePlayer as jest.Mock;
+
+const NEXT_URL = "https://feeds/next.json";
+const PREV_URL = "https://feeds/prev.json";
+
+const entryWith = (extensions: Record<string, unknown>): ZappEntry =>
+  ({ id: "current", type: { value: "audio" }, extensions }) as ZappEntry;
+
+/** Seekable VOD by default; pass 0 for a live stream with no seek window. */
+const stateAt = (
+  currentTime: number,
+  seekableDuration = 600
+): QuickBrickPlayer.PlayerState =>
+  ({ currentTime, seekableDuration }) as QuickBrickPlayer.PlayerState;
+
+const NOT_SEEKABLE = 0;
+
+const renderPlaylistNavigation = async (
+  entry: ZappEntry,
+  playerState: QuickBrickPlayer.PlayerState
+) => {
+  const rendered = renderHook(() => usePlaylistNavigation(entry, playerState));
+
+  await act(async () => {});
+
+  return rendered;
+};
+
+describe("usePlaylistNavigation", () => {
+  let replaceTop: jest.Mock;
+  let seekTo: jest.Mock;
+
+  beforeEach(() => {
+    replaceTop = jest.fn();
+    seekTo = jest.fn();
+
+    useNavigationMock.mockReturnValue({ replaceTop });
+
+    usePlayerMock.mockReturnValue({ seekTo });
+
+    loadFeedEntryMock.mockReset();
+  });
+
+  describe("availability", () => {
+    it("reports both directions when both extensions are present", async () => {
+      const entry = entryWith({
+        play_next_feed_url: NEXT_URL,
+        play_previous_feed_url: PREV_URL,
+      });
+
+      const { result } = await renderPlaylistNavigation(entry, stateAt(0));
+
+      expect(result.current.hasNext).toBe(true);
+      expect(result.current.hasPrevious).toBe(true);
+    });
+
+    it("keeps previous available at the head of a chain when the track is seekable", async () => {
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const { result } = await renderPlaylistNavigation(entry, stateAt(0));
+
+      expect(result.current.hasNext).toBe(true);
+      expect(result.current.hasPrevious).toBe(true);
+    });
+
+    it("reports no previous only when the track cannot seek either", async () => {
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const { result } = await renderPlaylistNavigation(
+        entry,
+        stateAt(0, NOT_SEEKABLE)
+      );
+
+      expect(result.current.hasNext).toBe(true);
+      expect(result.current.hasPrevious).toBe(false);
+    });
+
+    it("reports neither direction for a non-seekable entry with no extensions", async () => {
+      const { result } = await renderPlaylistNavigation(
+        entryWith({}),
+        stateAt(0, NOT_SEEKABLE)
+      );
+
+      expect(result.current.hasNext).toBe(false);
+      expect(result.current.hasPrevious).toBe(false);
+    });
+  });
+
+  describe("goNext", () => {
+    it("plays the entry resolved from the next feed url", async () => {
+      const target = { id: "next" } as ZappEntry;
+      loadFeedEntryMock.mockResolvedValue(target);
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const { result } = await renderPlaylistNavigation(entry, stateAt(0));
+
+      await act(async () => result.current.goNext());
+
+      expect(loadFeedEntryMock).toHaveBeenCalledWith(NEXT_URL, entry);
+      expect(replaceTop).toHaveBeenCalledWith(target);
+    });
+
+    it("does nothing when there is no next url", async () => {
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entryWith({}), stateAt(0))
+      );
+
+      await act(async () => result.current.goNext());
+
+      expect(loadFeedEntryMock).not.toHaveBeenCalled();
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+
+    it("leaves playback untouched when the feed fails to load", async () => {
+      loadFeedEntryMock.mockRejectedValue(new Error("network down"));
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entry, stateAt(0))
+      );
+
+      await act(async () => result.current.goNext());
+
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("goPrevious", () => {
+    it("restarts the current track when past the threshold", async () => {
+      const entry = entryWith({ play_previous_feed_url: PREV_URL });
+
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entry, stateAt(10))
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).toHaveBeenCalledWith(0);
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+
+    it("plays the previous entry when before the threshold", async () => {
+      const target = { id: "prev" } as ZappEntry;
+      loadFeedEntryMock.mockResolvedValue(target);
+      const entry = entryWith({ play_previous_feed_url: PREV_URL });
+
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entry, stateAt(1))
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).not.toHaveBeenCalled();
+      expect(replaceTop).toHaveBeenCalledWith(target);
+    });
+
+    it("restarts the track when there is no previous entry to move to", async () => {
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(
+          entryWith({ play_next_feed_url: NEXT_URL }),
+          stateAt(390)
+        )
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).toHaveBeenCalledWith(0);
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+
+    it("restarts even before the threshold when there is no previous entry", async () => {
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entryWith({}), stateAt(1))
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).toHaveBeenCalledWith(0);
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+
+    // usePlayer, not playerManager.getActivePlayer — the latter is always the
+    // local player, so restarting would be lost while casting.
+    it("restarts through the player that owns playback, not the local one", async () => {
+      const receiverSeekTo = jest.fn();
+      usePlayerMock.mockReturnValue({ seekTo: receiverSeekTo });
+
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(
+          entryWith({ play_previous_feed_url: PREV_URL }),
+          stateAt(10)
+        )
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(receiverSeekTo).toHaveBeenCalledWith(0);
+    });
+
+    it("does nothing when there is neither a previous entry nor a seek window", async () => {
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entryWith({}), stateAt(10, NOT_SEEKABLE))
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).not.toHaveBeenCalled();
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+
+    it("navigates to the previous entry past the threshold when the stream cannot seek", async () => {
+      const target = { id: "prev" } as ZappEntry;
+      loadFeedEntryMock.mockResolvedValue(target);
+
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(
+          entryWith({ play_previous_feed_url: PREV_URL }),
+          stateAt(10, NOT_SEEKABLE)
+        )
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).not.toHaveBeenCalled();
+      expect(replaceTop).toHaveBeenCalledWith(target);
+    });
+
+    it("restarts past the threshold when the stream is seekable", async () => {
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(
+          entryWith({ play_previous_feed_url: PREV_URL }),
+          stateAt(10)
+        )
+      );
+
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).toHaveBeenCalledWith(0);
+      expect(replaceTop).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("double tap guard", () => {
+    const bothDirections = {
+      play_next_feed_url: NEXT_URL,
+      play_previous_feed_url: PREV_URL,
+    };
+
+    /**
+     * Makes the next feed request hang until the returned function is called,
+     * so a test can fire a second tap while the first is still in flight.
+     */
+    const deferredFeed = () => {
+      const deferred: { complete?: (entry: ZappEntry) => void } = {};
+
+      loadFeedEntryMock.mockReturnValue(
+        new Promise<ZappEntry>((resolve) => {
+          deferred.complete = resolve;
+        })
+      );
+
+      return (entry: ZappEntry) => deferred.complete(entry);
+    };
+
+    it("ignores a second tap while the first request is still in flight", async () => {
+      const complete = deferredFeed();
+
+      const { result } = await renderPlaylistNavigation(
+        entryWith(bothDirections),
+        stateAt(0)
+      );
+
+      await act(async () => {
+        const first = result.current.goNext();
+        const second = result.current.goNext();
+
+        complete({ id: "next" } as ZappEntry);
+
+        await Promise.all([first, second]);
+      });
+
+      expect(loadFeedEntryMock).toHaveBeenCalledTimes(1);
+      expect(replaceTop).toHaveBeenCalledTimes(1);
+    });
+
+    it("stops Previous racing an in-flight Next", async () => {
+      const complete = deferredFeed();
+
+      const { result } = await renderPlaylistNavigation(
+        entryWith(bothDirections),
+        stateAt(0)
+      );
+
+      await act(async () => {
+        const next = result.current.goNext();
+        const previous = result.current.goPrevious();
+
+        complete({ id: "next" } as ZappEntry);
+
+        await Promise.all([next, previous]);
+      });
+
+      expect(loadFeedEntryMock).toHaveBeenCalledTimes(1);
+
+      expect(loadFeedEntryMock).toHaveBeenCalledWith(
+        NEXT_URL,
+        expect.anything()
+      );
+    });
+
+    it("allows a new navigation once the previous one has completed", async () => {
+      loadFeedEntryMock.mockResolvedValue({ id: "next" } as ZappEntry);
+
+      const { result } = await renderPlaylistNavigation(
+        entryWith(bothDirections),
+        stateAt(0)
+      );
+
+      await act(async () => result.current.goNext());
+      await act(async () => result.current.goNext());
+
+      expect(loadFeedEntryMock).toHaveBeenCalledTimes(2);
+      expect(replaceTop).toHaveBeenCalledTimes(2);
+    });
+
+    it("releases the guard after a failed request so the control can retry", async () => {
+      loadFeedEntryMock
+        .mockRejectedValueOnce(new Error("network down"))
+        .mockResolvedValueOnce({ id: "next" } as ZappEntry);
+
+      const { result } = await renderPlaylistNavigation(
+        entryWith(bothDirections),
+        stateAt(0)
+      );
+
+      await act(async () => result.current.goNext());
+
+      expect(replaceTop).not.toHaveBeenCalled();
+
+      await act(async () => result.current.goNext());
+
+      expect(replaceTop).toHaveBeenCalledTimes(1);
+    });
+
+    it("does not guard the Previous restart, which is local and instant", async () => {
+      loadFeedEntryMock.mockResolvedValue({ id: "prev" } as ZappEntry);
+
+      const { result } = renderHook(() =>
+        usePlaylistNavigation(entryWith(bothDirections), stateAt(10))
+      );
+
+      await act(async () => result.current.goPrevious());
+      await act(async () => result.current.goPrevious());
+
+      expect(seekTo).toHaveBeenCalledTimes(2);
+      expect(loadFeedEntryMock).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/Player/AudioLayer/playerActions.ts

@@ -0,0 +1,294 @@
+import { map } from "rxjs";
+import {
+  actionExecutor,
+  ActionResult,
+} from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutor";
+import { ActionHandler } from "@applicaster/zapp-react-native-utils/actionsExecutor/types";
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
+import { modalOrchestrator } from "@applicaster/zapp-react-native-utils/modalState/ModalOrchestrator";
+import { toNumber } from "@applicaster/zapp-react-native-utils/numberUtils";
+
+import { speedOptions } from "../Const/speedOptions";
+import { getSleepTimerOptions } from "../Const/sleepTimerOptions";
+import { formatSpeed } from "./utils";
+import { SpeedController } from "./SpeedManager";
+import { SleepTimerController, SleepTimerState } from "./SleepTimerManager";
+
+export const PLAYER_ACTION_IDENTIFIERS = {
+  PLAYBACK_SPEED: "playback-speed",
+  SLEEP_TIMER: "sleep-timer",
+} as const;
+
+export const PLAYER_ACTION_TYPES = {
+  OPEN_PLAYBACK_SPEED: "openPlaybackSpeed",
+  OPEN_SLEEP_TIMER: "openSleepTimer",
+  SET_PLAYBACK_SPEED: "setPlaybackSpeed",
+  SET_SLEEP_TIMER: "setSleepTimer",
+} as const;
+
+function getPlayerConfig(): Record<string, any> {
+  return playerManager.getActivePlayer()?.getConfig?.() || {};
+}
+
+function remainingTimerDate(timerDate: number): number | null {
+  return timerDate !== 0 && +timerDate > Date.now() ? timerDate : null;
+}
+
+function dismissOpenedSheet(action: ActionType) {
+  if (action.options?.dismissSheet) {
+    modalOrchestrator.close();
+  }
+}
+
+function optionToEntry(
+  id: string,
+  title: string,
+  actionType: string,
+  options: Record<string, any>
+): ZappEntry {
+  return {
+    id,
+    title,
+    extensions: {
+      tap_actions: {
+        actions: [
+          { type: actionType, options: { ...options, dismissSheet: true } },
+        ],
+      },
+    },
+  } as ZappEntry;
+}
+
+function sleepTimerEntryState(
+  sleepState: SleepTimerState
+): CellActionEntryState {
+  const config = getPlayerConfig();
+  const isActive = Boolean(remainingTimerDate(sleepState.timerDate));
+
+  return {
+    state: isActive ? 1 : 0,
+    label: config.playback_sleep_title || "Sleep Timer",
+    asset: isActive
+      ? config.sleep_timer_active || config.sleep_timer || ""
+      : config.sleep_timer || "",
+  };
+}
+
+function playbackSpeedEntryState(speed: {
+  asset?: string;
+  value?: number;
+}): CellActionEntryState {
+  const config = getPlayerConfig();
+  const assetKey = speed?.asset || formatSpeed(speed?.value ?? 1);
+
+  return {
+    state: 0,
+    label: config.playback_speed_title || "Playback Speed",
+    // Manifest keys are speed_0_8 / speed_1 / … (same icons as the transport row).
+    // There is no playback_speed uploader.
+    asset: config[assetKey] || config.speed_1 || "",
+  };
+}
+
+export async function openPlaybackSpeedAction(
+  speedController: SpeedController
+): Promise<ActionResult> {
+  const config = getPlayerConfig();
+  const current = speedController.currentSpeed;
+
+  const items = speedOptions.map((option) =>
+    optionToEntry(
+      String(option.value),
+      option.label,
+      PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      { value: option.value }
+    )
+  );
+
+  return actionExecutor.handleAction({
+    type: "openBottomSheet",
+    options: {
+      replace: true,
+      header: {
+        title: config.playback_speed_title || "Playback Speed",
+      },
+      content: {
+        role: "collection_selector",
+        behavior: {
+          selectMode: "single",
+          currentSelection: [String(current.value)],
+        },
+        items,
+      },
+    },
+  } as ActionType);
+}
+
+export async function openSleepTimerAction(
+  sleepController: SleepTimerController
+): Promise<ActionResult> {
+  const config = getPlayerConfig();
+  const sleepState = sleepController.currentState;
+  const timerRemaining = remainingTimerDate(sleepState.timerDate);
+
+  const items = getSleepTimerOptions(
+    config.playback_sleep_off_label || "Off",
+    timerRemaining
+  )
+    .filter(Boolean)
+    .map((option) =>
+      optionToEntry(
+        String(option.value),
+        option.label,
+        PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+        { value: option.value, label: option.label }
+      )
+    );
+
+  return actionExecutor.handleAction({
+    type: "openBottomSheet",
+    options: {
+      replace: true,
+      header: {
+        title: config.playback_sleep_title || "Sleep Timer",
+      },
+      content: {
+        role: "collection_selector",
+        behavior: {
+          selectMode: "single",
+          currentSelection: timerRemaining
+            ? [String(sleepState.timer.value)]
+            : [],
+        },
+        items,
+      },
+    },
+  } as ActionType);
+}
+
+export async function setPlaybackSpeedAction(
+  speedController: SpeedController,
+  action: ActionType
+): Promise<ActionResult> {
+  const value = toNumber(action.options?.value);
+
+  if (!Number.isFinite(value)) {
+    return ActionResult.Error;
+  }
+
+  await speedController.setPlaybackSpeed({
+    asset: formatSpeed(value),
+    value,
+  });
+
+  dismissOpenedSheet(action);
+
+  return ActionResult.Success;
+}
+
+export async function setSleepTimerAction(
+  sleepController: SleepTimerController,
+  action: ActionType
+): Promise<ActionResult> {
+  const value = toNumber(action.options?.value);
+
+  if (!Number.isFinite(value)) {
+    return ActionResult.Error;
+  }
+
+  await sleepController.setSleepTimer({
+    label: action.options?.label || String(value),
+    value,
+  });
+
+  dismissOpenedSheet(action);
+
+  return ActionResult.Success;
+}
+
+export function registerPlayerActions(options: {
+  speedController?: SpeedController;
+  sleepController?: SleepTimerController;
+}): () => void {
+  const unregisters: Array<() => void> = [];
+
+  if (options.speedController) {
+    const speedController = options.speedController;
+
+    const speedHandlers: Array<[string, ActionHandler]> = [
+      [
+        PLAYER_ACTION_TYPES.OPEN_PLAYBACK_SPEED,
+        () => openPlaybackSpeedAction(speedController),
+      ],
+      [
+        PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+        (action) => setPlaybackSpeedAction(speedController, action),
+      ],
+    ];
+
+    speedHandlers.forEach(([type, handler]) => {
+      actionExecutor.unregisterAction(type);
+      unregisters.push(actionExecutor.registerAction(type, handler));
+    });
+
+    unregisters.push(
+      uiActionsRegistry.registerAction(
+        PLAYER_ACTION_IDENTIFIERS.PLAYBACK_SPEED,
+        {
+          initialEntryState: () =>
+            playbackSpeedEntryState(speedController.currentSpeed),
+          observeEntryState: () =>
+            speedController.playbackSpeed$.pipe(
+              map((speed) => playbackSpeedEntryState(speed))
+            ),
+          invokeAction: async () => {
+            await actionExecutor.handleAction({
+              type: PLAYER_ACTION_TYPES.OPEN_PLAYBACK_SPEED,
+            });
+          },
+        }
+      )
+    );
+  }
+
+  if (options.sleepController) {
+    const sleepController = options.sleepController;
+
+    const sleepHandlers: Array<[string, ActionHandler]> = [
+      [
+        PLAYER_ACTION_TYPES.OPEN_SLEEP_TIMER,
+        () => openSleepTimerAction(sleepController),
+      ],
+      [
+        PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+        (action) => setSleepTimerAction(sleepController, action),
+      ],
+    ];
+
+    sleepHandlers.forEach(([type, handler]) => {
+      actionExecutor.unregisterAction(type);
+      unregisters.push(actionExecutor.registerAction(type, handler));
+    });
+
+    unregisters.push(
+      uiActionsRegistry.registerAction(PLAYER_ACTION_IDENTIFIERS.SLEEP_TIMER, {
+        initialEntryState: () =>
+          sleepTimerEntryState(sleepController.currentState),
+        observeEntryState: () =>
+          sleepController.sleepTimerState$.pipe(
+            map((sleepState) => sleepTimerEntryState(sleepState))
+          ),
+        invokeAction: async () => {
+          await actionExecutor.handleAction({
+            type: PLAYER_ACTION_TYPES.OPEN_SLEEP_TIMER,
+          });
+        },
+      })
+    );
+  }
+
+  return () => {
+    unregisters.forEach((unregister) => unregister());
+  };
+}