@applicaster/zapp-react-native-utils 16.0.0-rc.7 → 16.0.0-rc.70

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,49 @@
+import { retrieveFeedUrl, retrievePlayPreviousFeedUrl } from "../utils";
+
+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,11 @@
+export const getUpcomingQueue = async (
+  plugin?: QuickBrickPlugin | ZappPlugin
+): Promise<unknown[] | null> => {
+  const QueueManager = (plugin as any)?.module?.QueueManager;
+
+  if (!QueueManager?.instance) {
+    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;

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -3,10 +3,13 @@ import {
   PipesClientResponseHelper,
   RequestBuilder,
 } from "@applicaster/zapp-pipes-v2-client";
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { log_error, log_info } from "./OverlaysObserver";
-import * as R from "ramda";
 import { toNumber, toNumberWithDefault } from "../../../numberUtils";
 
+import { findPluginByIdentifier } from "../../../pluginUtils";
+import { getUpcomingQueue } from "./getUpcomingQueue";
+
 export const parseTimeToSeconds = (timeStr: string): number => {
   const validationError = new Error("Invalid time format");
 
@@ -40,11 +43,58 @@ export const parseTimeToSeconds = (timeStr: string): number => {
   }
 };
 
-export const retrieveFeedUrl = (entry: ZappEntry) =>
-  entry?.extensions?.play_next_feed_url;
+/**
+ * HACK / TEMPORARY WORKAROUND:
+ * Resolves the play_next_feed_url dynamically for OverlaysObserver.
+ *
+ * WHY THIS IS HACKED HERE:
+ * OverlaysObserver was originally designed as a Recommendation Overlay engine (fetching static
+ * play_next_feed_url for overlay UI visuals). However, for dynamic queue & continuous audio playback,
+ * modifying feeds via `decorateFeed` at load time doesn't work (due to feed caching and mid-playback queue mutations).
+ * To avoid mutating feed payloads across the app, we temporarily intercept play_next_feed_url here
+ * at runtime to check if QueueManager has active/upcoming queue items.
+ *
+ * FUTURE ARCHITECTURE / TODO:
+ * Move queue/playlist resolution into a dedicated Player/Queue Provider module (or Handler Chain)
+ * 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> => {
+  if (!entry) return null;
+
+  const availablePlugins = plugins || appStore.get("plugins");
+
+  const queuePlugin = findPluginByIdentifier(
+    "queue-action",
+    availablePlugins,
+    true
+  );
+
+  if (queuePlugin) {
+    try {
+      const upcomingQueue = await getUpcomingQueue(queuePlugin);
+
+      if (upcomingQueue && upcomingQueue.length > 0) {
+        const queueItemId = entry?.extensions?.queueItemId || entry?.id;
+
+        return `pipesv2://queue-action/play-next?queueItemId=${queueItemId}`;
+      }
+    } catch (e) {
+      log_error("retrieveFeedUrl: Failed to resolve QueueManager", e);
+    }
+  }
+
+  return entry?.extensions?.play_next_feed_url;
+};
+
+export const retrievePlayPreviousFeedUrl = (entry: ZappEntry) =>
+  entry?.extensions?.play_previous_feed_url;
 
 export const retrieveOverlayDuration = (plugin) =>
-  toNumberWithDefault(plugin?.configuration?.overlay_duration, 15);
+  toNumberWithDefault(15, plugin?.configuration?.overlay_duration);
 
 export const retrieveOverlayTriggerOffset = (item: ZappEntry) => {
   return item && item.extensions && item.extensions.overlay_timestamp
@@ -150,19 +200,3 @@ export const loadFeedAndPrefetchThumbnailImage = async (
 
   return playNextEntry;
 };
-
-export const findPluginByIdentifier = (
-  identifier: string,
-  plugins: ZappPlugin[]
-): ZappPlugin => {
-  if (!identifier) {
-    return undefined;
-  }
-
-  const plugin = R.compose(
-    R.find(R.propEq("identifier", identifier)),
-    R.values
-  )(plugins);
-
-  return plugin;
-};