@applicaster/zapp-react-native-utils 16.0.0-rc.6 → 16.0.0-rc.60

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -3,10 +3,12 @@ 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";
+
 export const parseTimeToSeconds = (timeStr: string): number => {
   const validationError = new Error("Invalid time format");
 
@@ -40,11 +42,54 @@ 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);
+
+  if (queuePlugin) {
+    try {
+      const { QueueManager } = require("@applicaster/queue-action/src/Manager");
+      const upcomingQueue = await QueueManager.instance.getUpcomingQueue();
+
+      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 +195,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;
-};

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

@@ -0,0 +1,403 @@
+import { Player } from "../player";
+import { isTV } from "../../../reactUtils";
+
+jest.mock("../../../reactUtils", () => ({
+  ...jest.requireActual("../../../reactUtils"),
+  isTV: jest.fn(() => false),
+}));
+
+const mockIsTV = isTV as jest.Mock;
+
+const ENTRY = {
+  title: "Entry Title",
+  summary: "Entry Summary",
+  extensions: { programme: "Programme Title" },
+} as unknown as ZappEntry;
+
+const LIVE_ENTRY = {
+  title: "Live Title",
+  summary: "Live Summary",
+} as unknown as ZappEntry;
+
+const makePlayer = (configuration: Record<string, any> | null = null) => {
+  const player = new Player({ playerId: "test-player" });
+
+  player.getPluginConfiguration = () => configuration;
+
+  return player;
+};
+
+describe("Player content channel", () => {
+  beforeEach(() => {
+    mockIsTV.mockReturnValue(false);
+  });
+
+  it("resolves the entry fields when nothing is configured", () => {
+    const player = makePlayer();
+
+    player.entry = ENTRY;
+
+    expect(player.getContent()).toEqual({
+      title: "Entry Title",
+      summary: "Entry Summary",
+    });
+  });
+
+  it("resolves a configured custom data key", () => {
+    const player = makePlayer({
+      title_data_key_source: "other",
+      title_custom_data_key: "extensions.programme",
+    });
+
+    player.entry = ENTRY;
+
+    expect(player.getContent().title).toBe("Programme Title");
+  });
+
+  it("falls back to the entry field when the configured key is unresolvable", () => {
+    const player = makePlayer({
+      title_data_key_source: "other",
+      title_custom_data_key: "extensions.nope",
+    });
+
+    player.entry = ENTRY;
+
+    expect(player.getContent().title).toBe("Entry Title");
+  });
+
+  it("emits the resolved content to subscribers when the entry changes", () => {
+    const player = makePlayer();
+    const received: any[] = [];
+
+    player
+      .getContentObservable()
+      .subscribe((content) => received.push(content));
+
+    player.entry = ENTRY;
+
+    expect(received[received.length - 1]).toEqual({
+      title: "Entry Title",
+      summary: "Entry Summary",
+    });
+  });
+
+  it("seeds subscribers with resolved content, never the raw entry", () => {
+    const player = makePlayer({
+      title_data_key_source: "other",
+      title_custom_data_key: "extensions.programme",
+    });
+
+    player.entry = ENTRY;
+
+    const received: any[] = [];
+
+    player
+      .getContentObservable()
+      .subscribe((content) => received.push(content));
+
+    expect(received[0].title).toBe("Programme Title");
+  });
+
+  // The live entry lives on `OverlaysObserver`, not on the player, so these
+  // stub the observer rather than constructing a real one (whose constructor
+  // pulls in chapter markers, play-next and the plugin store). What is under
+  // test here is only how `getContent` and the `entry` setter treat it; the
+  // observer's own side - loading the feed and storing the result - is
+  // covered in `OverlayObserver/__tests__/liveContent.test.ts`.
+  const withLiveEntry = (player: Player, liveEntry: ZappEntry | null) => {
+    (player as any).overlaysObserver = {
+      liveEntry,
+      clearLiveEntry() {
+        this.liveEntry = null;
+      },
+    };
+  };
+
+  it("prefers the observer's live entry over the player entry", () => {
+    const player = makePlayer();
+
+    player.entry = ENTRY;
+    withLiveEntry(player, LIVE_ENTRY);
+
+    expect(player.getContent()).toEqual({
+      title: "Live Title",
+      summary: "Live Summary",
+    });
+  });
+
+  it("clears the live entry when a new entry is set", () => {
+    const player = makePlayer();
+
+    player.entry = ENTRY;
+    withLiveEntry(player, LIVE_ENTRY);
+    player.entry = ENTRY;
+
+    expect(player.getContent().title).toBe("Entry Title");
+  });
+
+  it("falls through to the player entry when there is no observer at all", () => {
+    const player = makePlayer();
+
+    player.entry = ENTRY;
+
+    expect((player as any).overlaysObserver).toBeFalsy();
+    expect(player.getContent().title).toBe("Entry Title");
+  });
+
+  it("resolves the cover image from the entry's media group", () => {
+    const player = makePlayer();
+
+    player.entry = {
+      title: "Entry Title",
+      media_group: [
+        {
+          type: "image",
+          media_item: [
+            { key: "image_other", src: "https://img.test/other.jpg" },
+            { key: "image_base", src: "https://img.test/base.jpg" },
+          ],
+        },
+      ],
+    } as unknown as ZappEntry;
+
+    expect(player.getContent().imageUrl).toBe("https://img.test/base.jpg");
+  });
+
+  it("falls back to the first media item when there is no image_base", () => {
+    const player = makePlayer();
+
+    player.entry = {
+      title: "Entry Title",
+      media_group: [
+        {
+          type: "image",
+          media_item: [
+            { key: "image_other", src: "https://img.test/other.jpg" },
+          ],
+        },
+      ],
+    } as unknown as ZappEntry;
+
+    expect(player.getContent().imageUrl).toBe("https://img.test/other.jpg");
+  });
+
+  it("has no image when the entry carries no media group", () => {
+    const player = makePlayer();
+
+    player.entry = ENTRY;
+
+    expect(player.getContent().imageUrl).toBeUndefined();
+  });
+
+  it("takes the cover image from the live entry, not the channel", () => {
+    // The programme's own artwork has to travel with its title - otherwise the
+    // lock screen would keep showing the channel's cover all day.
+    const player = makePlayer();
+
+    player.entry = {
+      title: "Channel",
+      media_group: [
+        {
+          type: "image",
+          media_item: [
+            { key: "image_base", src: "https://img.test/channel.jpg" },
+          ],
+        },
+      ],
+    } as unknown as ZappEntry;
+
+    withLiveEntry(player, {
+      title: "Programme",
+      media_group: [
+        {
+          type: "image",
+          media_item: [
+            { key: "image_base", src: "https://img.test/programme.jpg" },
+          ],
+        },
+      ],
+    } as unknown as ZappEntry);
+
+    expect(player.getContent().imageUrl).toBe("https://img.test/programme.jpg");
+  });
+
+  it("publishes the observer's live entry to subscribers", () => {
+    const player = makePlayer();
+    const received: any[] = [];
+
+    player.entry = ENTRY;
+
+    player
+      .getContentObservable()
+      .subscribe((content) => received.push(content));
+
+    withLiveEntry(player, LIVE_ENTRY);
+    player.publishContent();
+
+    expect(received[received.length - 1].title).toBe("Live Title");
+  });
+
+  it("does not resolve while no subscriber exists", () => {
+    const player = makePlayer();
+    const getConfiguration = jest.fn(() => null);
+
+    player.getPluginConfiguration = getConfiguration;
+    player.entry = ENTRY;
+
+    expect(getConfiguration).not.toHaveBeenCalled();
+  });
+});
+
+/**
+ * Which Studio key set backs the resolution is decided inside `getContent()`
+ * (via `getPlayerContentDataKeys`). Getting it wrong would make one platform
+ * or content type read another's Studio configuration, so each combination is
+ * pinned here - including the negative cases that prove the sets never cross.
+ *
+ * These moved here from `PlayerContainer.test.tsx` when the resolution moved
+ * out of the React tree and into the player; the assertions are unchanged.
+ */
+describe("Player content channel: key-set selection", () => {
+  const VIDEO_ENTRY = {
+    id: "video-entry",
+    title: "Entry Title",
+    summary: "Entry Summary",
+    content: { src: "https://example.com/video.m3u8" },
+    extensions: { customTitleKey: "Custom Title From Extensions" },
+  } as unknown as ZappEntry;
+
+  const AUDIO_ENTRY = {
+    id: "audio-entry",
+    title: "Entry Title",
+    summary: "Entry Summary",
+    content: { type: "audio", src: "https://example.com/audio.m3u8" },
+    extensions: { customTitleKey: "Custom Audio Title From Extensions" },
+  } as unknown as ZappEntry;
+
+  const contentFor = (
+    entry: ZappEntry,
+    configuration: Record<string, any> | null
+  ) => {
+    const player = makePlayer(configuration);
+
+    player.entry = entry;
+
+    return player.getContent();
+  };
+
+  describe("TV video", () => {
+    beforeEach(() => mockIsTV.mockReturnValue(true));
+
+    it("resolves the TV video override to the configured extensions key", () => {
+      const content = contentFor(VIDEO_ENTRY, {
+        video_player_title_data_key_source: "other",
+        video_player_title_custom_data_key: "extensions.customTitleKey",
+      });
+
+      expect(content.title).toBe("Custom Title From Extensions");
+      // summary was not overridden, so it keeps falling back to entry.summary.
+      expect(content.summary).toBe("Entry Summary");
+    });
+
+    it("falls back to the entry title when the configured key does not resolve", () => {
+      const content = contentFor(VIDEO_ENTRY, {
+        video_player_title_data_key_source: "other",
+        video_player_title_custom_data_key: "extensions.doesNotExist",
+      });
+
+      expect(content.title).toBe("Entry Title");
+    });
+
+    it("ignores mobile configuration", () => {
+      const content = contentFor(VIDEO_ENTRY, {
+        title_data_key_source: "other",
+        title_custom_data_key: "extensions.customTitleKey",
+      });
+
+      expect(content.title).toBe("Entry Title");
+    });
+
+    it("reads the TV video key set, not the mobile one, when both are configured", () => {
+      const content = contentFor(VIDEO_ENTRY, {
+        video_player_title_data_key_source: "other",
+        video_player_title_custom_data_key: "extensions.customTitleKey",
+        // A mobile key is also configured, to prove the TV branch ignores it.
+        title_data_key_source: "other",
+        title_custom_data_key: "extensions.doesNotExist",
+      });
+
+      expect(content.title).toBe("Custom Title From Extensions");
+    });
+
+    it("passes the entry fields through when nothing is configured", () => {
+      const content = contentFor(VIDEO_ENTRY, {});
+
+      expect(content.title).toBe("Entry Title");
+      expect(content.summary).toBe("Entry Summary");
+    });
+  });
+
+  describe("TV audio", () => {
+    beforeEach(() => mockIsTV.mockReturnValue(true));
+
+    it("reads the TV audio key set, not the TV video one", () => {
+      const content = contentFor(AUDIO_ENTRY, {
+        audio_player_title_data_key_source: "other",
+        audio_player_title_custom_data_key: "extensions.customTitleKey",
+        // Configuring the TV *video* key too, to prove TV audio content reads
+        // its own key family instead.
+        video_player_title_data_key_source: "other",
+        video_player_title_custom_data_key: "extensions.doesNotExist",
+      });
+
+      expect(content.title).toBe("Custom Audio Title From Extensions");
+    });
+
+    it("falls back to the entry fields when nothing is configured", () => {
+      const content = contentFor(AUDIO_ENTRY, {});
+
+      expect(content.title).toBe("Entry Title");
+      expect(content.summary).toBe("Entry Summary");
+    });
+  });
+
+  describe("mobile", () => {
+    beforeEach(() => mockIsTV.mockReturnValue(false));
+
+    it("resolves the default (mobile) key set", () => {
+      const content = contentFor(VIDEO_ENTRY, {
+        title_data_key_source: "other",
+        title_custom_data_key: "extensions.customTitleKey",
+      });
+
+      expect(content.title).toBe("Custom Title From Extensions");
+    });
+
+    it("ignores TV video configuration", () => {
+      const content = contentFor(VIDEO_ENTRY, {
+        video_player_title_data_key_source: "other",
+        video_player_title_custom_data_key: "extensions.customTitleKey",
+      });
+
+      expect(content.title).toBe("Entry Title");
+    });
+
+    it("shares one key set between video and audio", () => {
+      const content = contentFor(AUDIO_ENTRY, {
+        title_data_key_source: "other",
+        title_custom_data_key: "extensions.customTitleKey",
+      });
+
+      expect(content.title).toBe("Custom Audio Title From Extensions");
+    });
+
+    it("ignores TV audio configuration for mobile audio", () => {
+      const content = contentFor(AUDIO_ENTRY, {
+        audio_player_title_data_key_source: "other",
+        audio_player_title_custom_data_key: "extensions.customTitleKey",
+      });
+
+      expect(content.title).toBe("Entry Title");
+    });
+  });
+});

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

@@ -0,0 +1,150 @@
+const mockAppStoreGet = jest.fn();
+const mockFindPluginByIdentifier = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: { get: (key: string) => mockAppStoreGet(key) },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/pluginUtils", () => ({
+  findPluginByIdentifier: (id: string, plugins: any) =>
+    mockFindPluginByIdentifier(id, plugins),
+}));
+
+import { PlayerRole } from "../const";
+import { playerFactory } from "../playerFactory";
+
+const fakeComponent = () => null;
+
+class FakeController {
+  receivedConfig: any;
+  constructor(config: any) {
+    this.receivedConfig = config;
+  }
+}
+
+const baseConfig = {
+  player: {},
+  playerId: "p1",
+  autoplay: false,
+  entry: { id: "entry-1" } as any,
+  muted: false,
+  playerPluginId: "test-plugin",
+  screenConfig: { foo: "bar" },
+  playerRole: PlayerRole.Cell,
+};
+
+const installPluginWithProtocol = (
+  protocolReturn: any | ((screenConfig: any, entry: any) => any)
+) => {
+  const playerProtocol =
+    typeof protocolReturn === "function"
+      ? protocolReturn
+      : () => protocolReturn;
+
+  mockAppStoreGet.mockImplementation((key: string) =>
+    key === "plugins" ? { "test-plugin": {} } : null
+  );
+
+  mockFindPluginByIdentifier.mockReturnValue({
+    module: { playerProtocol },
+  });
+};
+
+describe("playerFactory", () => {
+  beforeEach(() => {
+    mockAppStoreGet.mockReset();
+    mockFindPluginByIdentifier.mockReset();
+  });
+
+  it("resolves with controller and Component when playerProtocol returns synchronously", async () => {
+    installPluginWithProtocol({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    });
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+
+    expect((item?.controller as FakeController).receivedConfig).toBe(
+      baseConfig
+    );
+  });
+
+  it("resolves with controller and Component when playerProtocol returns a Promise (delayed import)", async () => {
+    installPluginWithProtocol(async () => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+  });
+
+  it("passes screenConfig and entry through to playerProtocol", async () => {
+    const playerProtocol = jest.fn(() => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: { playerProtocol } });
+
+    await playerFactory(baseConfig);
+
+    expect(playerProtocol).toHaveBeenCalledWith(
+      baseConfig.screenConfig,
+      baseConfig.entry
+    );
+  });
+
+  it("resolves to null when playerPluginId is missing", async () => {
+    expect(
+      await playerFactory({ ...baseConfig, playerPluginId: "" } as any)
+    ).toBeNull();
+  });
+
+  it("resolves to null when appStore has no plugins", async () => {
+    mockAppStoreGet.mockReturnValue(null);
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when the plugin has no playerProtocol", async () => {
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: {} });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a Component", async () => {
+    installPluginWithProtocol({ controllerClass: FakeController });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a controllerClass", async () => {
+    installPluginWithProtocol({ Component: fakeComponent });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("rejects when playerProtocol throws synchronously", async () => {
+    installPluginWithProtocol(() => {
+      throw new Error("boom");
+    });
+
+    await expect(playerFactory(baseConfig)).rejects.toThrow("boom");
+  });
+});

package/appUtils/playerManager/__tests__/usePlayerContent.test.tsx

@@ -0,0 +1,64 @@
+import { renderHook, act } from "@testing-library/react-native";
+import { BehaviorSubject } from "rxjs";
+
+import { usePlayerContent } from "../usePlayerContent";
+
+const mockPlayer: any = {
+  subject: null as BehaviorSubject<any> | null,
+  getContent: jest.fn(),
+  getContentObservable: jest.fn(),
+};
+
+jest.mock("../usePlayer", () => ({
+  usePlayer: () => mockPlayer,
+}));
+
+describe("usePlayerContent", () => {
+  beforeEach(() => {
+    mockPlayer.subject = new BehaviorSubject({
+      title: "First Title",
+      summary: "First Summary",
+    });
+
+    mockPlayer.getContent = jest.fn(() => mockPlayer.subject.getValue());
+
+    mockPlayer.getContentObservable = jest.fn(() =>
+      mockPlayer.subject.asObservable()
+    );
+  });
+
+  it("returns the player's current content", () => {
+    const { result } = renderHook(() => usePlayerContent());
+
+    expect(result.current).toEqual({
+      title: "First Title",
+      summary: "First Summary",
+    });
+  });
+
+  it("re-renders when the player publishes new content", () => {
+    const { result } = renderHook(() => usePlayerContent());
+
+    act(() => {
+      mockPlayer.subject.next({
+        title: "Second Title",
+        summary: "Second Summary",
+      });
+    });
+
+    expect(result.current).toEqual({
+      title: "Second Title",
+      summary: "Second Summary",
+    });
+  });
+
+  it("unsubscribes on unmount", () => {
+    const { unmount } = renderHook(() => usePlayerContent());
+
+    expect(mockPlayer.subject.observed).toBe(true);
+
+    unmount();
+
+    expect(mockPlayer.subject.observed).toBe(false);
+  });
+});