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

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -2,9 +2,8 @@ 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 { getPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
 import {
-  findPluginByIdentifier,
   loadFeedEntry,
   loadFeedAndPrefetchThumbnailImage,
   parseTimeToSeconds,
@@ -19,6 +18,12 @@ export const { log_verbose, log_debug, log_info, log_error } = createLogger({
   parent: utilsLogger,
 });
 
+/**
+ * Mirrors `initial_value` for `audio_live_player_update_interval` in
+ * `defaultManifestConfigurations/player.js`.
+ */
+const DEFAULT_LIVE_CONTENT_UPDATE_INTERVAL_SECONDS = 60;
+
 type ChapterMarkerOriginal = {
   id: string;
   title: string;
@@ -40,11 +45,6 @@ export type LiveMetadataConfig = {
   updateInterval: number;
 };
 
-export type TitleSummaryEvent = {
-  title: string | number;
-  summary: string | number;
-};
-
 type ChapterMarkersObserverProps = {
   player: Player;
 };
@@ -66,11 +66,9 @@ export class OverlaysObserver {
   readonly chapterSubject: BehaviorSubject<ChapterMarkerEvent>;
   private playNextSubject: BehaviorSubject<PlayNextState>;
   private liveMetadataSubject: BehaviorSubject<LiveMetadataEvent>;
-  private titleSummarySubject: BehaviorSubject<TitleSummaryEvent>;
-  private feedUrl: string;
-  private reloadData: () => void;
-  private updateTitleAndDescription: (data: any) => void;
-  private feedDataInterval: any;
+  private liveContentInterval: any;
+  private liveContentGeneration = 0;
+  private _liveEntry: ZappEntry | null = null;
   private liveMetadataUpdateInterval: any;
   private releasePlayerObserver?: () => void;
   readonly entry: ZappEntry;
@@ -86,41 +84,140 @@ export class OverlaysObserver {
     this.player = player;
     this.entry = player.getEntry();
 
-    this.titleSummarySubject = new BehaviorSubject<TitleSummaryEvent>({
-      title: this.entry?.title || "",
-      summary: this.entry?.summary || "",
-    });
-
     this.liveMetadataSubject = new BehaviorSubject<LiveMetadataEvent>(
       this.entry?.extensions?.liveMetadata || null
     );
 
     this.chapterMarkerEvents = this.prepareChapterMarkers();
     this.releasePlayerObserver = this.subscribeToPlayerEvents();
-    this.feedUrl = "";
-    this.reloadData = () => {};
-    this.updateTitleAndDescription = () => {};
-    this.feedDataInterval = null;
+    this.liveContentInterval = null;
     this.liveMetadataUpdateInterval = null;
     void this.preparePlayNext();
     void this.prepareLiveMetadata();
   }
 
-  private setupFeedDataInterval(interval: number) {
-    if (this.feedUrl && this.reloadData && this.updateTitleAndDescription) {
-      this.feedDataInterval = setInterval(() => {
-        this.reloadData();
-      }, interval * 1000);
+  /**
+   * Polls the live feed and pushes each loaded entry into the player, which
+   * re-resolves its Title/Subtitle and publishes on its content channel.
+   *
+   * Runs entirely outside React: `loadFeedEntry` builds its request through
+   * `RequestBuilder.setUrl`, which inflates URL macros with the entry and
+   * screen contexts, so no `useInflatedUrl` is needed. `prepareLiveMetadata`
+   * below already polls this way.
+   */
+  public startLiveContentUpdates() {
+    this.stopLiveContentUpdates();
+
+    if (!this.player?.isLive?.()) {
+      log_debug("startLiveContentUpdates: Player is not live. Skipping...");
+
+      return;
+    }
+
+    const feedUrl = this.getLiveContentFeedUrl();
+
+    if (!feedUrl) {
+      log_debug(
+        "startLiveContentUpdates: Entry carries no live channel feed. Skipping..."
+      );
+
+      return;
     }
+
+    const intervalSeconds = this.getLiveContentUpdateInterval();
+
+    // Clearing the interval cannot cancel a request already in flight, so each
+    // run carries the generation it started in. A response that arrives after
+    // a stop or a restart belongs to a channel that is no longer playing and
+    // is dropped, rather than publishing the previous programme's title over
+    // the current one.
+    const generation = ++this.liveContentGeneration;
+
+    const load = async () => {
+      try {
+        const entry = await loadFeedEntry(feedUrl, this.entry);
+
+        if (generation !== this.liveContentGeneration) {
+          return;
+        }
+
+        this._liveEntry = entry;
+        this.player.publishContent();
+      } catch {
+        // `loadFeedEntry` already logs the failure. Keep whatever content is
+        // currently published rather than blanking the title on a transient
+        // network error.
+      }
+    };
+
+    void load();
+
+    this.liveContentInterval = setInterval(load, intervalSeconds * 1000);
   }
 
-  public clearFeedDataInterval() {
-    if (this.feedDataInterval) {
-      clearInterval(this.feedDataInterval);
-      this.feedDataInterval = null;
+  public stopLiveContentUpdates() {
+    // Invalidates any in-flight request as well as the interval.
+    this.liveContentGeneration += 1;
+
+    if (this.liveContentInterval) {
+      clearInterval(this.liveContentInterval);
+      this.liveContentInterval = null;
     }
   }
 
+  /**
+   * The programme feed for the channel currently playing. Derived here rather
+   * than by the caller so no UI component needs to know where a live channel
+   * keeps its feed, or that the URL has to be rewritten to reach the
+   * programme ("livePage") view of it.
+   */
+  private getLiveContentFeedUrl(): string {
+    const channelSrc =
+      this.player.getEntry()?.extensions?.live?.channel_src ?? "";
+
+    return channelSrc.replace(new RegExp("subClass", "g"), "livePage");
+  }
+
+  /**
+   * Falls back to the manifest's own `initial_value` when the app ships no
+   * value: `intervalSeconds * 1000` would otherwise be `NaN`, and
+   * `setInterval` treats `NaN` as `0` - a tight loop hammering the feed.
+   */
+  private getLiveContentUpdateInterval(): number {
+    const configured =
+      this.player.getPluginConfiguration()?.audio_live_player_update_interval;
+
+    const seconds = Number(configured);
+
+    return Number.isFinite(seconds) && seconds > 0
+      ? seconds
+      : DEFAULT_LIVE_CONTENT_UPDATE_INTERVAL_SECONDS;
+  }
+
+  /**
+   * The entry most recently loaded from the live channel feed - the programme
+   * currently on air, as opposed to `player.entry`, which is the channel and
+   * stays put for the whole listening session.
+   *
+   * Read by `Player.getContent()`, which prefers it over the player's own
+   * entry. It lives here rather than on `Player` because it is live-feed
+   * state, like `liveMetadata` and play-next: a VOD or cast player never has
+   * an observer at all, so it never carries this either.
+   */
+  public get liveEntry(): ZappEntry | null {
+    return this._liveEntry;
+  }
+
+  /**
+   * Called by `Player`'s `entry` setter. The live entry is an overlay on the
+   * current entry, so its lifetime is scoped to that entry: without this, a
+   * programme from a previous channel would shadow the new one forever - the
+   * content would change but the title would not.
+   */
+  public clearLiveEntry() {
+    this._liveEntry = null;
+  }
+
   public clearLiveMetadataUpdateInterval() {
     if (this.liveMetadataUpdateInterval) {
       clearInterval(this.liveMetadataUpdateInterval);
@@ -128,22 +225,6 @@ export class OverlaysObserver {
     }
   }
 
-  public setFeedDataHandlers(
-    feedUrl: string,
-    reloadData: () => void,
-    interval: number,
-    updateTitleAndDescription: (data: any) => void
-  ) {
-    this.feedUrl = feedUrl;
-    this.reloadData = reloadData;
-    this.updateTitleAndDescription = updateTitleAndDescription;
-    this.setupFeedDataInterval(interval);
-  }
-
-  public getTitleSummaryObservable(): Observable<TitleSummaryEvent> {
-    return this.titleSummarySubject.asObservable().pipe(distinctUntilChanged());
-  }
-
   hidePlayNext = () => {
     this.isPlayNextSuppressed = true;
     this.playNextSubject.next(null);
@@ -155,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) {
@@ -170,7 +248,7 @@ export class OverlaysObserver {
         return;
       }
 
-      const playNextFeedUrl: string = retrieveFeedUrl(this.entry);
+      const playNextFeedUrl: string = await retrieveFeedUrl(this.entry);
 
       if (!playNextFeedUrl || typeof playNextFeedUrl !== "string") {
         log_debug(
@@ -395,9 +473,8 @@ export class OverlaysObserver {
     this.chapterSubject.complete();
     this.playNextSubject.complete();
     this.liveMetadataSubject.complete();
-    this.titleSummarySubject.complete();
     this.releasePlayerObserver?.();
-    this.clearFeedDataInterval();
+    this.stopLiveContentUpdates();
     this.clearLiveMetadataUpdateInterval();
     this.releasePlayerObserver = null;
   };

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

@@ -0,0 +1,205 @@
+import { OverlaysObserver } from "../OverlaysObserver";
+import { loadFeedEntry } from "../utils";
+
+jest.mock("../utils", () => ({
+  ...jest.requireActual("../utils"),
+  loadFeedEntry: jest.fn(),
+}));
+
+const FEED_ENTRY = { title: "Programme One" } as unknown as ZappEntry;
+
+const CHANNEL_ENTRY = {
+  title: "Channel",
+  extensions: { live: { channel_src: "https://feed.test/subClass/audio" } },
+} as unknown as ZappEntry;
+
+const makePlayer = ({
+  isLive = true,
+  entry = CHANNEL_ENTRY,
+  configuration = { audio_live_player_update_interval: 30 },
+}: {
+  isLive?: boolean;
+  entry?: ZappEntry;
+  configuration?: Record<string, any>;
+} = {}) => ({
+  isLive: () => isLive,
+  getEntry: () => entry,
+  getPluginConfiguration: () => configuration,
+  publishContent: jest.fn(),
+  addListener: jest.fn(() => () => {}),
+  removeListener: jest.fn(),
+});
+
+describe("OverlaysObserver live content", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    (loadFeedEntry as jest.Mock).mockReset();
+    (loadFeedEntry as jest.Mock).mockResolvedValue(FEED_ENTRY);
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it("stores the loaded programme and asks the player to republish", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observer.liveEntry).toBe(FEED_ENTRY);
+    expect(player.publishContent).toHaveBeenCalled();
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("clears the stored programme on clearLiveEntry", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    observer.clearLiveEntry();
+
+    expect(observer.liveEntry).toBeNull();
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("reloads on the configured interval", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+
+    (loadFeedEntry as jest.Mock).mockClear();
+
+    jest.advanceTimersByTime(30_000);
+
+    expect(loadFeedEntry).toHaveBeenCalledTimes(1);
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("stops polling after stopLiveContentUpdates", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+
+    observer.stopLiveContentUpdates();
+
+    (loadFeedEntry as jest.Mock).mockClear();
+
+    jest.advanceTimersByTime(90_000);
+
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+  });
+
+  it("keeps the previous content when a poll fails", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    (loadFeedEntry as jest.Mock).mockRejectedValue(new Error("network"));
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observer.liveEntry).toBeNull();
+    expect(player.publishContent).not.toHaveBeenCalled();
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("drops a response that arrives after polling was stopped", async () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    let resolveLoad: (entry: ZappEntry) => void;
+
+    (loadFeedEntry as jest.Mock).mockReturnValue(
+      new Promise<ZappEntry>((resolve) => {
+        resolveLoad = resolve;
+      })
+    );
+
+    observer.startLiveContentUpdates();
+    observer.stopLiveContentUpdates();
+
+    // The request was already in flight when polling stopped: clearing the
+    // interval cannot cancel it, so its result must be ignored rather than
+    // published over whatever is playing now.
+    resolveLoad(FEED_ENTRY);
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(observer.liveEntry).toBeNull();
+    expect(player.publishContent).not.toHaveBeenCalled();
+  });
+
+  it("does not start polling when the entry carries no live channel feed", () => {
+    const player = makePlayer({ entry: { title: "No Feed" } as ZappEntry });
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+  });
+
+  it("does not start polling for on-demand content", () => {
+    const player = makePlayer({ isLive: false });
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+  });
+
+  it("rewrites the channel url to reach the programme feed", () => {
+    const player = makePlayer();
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    expect(loadFeedEntry).toHaveBeenCalledWith(
+      "https://feed.test/livePage/audio",
+      expect.anything()
+    );
+
+    observer.stopLiveContentUpdates();
+  });
+
+  it("falls back to the manifest default interval when none is configured", async () => {
+    // An unset value would make `intervalSeconds * 1000` NaN, and setInterval
+    // treats NaN as 0 - a tight loop hammering the feed.
+    const player = makePlayer({ configuration: {} });
+    const observer = new OverlaysObserver({ player } as any);
+
+    observer.startLiveContentUpdates();
+
+    await Promise.resolve();
+
+    (loadFeedEntry as jest.Mock).mockClear();
+
+    jest.advanceTimersByTime(59_000);
+    expect(loadFeedEntry).not.toHaveBeenCalled();
+
+    jest.advanceTimersByTime(1_000);
+    expect(loadFeedEntry).toHaveBeenCalledTimes(1);
+
+    observer.stopLiveContentUpdates();
+  });
+});

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

@@ -0,0 +1,56 @@
+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;
+
+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(
+      "https://feeds/next.json"
+    );
+  });
+
+  it("resolves to null for a missing entry", async () => {
+    await expect(
+      retrieveFeedUrl(undefined as unknown as ZappEntry)
+    ).resolves.toBeNull();
+  });
+
+  it("returns the previous feed url when present", () => {
+    const entry = entryWith({
+      play_previous_feed_url: "https://feeds/prev.json",
+    });
+
+    expect(retrievePlayPreviousFeedUrl(entry)).toBe("https://feeds/prev.json");
+  });
+
+  it("returns undefined when only the next url is present", () => {
+    const entry = entryWith({ play_next_feed_url: "https://feeds/next.json" });
+
+    expect(retrievePlayPreviousFeedUrl(entry)).toBeUndefined();
+  });
+
+  it("returns undefined for an entry with no extensions", () => {
+    expect(
+      retrievePlayPreviousFeedUrl({
+        id: "1",
+        type: { value: "video" },
+      } as ZappEntry)
+    ).toBeUndefined();
+  });
+
+  it("returns undefined for a missing entry", () => {
+    expect(
+      retrievePlayPreviousFeedUrl(undefined as unknown as ZappEntry)
+    ).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,4 @@
+/** `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

@@ -0,0 +1,4 @@
+/** `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

@@ -0,0 +1,24 @@
+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

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