@applicaster/quick-brick-player 16.0.0-rc.9 → 16.0.0-rc.90

package/src/Player/AudioLayer/PlaylistNavigationController.ts

@@ -0,0 +1,381 @@
+import { BehaviorSubject } from "rxjs";
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { findPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
+import { loadFeedEntry } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils";
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_error, log_info } = createLogger({
+  subsystem: "Player",
+  category: "PlaylistNavigationController",
+});
+
+export const RESTART_THRESHOLD_SECONDS = 3;
+
+export interface PlayerSeeker {
+  seekTo: (time: number) => void;
+}
+
+export interface PlayerNavigator {
+  replaceTop: (entry: ZappEntry) => void;
+}
+
+export interface PlaylistNavigationControllerOptions {
+  entry: ZappEntry;
+  player: PlayerSeeker;
+  navigator: PlayerNavigator;
+  playerState?: QuickBrickPlayer.PlayerState;
+}
+
+export class PlaylistNavigationController {
+  public readonly hasNext$: BehaviorSubject<boolean>;
+  public readonly hasPrevious$: BehaviorSubject<boolean>;
+
+  private entry: ZappEntry;
+  private player: PlayerSeeker;
+  private navigator: PlayerNavigator;
+  private playerState: QuickBrickPlayer.PlayerState | undefined;
+  private isNavigating = false;
+  private unsubscribeQueueListener: (() => void) | null = null;
+  private isDestroyed = false;
+  private recalculateGeneration = 0;
+
+  constructor(options: PlaylistNavigationControllerOptions) {
+    this.entry = options.entry;
+    this.player = options.player;
+    this.navigator = options.navigator;
+    this.playerState = options.playerState;
+
+    const staticNextUrl = this.entry?.extensions?.play_next_feed_url;
+    const staticPrevUrl = this.entry?.extensions?.play_previous_feed_url;
+    const canRestart = (this.playerState?.seekableDuration ?? 0) > 0;
+
+    this.hasNext$ = new BehaviorSubject<boolean>(Boolean(staticNextUrl));
+
+    this.hasPrevious$ = new BehaviorSubject<boolean>(
+      Boolean(staticPrevUrl) || canRestart
+    );
+
+    this.subscribeToQueue();
+    this.recalculate();
+  }
+
+  public updateContext(
+    options: Partial<PlaylistNavigationControllerOptions>
+  ): void {
+    if (options.player) {
+      this.player = options.player;
+    }
+
+    if (options.navigator) {
+      this.navigator = options.navigator;
+    }
+
+    let needsRecalculate = false;
+
+    if (options.entry) {
+      const isSameEntry =
+        this.entry?.id === options.entry?.id &&
+        this.entry?.extensions?.queueItemId ===
+          options.entry?.extensions?.queueItemId;
+
+      if (!isSameEntry) {
+        this.entry = options.entry;
+        needsRecalculate = true;
+      } else {
+        this.entry = options.entry;
+      }
+    }
+
+    if (options.playerState) {
+      const prevCanRestart = (this.playerState?.seekableDuration ?? 0) > 0;
+      const newCanRestart = (options.playerState?.seekableDuration ?? 0) > 0;
+      this.playerState = options.playerState;
+
+      if (prevCanRestart !== newCanRestart) {
+        needsRecalculate = true;
+      }
+    }
+
+    if (needsRecalculate) {
+      this.recalculate();
+    }
+  }
+
+  public updatePlayerState(playerState?: QuickBrickPlayer.PlayerState): void {
+    const prevCanRestart = (this.playerState?.seekableDuration ?? 0) > 0;
+    const newCanRestart = (playerState?.seekableDuration ?? 0) > 0;
+    this.playerState = playerState;
+
+    if (prevCanRestart !== newCanRestart) {
+      this.recalculate();
+    }
+  }
+
+  public updateEntry(entry: ZappEntry): void {
+    if (
+      this.entry?.id === entry?.id &&
+      this.entry?.extensions?.queueItemId === entry?.extensions?.queueItemId
+    ) {
+      this.entry = entry;
+
+      return;
+    }
+
+    this.entry = entry;
+    this.recalculate();
+  }
+
+  private getQueueManagerInstance() {
+    try {
+      const plugins = appStore?.get?.("plugins") || [];
+      const queuePlugin = findPluginByIdentifier("queue-action", plugins, true);
+      const QueueManager = (queuePlugin as any)?.module?.QueueManager;
+
+      if (QueueManager?.isInitialized?.()) {
+        return QueueManager.instance;
+      }
+    } catch {
+      // Safe fallback when store or plugin is not available
+    }
+
+    return null;
+  }
+
+  private subscribeToQueue(): void {
+    const queueManager = this.getQueueManagerInstance();
+
+    if (queueManager?.addListener) {
+      this.unsubscribeQueueListener = queueManager.addListener(() => {
+        if (!this.isDestroyed) {
+          this.recalculate();
+        }
+      });
+    }
+  }
+
+  private async getQueueData(): Promise<{
+    upcoming: ZappEntry[];
+    history: ZappEntry[];
+  }> {
+    const queueManager = this.getQueueManagerInstance();
+
+    if (!queueManager) {
+      return { upcoming: [], history: [] };
+    }
+
+    try {
+      const [upcoming, history] = await Promise.all([
+        queueManager.getUpcomingQueue?.() ?? [],
+        queueManager.getHistoryQueue?.() ?? [],
+      ]);
+
+      return {
+        upcoming: Array.isArray(upcoming) ? upcoming : [],
+        history: Array.isArray(history) ? history : [],
+      };
+    } catch (error) {
+      log_error("PlaylistNavigationController: Error fetching queue items", {
+        error,
+      });
+
+      return { upcoming: [], history: [] };
+    }
+  }
+
+  public async recalculate(): Promise<void> {
+    if (this.isDestroyed) return;
+
+    const generation = ++this.recalculateGeneration;
+    const { upcoming, history } = await this.getQueueData();
+
+    if (this.isDestroyed || generation !== this.recalculateGeneration) {
+      return;
+    }
+
+    const isPlayingFromQueue = Boolean(this.entry?.extensions?.queueItemId);
+    const staticNextUrl = this.entry?.extensions?.play_next_feed_url;
+    const staticPrevUrl = this.entry?.extensions?.play_previous_feed_url;
+
+    const hasNext = isPlayingFromQueue
+      ? upcoming.length > 0 || Boolean(staticNextUrl)
+      : Boolean(staticNextUrl) || upcoming.length > 0;
+
+    const canRestart = (this.playerState?.seekableDuration ?? 0) > 0;
+
+    const hasPrevious = isPlayingFromQueue
+      ? history.length > 0 || Boolean(staticPrevUrl) || canRestart
+      : Boolean(staticPrevUrl) || history.length > 0 || canRestart;
+
+    if (this.hasNext$.getValue() !== hasNext) {
+      this.hasNext$.next(hasNext);
+    }
+
+    if (this.hasPrevious$.getValue() !== hasPrevious) {
+      this.hasPrevious$.next(hasPrevious);
+    }
+  }
+
+  public async goNext(): Promise<void> {
+    if (this.isNavigating || this.isDestroyed) {
+      return;
+    }
+
+    this.isNavigating = true;
+
+    try {
+      const { upcoming } = await this.getQueueData();
+
+      if (this.isDestroyed) return;
+
+      const isPlayingFromQueue = Boolean(this.entry?.extensions?.queueItemId);
+
+      if (isPlayingFromQueue && upcoming.length > 0) {
+        const nextItem = upcoming[0];
+
+        log_info(
+          `goNext: playing next item from queue "${nextItem.title}", id: ${nextItem.id}`,
+          { targetId: nextItem.id }
+        );
+
+        if (this.isDestroyed) return;
+        this.navigator?.replaceTop?.(nextItem);
+
+        return;
+      }
+
+      const staticNextUrl = this.entry?.extensions?.play_next_feed_url;
+
+      if (staticNextUrl) {
+        const target = await loadFeedEntry(staticNextUrl, this.entry);
+
+        if (this.isDestroyed) return;
+
+        log_info(
+          `goNext: playing "${target.title}", id: ${target.id} from remote feed`,
+          {
+            staticNextUrl,
+            targetId: target.id,
+          }
+        );
+
+        this.navigator?.replaceTop?.(target);
+
+        return;
+      }
+
+      if (upcoming.length > 0) {
+        const nextItem = upcoming[0];
+
+        log_info(
+          `goNext: playing next item from queue "${nextItem.title}", id: ${nextItem.id}`,
+          { targetId: nextItem.id }
+        );
+
+        if (this.isDestroyed) return;
+        this.navigator?.replaceTop?.(nextItem);
+      }
+    } catch (error) {
+      log_error("goNext: could not navigate to next entry", { error });
+    } finally {
+      this.isNavigating = false;
+    }
+  }
+
+  public async goPrevious(): Promise<void> {
+    if (this.isNavigating || this.isDestroyed) {
+      return;
+    }
+
+    this.isNavigating = true;
+
+    try {
+      const { history } = await this.getQueueData();
+
+      if (this.isDestroyed) return;
+
+      const isPlayingFromQueue = Boolean(this.entry?.extensions?.queueItemId);
+      const staticPrevUrl = this.entry?.extensions?.play_previous_feed_url;
+
+      const currentTime = this.playerState?.currentTime ?? 0;
+      const canRestart = (this.playerState?.seekableDuration ?? 0) > 0;
+
+      const hasQueueHistory = history.length > 0;
+      const hasStaticPrev = Boolean(staticPrevUrl);
+
+      const hasTarget = isPlayingFromQueue
+        ? hasQueueHistory || hasStaticPrev
+        : hasStaticPrev || hasQueueHistory;
+
+      const shouldRestart =
+        canRestart && (currentTime > RESTART_THRESHOLD_SECONDS || !hasTarget);
+
+      if (shouldRestart) {
+        if (this.isDestroyed) return;
+        this.player?.seekTo?.(0);
+
+        return;
+      }
+
+      if (isPlayingFromQueue && hasQueueHistory) {
+        const prevItem = history[history.length - 1];
+
+        log_info(
+          `goPrevious: playing previous item from queue "${prevItem.title}", id: ${prevItem.id}`,
+          { targetId: prevItem.id }
+        );
+
+        if (this.isDestroyed) return;
+        this.navigator?.replaceTop?.(prevItem);
+
+        return;
+      }
+
+      if (hasStaticPrev) {
+        const target = await loadFeedEntry(staticPrevUrl, this.entry);
+
+        if (this.isDestroyed) return;
+
+        log_info(
+          `goPrevious: playing "${target.title}", id: ${target.id} from remote feed`,
+          {
+            staticPrevUrl,
+            targetId: target.id,
+          }
+        );
+
+        this.navigator?.replaceTop?.(target);
+
+        return;
+      }
+
+      if (hasQueueHistory) {
+        const prevItem = history[history.length - 1];
+
+        log_info(
+          `goPrevious: playing previous item from queue "${prevItem.title}", id: ${prevItem.id}`,
+          { targetId: prevItem.id }
+        );
+
+        if (this.isDestroyed) return;
+        this.navigator?.replaceTop?.(prevItem);
+      }
+    } catch (error) {
+      log_error("goPrevious: could not navigate to previous entry", { error });
+    } finally {
+      this.isNavigating = false;
+    }
+  }
+
+  public destroy(): void {
+    this.isDestroyed = true;
+    this.recalculateGeneration++;
+
+    if (this.unsubscribeQueueListener) {
+      this.unsubscribeQueueListener();
+      this.unsubscribeQueueListener = null;
+    }
+
+    this.hasNext$.complete();
+    this.hasPrevious$.complete();
+  }
+}

package/src/Player/AudioLayer/SleepTimerManager.ts

@@ -41,6 +41,10 @@ export class SleepTimerController {
     return this.sleepTimerStateSubject.asObservable();
   }
 
+  get currentState(): SleepTimerState {
+    return this.sleepTimerStateSubject.getValue();
+  }
+
   private async scheduleSleep(sleepDate): Promise<boolean> {
     log_debug(`Setting sleep interval to ${sleepDate}`);
 
@@ -118,7 +122,7 @@ export class SleepTimerController {
 
     log_debug("Sleep state restored");
 
-    this.setSleepTimer(item as SleepTimer, futureSleepDate);
+    await this.setSleepTimer(item as SleepTimer, futureSleepDate);
   }
 
   // Will be called if user closed the player explicitly.

package/src/Player/AudioLayer/SpeedManager.ts

@@ -33,6 +33,10 @@ export class SpeedController {
     return this.playbackSpeedSubject.asObservable();
   }
 
+  get currentSpeed(): PlaybackSpeed {
+    return this.playbackSpeedSubject.getValue();
+  }
+
   async loadSpeed() {
     const speed = await localStorage.getItem(SPEED_PREFERENCE_KEY, NAMESPACE);
 

package/src/Player/AudioLayer/__tests__/AudioDescription.test.tsx

@@ -0,0 +1,147 @@
+import React from "react";
+import { StyleSheet } from "react-native";
+import { render } from "@testing-library/react-native";
+
+import { AudioDescription } from "../AudioDescription";
+
+// `title`/`summary` come from the player manager's content channel rather than
+// from props or context, so the hook is mocked here. Read lazily inside the
+// factory: `jest.mock` is hoisted above the `let`, so capturing eagerly would
+// freeze it at `undefined`.
+let mockContent: {
+  title: Option<string | number>;
+  summary: Option<string | number>;
+} = { title: "A Title", summary: "A Summary" };
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayerContent",
+  () => ({ usePlayerContent: () => mockContent })
+);
+
+beforeEach(() => {
+  mockContent = { title: "A Title", summary: "A Summary" };
+});
+
+const layoutState = { inline: false, docked: false, isModal: true };
+
+const valueFrom =
+  (config: Record<string, unknown>): GetValue =>
+  (key: string) =>
+    (config[key] ?? null) as never;
+
+const renderDescription = (
+  config: Record<string, unknown>,
+  state = layoutState
+) =>
+  render(
+    <AudioDescription
+      layoutState={state}
+      value={valueFrom(config)}
+      maxWidth={400}
+    />
+  );
+
+// The wrapper's style prop is an array, so flatten before reading height.
+const wrapperHeight = (tree) =>
+  StyleSheet.flatten(tree.toJSON().props.style).height;
+
+describe("AudioDescription", () => {
+  it("renders both texts when both toggles are on", () => {
+    const { queryByText } = renderDescription({ title: true, subtitle: true });
+
+    expect(queryByText("A Title")).toBeTruthy();
+    expect(queryByText("A Summary")).toBeTruthy();
+  });
+
+  it("hides the title when the title toggle is off", () => {
+    const { queryByText } = renderDescription({ title: false, subtitle: true });
+
+    expect(queryByText("A Title")).toBeNull();
+    expect(queryByText("A Summary")).toBeTruthy();
+  });
+
+  it("hides the summary when the subtitle toggle is off", () => {
+    const { queryByText } = renderDescription({ title: true, subtitle: false });
+
+    expect(queryByText("A Title")).toBeTruthy();
+    expect(queryByText("A Summary")).toBeNull();
+  });
+
+  it("renders neither text when both toggles are off", () => {
+    const { queryByText } = renderDescription({
+      title: false,
+      subtitle: false,
+    });
+
+    expect(queryByText("A Title")).toBeNull();
+    expect(queryByText("A Summary")).toBeNull();
+  });
+
+  it("reserves no height when both toggles are off", () => {
+    const tree = renderDescription({ title: false, subtitle: false });
+
+    expect(wrapperHeight(tree)).toBe(0);
+  });
+
+  it("reserves less height when the title is hidden than when it is shown", () => {
+    const withTitle = renderDescription({ title: true, subtitle: true });
+    const withoutTitle = renderDescription({ title: false, subtitle: true });
+
+    expect(wrapperHeight(withoutTitle)).toBeLessThan(wrapperHeight(withTitle));
+  });
+
+  it("reserves less height when the subtitle is hidden than when it is shown", () => {
+    const withSubtitle = renderDescription({ title: true, subtitle: true });
+    const withoutSubtitle = renderDescription({ title: true, subtitle: false });
+
+    expect(wrapperHeight(withoutSubtitle)).toBeLessThan(
+      wrapperHeight(withSubtitle)
+    );
+  });
+
+  it("reads the docked toggle keys when docked", () => {
+    const { queryByText } = renderDescription(
+      { docked_player_title: true, docked_player_subtitle: false },
+      { ...layoutState, docked: true }
+    );
+
+    expect(queryByText("A Title")).toBeTruthy();
+    expect(queryByText("A Summary")).toBeNull();
+  });
+
+  /**
+   * Live audio resolves its text asynchronously: the channel feed is polled
+   * after playback starts, so the first render has no programme title yet. The
+   * row must hold its place across that transition instead of collapsing and
+   * expanding a second later.
+   */
+  describe("layout stability while the text is still missing", () => {
+    it("reserves the same height with and without text", () => {
+      const withText = renderDescription({ title: true, subtitle: true });
+
+      mockContent = { title: null, summary: null };
+
+      const withoutText = renderDescription({ title: true, subtitle: true });
+
+      expect(wrapperHeight(withoutText)).toBe(wrapperHeight(withText));
+    });
+
+    it("still renders both rows when the text has not arrived", () => {
+      mockContent = { title: null, summary: null };
+
+      const tree = renderDescription({ title: true, subtitle: true });
+
+      expect(wrapperHeight(tree)).toBeGreaterThan(0);
+    });
+
+    it("reserves height for the summary even when only the summary is missing", () => {
+      const withSummary = renderDescription({ title: true, subtitle: true });
+
+      mockContent = { title: "A Title", summary: null };
+
+      const withoutSummary = renderDescription({ title: true, subtitle: true });
+
+      expect(wrapperHeight(withoutSummary)).toBe(wrapperHeight(withSummary));
+    });
+  });
+});

package/src/Player/AudioLayer/__tests__/AudioPlayerWrapper.test.tsx

@@ -0,0 +1,130 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+
+/**
+ * Covers AudioPlayerWrapper's remaining Title/Subtitle responsibility, which is
+ * only lifecycle: keep the manager's live-content polling running while this
+ * player is mounted. It carries neither the text (consumers read it from the
+ * player manager via `usePlayerContent`) nor any decision about the polling -
+ * whether the content is live, where the channel's programme feed lives and
+ * how often to poll are all `OverlaysObserver`'s.
+ *
+ * The rest of the chain is covered where each link lives:
+ *   - is-live / feed url / interval           OverlayObserver/__tests__/liveContent.test.ts
+ *   - polling -> `observer.liveEntry`         OverlayObserver/__tests__/liveContent.test.ts
+ *   - liveEntry -> published content          playerManager/__tests__/playerContent.test.ts
+ *   - published content -> rendered text      AudioLayer/__tests__/AudioDescription.test.tsx
+ */
+
+const mockStartLiveContentUpdates = jest.fn();
+const mockStopLiveContentUpdates = jest.fn();
+
+const mockPlayer = {
+  getOverlayObservable: () => ({
+    startLiveContentUpdates: mockStartLiveContentUpdates,
+    stopLiveContentUpdates: mockStopLiveContentUpdates,
+  }),
+  addListener: jest.fn(() => jest.fn()),
+  play: jest.fn(),
+  pause: jest.fn(),
+  rewind: jest.fn(),
+  forward: jest.fn(),
+};
+
+let mockIsLive = false;
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer",
+  () => ({ usePlayer: () => mockPlayer })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayerState",
+  () => ({
+    usePlayerState: () => ({
+      isLive: mockIsLive,
+      seekableDuration: 0,
+      isReadyToPlay: false,
+      isBuffering: false,
+      isPaused: false,
+    }),
+  })
+);
+
+jest.mock("@applicaster/zapp-react-native-utils/appUtils", () => ({
+  playerManager: {
+    close: jest.fn(),
+    isCasting: jest.fn(() => false),
+  },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
+  useNavigation: jest.fn(() => ({ maximiseVideoModal: jest.fn() })),
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/modalState", () => ({
+  useModalStoreState: jest.fn(() => ({ visible: false })),
+  dismissModal: jest.fn(),
+  openBottomSheetModal: jest.fn(),
+}));
+
+jest.mock("../Layout", () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+import { AudioPlayerWrapper } from "../AudioPlayerWrapper";
+
+const LIVE_ENTRY = {
+  id: "entry-1",
+  title: "Channel Title",
+  summary: "Channel Summary",
+  extensions: {
+    live: { channel_src: "https://feed.test/subClass/audio" },
+  },
+} as any;
+
+const baseProps = {
+  configuration: { audio_live_player_update_interval: 30 },
+  style: { width: 100, height: 100 } as any,
+  entry: LIVE_ENTRY,
+  layoutState: { inline: false, docked: false, isModal: false, pip: false },
+  playNextData: null,
+  children: null,
+};
+
+describe("AudioPlayerWrapper live content polling", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockIsLive = true;
+  });
+
+  it("asks the observer to keep live content fresh while mounted", () => {
+    render(<AudioPlayerWrapper {...baseProps} />);
+
+    expect(mockStartLiveContentUpdates).toHaveBeenCalled();
+  });
+
+  it("stops polling on unmount", () => {
+    const { unmount } = render(<AudioPlayerWrapper {...baseProps} />);
+
+    unmount();
+
+    expect(mockStopLiveContentUpdates).toHaveBeenCalled();
+  });
+
+  it("re-evaluates when the player reports the content is live", () => {
+    // `isLive` is unknown until the player loads, so the effect has to run
+    // again once it settles - the observer decides what to do with it.
+    mockIsLive = false;
+
+    const { rerender } = render(<AudioPlayerWrapper {...baseProps} />);
+
+    mockStartLiveContentUpdates.mockClear();
+    mockIsLive = true;
+
+    rerender(<AudioPlayerWrapper {...baseProps} />);
+
+    expect(mockStartLiveContentUpdates).toHaveBeenCalled();
+  });
+});