@applicaster/zapp-react-native-utils 16.0.0-alpha.9225550512 → 16.0.0-alpha.9506982263

package/actionsExecutor/actions/__tests__/showToast.test.ts

@@ -0,0 +1,88 @@
+import { showToastAction } from "../showToast";
+import { postEvent } from "../../../reactHooks/useSubscriberFor";
+import { ActionResult } from "../../ActionExecutor";
+
+jest.mock("../../../reactHooks/useSubscriberFor", () => ({
+  postEvent: jest.fn(),
+}));
+
+describe("showToastAction", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("calls postEvent with confirmation source, default timeout, and returns Success", async () => {
+    const action = {
+      type: "showToast",
+      options: {
+        id: "toast-1",
+        message: "Added to queue",
+        extraMessage: "Extra info",
+      },
+    };
+
+    const result = await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledTimes(1);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: "toast-1",
+        message: "Added to queue",
+        extraMessage: "Extra info",
+        style: undefined,
+        timeout: 1000,
+        source: "confirmation",
+      },
+    ]);
+
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("preserves an explicit timeout and style override", async () => {
+    const action = {
+      type: "showToast",
+      options: {
+        message: "Playlist created",
+        timeout: 3000,
+        style: { backgroundColor: "#00FF00" },
+      },
+    };
+
+    await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: undefined,
+        message: "Playlist created",
+        extraMessage: undefined,
+        style: { backgroundColor: "#00FF00" },
+        timeout: 3000,
+        source: "confirmation",
+      },
+    ]);
+  });
+
+  it("handles missing or empty options without throwing", async () => {
+    const action = {
+      type: "showToast",
+    };
+
+    const result = await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledTimes(1);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: undefined,
+        message: undefined,
+        extraMessage: undefined,
+        style: undefined,
+        timeout: 1000,
+        source: "confirmation",
+      },
+    ]);
+
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/showToast.ts

@@ -3,12 +3,65 @@ import { ActionResult } from "../ActionExecutor";
 import { ActionHandler } from "../types";
 import { postEvent } from "../../reactHooks/useSubscriberFor";
 
+export const CONFIRMATION_TOAST_SOURCE = "confirmation";
+
+export const CONFIRMATION_TOAST_DEFAULT_TIMEOUT = 1000;
+
 /**
- * Options for showToast action.
+ * Shows a mobile confirmation toast with Theme defaults from
+ * `Confirmation Toast / Message` in the base theme plugin.
+ *
+ * This action is confirmation-only by design: it always stamps
+ * `source: "confirmation"` (so Theme confirmation styles apply) and defaults
+ * `timeout` to 1000 ms. Non-confirmation toasts (e.g. Offline Experience)
+ * must post on the shared `"showToast"` event bus directly and omit `source`.
+ * Callers may override individual style fields; Theme supplies the rest.
+ *
+ * @example From React via ActionExecutorContext
+ * ```tsx
+ * import React, { useContext } from "react";
+ * import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutorContext";
+ *
+ * function QueueButton() {
+ *   const { handleAction } = useContext(ActionExecutorContext);
+ *
+ *   const onPress = () => {
+ *     void handleAction({
+ *       type: "showToast",
+ *       options: { message: "Added to queue" },
+ *     });
+ *   };
+ *
+ *   return <Button onPress={onPress} title="Add to queue" />;
+ * }
+ * ```
+ *
+ * @example From code via the actionExecutor singleton
+ * ```ts
+ * import { actionExecutor } from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutor";
+ *
+ * await actionExecutor.handleAction({
+ *   type: "showToast",
+ *   options: {
+ *     message: "Playlist created",
+ *     style: { backgroundColor: "#00AA55" }, // optional partial override
+ *   },
+ * });
+ * ```
+ *
+ * @example From entry / pipes actions JSON
+ * ```json
+ * {
+ *   "type": "showToast",
+ *   "options": {
+ *     "message": "Item removed from playlist"
+ *   }
+ * }
+ * ```
  */
 export interface ShowToastActionOptions {
-  id: string;
-  message: string;
+  id?: string;
+  message?: string;
   extraMessage?: string;
   style?: any;
   timeout?: number;
@@ -17,13 +70,16 @@ export interface ShowToastActionOptions {
 export const showToastAction: ActionHandler<ShowToastActionOptions> = async (
   action
 ): Promise<ActionResult> => {
+  const options = action?.options;
+
   postEvent("showToast", [
     {
-      id: action.options.id,
-      message: action.options.message,
-      extraMessage: action.options.extraMessage,
-      style: action.options.style,
-      timeout: action.options.timeout,
+      id: options?.id,
+      message: options?.message,
+      extraMessage: options?.extraMessage,
+      style: options?.style,
+      timeout: options?.timeout ?? CONFIRMATION_TOAST_DEFAULT_TIMEOUT,
+      source: CONFIRMATION_TOAST_SOURCE,
     },
   ]);
 

package/analyticsUtils/PlayerAnalyticsManager.ts

@@ -8,7 +8,7 @@ import {
 } from "../appUtils/playerManager";
 import { Player } from "../appUtils/playerManager/player";
 import { AnalyticPlayerListener } from "./AnalyticPlayerListener";
-import { PlayerRole } from "../appUtils/playerManager/conts";
+import { PlayerRole } from "../appUtils/playerManager/const";
 
 enum PlayerAnalyticsTrackerType {
   PlayerAnalyticsTracker = "PlayerAnalyticsTracker",

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -19,6 +19,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 +46,6 @@ export type LiveMetadataConfig = {
   updateInterval: number;
 };
 
-export type TitleSummaryEvent = {
-  title: string | number;
-  summary: string | number;
-};
-
 type ChapterMarkersObserverProps = {
   player: Player;
 };
@@ -59,24 +60,23 @@ type PlayNextConfig = {
 export type PlayNextState = PlayNextConfig & {
   triggerTime: number;
   handleUserCancelPlayNext: () => void;
+  hidePlayNext: () => void;
 };
 
 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;
   private chapterMarkerEvents: ChapterMarkerEvent[];
   readonly player: Player;
   private playNextConfig?: PlayNextConfig;
-  private isCanceledByUser = false;
+  private isPlayNextSuppressed = false;
 
   constructor({ player }: ChapterMarkersObserverProps) {
     this.chapterSubject = new BehaviorSubject(null);
@@ -85,41 +85,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);
@@ -127,25 +226,13 @@ 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);
+  };
 
   handleUserCancelPlayNext = () => {
-    this.isCanceledByUser = true;
-    this.playNextSubject.next(null);
+    this.hidePlayNext();
   };
 
   preparePlayNext = async () => {
@@ -270,7 +357,7 @@ export class OverlaysObserver {
 
   // TODO: Hack for video end, will be replaced with playlist prev/next in the future
   getPlayNextEntry = () =>
-    !this.isCanceledByUser ? this.playNextConfig?.entry : null;
+    !this.isPlayNextSuppressed ? this.playNextConfig?.entry : null;
 
   prepareChapterMarkers = () => {
     const chapterMarkers: ChapterMarkerOriginal[] =
@@ -353,7 +440,7 @@ export class OverlaysObserver {
     const shouldPlayNextBeVisible = currentTime > triggerTime;
 
     if (shouldPlayNextBeVisible) {
-      if (this.isCanceledByUser) {
+      if (this.isPlayNextSuppressed) {
         return;
       }
 
@@ -361,10 +448,11 @@ export class OverlaysObserver {
         ...this.playNextConfig,
         triggerTime,
         handleUserCancelPlayNext: this.handleUserCancelPlayNext,
+        hidePlayNext: this.hidePlayNext,
       });
     } else {
       this.playNextSubject.next(null);
-      this.isCanceledByUser = false;
+      this.isPlayNextSuppressed = false;
     }
   };
 
@@ -389,9 +477,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__/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();
+  });
+});