@applicaster/zapp-react-native-utils 14.0.0-rc.9 → 14.0.0-rc.91

package/playerUtils/PlayerTTS/PlayerTTS.ts

@@ -0,0 +1,359 @@
+import uuidv4 from "uuid/v4";
+import { AccessibilityManager } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager";
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+import { Player } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/player";
+
+const { log_debug, log_error } = createLogger({
+  subsystem: "Player",
+  category: "PlayerTTS",
+});
+
+enum SEEK_DIRECTION {
+  FORWARD = "forward",
+  REWIND = "back",
+}
+
+const hasPrerollAds = (entry: ZappEntry): boolean => {
+  const videoAds = entry?.extensions?.video_ads;
+
+  if (!videoAds) {
+    return false;
+  }
+
+  // If it's a string (VMAP URL), assume it might have preroll
+  if (typeof videoAds === "string") {
+    return true;
+  }
+
+  // If it's an array, check for preroll offset
+  if (Array.isArray(videoAds)) {
+    return videoAds.some(
+      (ad: ZappVideoAdExtension) => ad.offset === "preroll" || ad.offset === 0
+    );
+  }
+
+  return false;
+};
+
+export class PlayerTTS {
+  private player: Player;
+  private accessibilityManager: AccessibilityManager;
+  private seekStartPosition: number | null = null;
+  private isSeeking: boolean = false;
+  private listenerId: string;
+  private isInitialPlayerOpen: boolean = true;
+  private isPrerollActive: boolean = false;
+  private hasPrerollAds: boolean = false; // Track if preroll ads are expected
+
+  constructor(player: Player, accessibilityManager: AccessibilityManager) {
+    this.player = player;
+    this.accessibilityManager = accessibilityManager;
+    this.listenerId = `player-tts-${uuidv4()}`;
+    this.hasPrerollAds = hasPrerollAds(player.entry);
+
+    log_debug("PlayerTTS initialized", {
+      hasPrerollAds: this.hasPrerollAds,
+      listenerId: this.listenerId,
+      entryTitle: player.entry.title,
+    });
+  }
+
+  private numberToWords(num: number): string {
+    const ones = [
+      "",
+      "one",
+      "two",
+      "three",
+      "four",
+      "five",
+      "six",
+      "seven",
+      "eight",
+      "nine",
+      "ten",
+      "eleven",
+      "twelve",
+      "thirteen",
+      "fourteen",
+      "fifteen",
+      "sixteen",
+      "seventeen",
+      "eighteen",
+      "nineteen",
+    ];
+
+    const tens = [
+      "",
+      "",
+      "twenty",
+      "thirty",
+      "forty",
+      "fifty",
+      "sixty",
+      "seventy",
+      "eighty",
+      "ninety",
+    ];
+
+    if (num === 0) return "zero";
+    if (num < 20) return ones[num];
+
+    const ten = Math.floor(num / 10);
+    const one = num % 10;
+
+    return one === 0 ? tens[ten] : `${tens[ten]} ${ones[one]}`;
+  }
+
+  private secondsToTime(
+    seconds: number,
+    format: "natural" | "standard" = "natural"
+  ): string {
+    if (seconds < 0) return format === "natural" ? "zero" : "0";
+
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = Math.floor(seconds % 60);
+
+    if (format === "standard") {
+      const parts = [];
+
+      if (minutes > 0) {
+        parts.push(`${minutes} minute${minutes !== 1 ? "s" : ""}`);
+      }
+
+      if (remainingSeconds > 0) {
+        parts.push(
+          `${remainingSeconds} second${remainingSeconds !== 1 ? "s" : ""}`
+        );
+      }
+
+      return parts.length > 0 ? parts.join(" ") : "0";
+    } else {
+      if (minutes === 0) {
+        if (remainingSeconds === 0) return "zero";
+
+        if (remainingSeconds < 10) {
+          return `zero o ${this.numberToWords(remainingSeconds)}`;
+        }
+
+        return `zero ${this.numberToWords(remainingSeconds)}`;
+      }
+
+      if (remainingSeconds === 0) {
+        return `${this.numberToWords(minutes)}`;
+      }
+
+      if (remainingSeconds < 10) {
+        return `${this.numberToWords(minutes)} o ${this.numberToWords(remainingSeconds)}`;
+      }
+
+      return `${this.numberToWords(minutes)} ${this.numberToWords(remainingSeconds)}`;
+    }
+  }
+
+  private announcePause = () => {
+    if (!this.isSeeking) {
+      this.accessibilityManager.addHeading(
+        `Paused - ${this.secondsToTime(this.player.playerState.contentPosition, "standard")}`
+      );
+    }
+  };
+
+  private announceContentStart(
+    options: {
+      currentTime?: number;
+      duration?: number;
+      useReadText?: boolean;
+    } = {}
+  ): void {
+    const { currentTime, duration, useReadText = false } = options;
+    const state = this.player.playerState;
+
+    const timeRemaining =
+      (duration || state?.contentDuration || 0) -
+      (currentTime || state?.contentPosition || 0);
+
+    const title = (this.player.entry.title as string) || "";
+    const summary = (this.player.entry.summary as string) || "";
+
+    log_debug("Announcing content start", {
+      title,
+      currentTime: currentTime || state?.contentPosition || 0,
+      duration: duration || state?.contentDuration || 0,
+      timeRemaining,
+      useReadText,
+    });
+
+    this.accessibilityManager.addHeading(`Playing - ${title}`);
+    if (summary) this.accessibilityManager.addHeading(summary);
+
+    this.accessibilityManager.addHeading(
+      `Playing from ${this.secondsToTime(currentTime || state?.contentPosition || 0, "standard")}`
+    );
+
+    const remainingText = `${this.secondsToTime(Math.max(0, Math.floor(timeRemaining)), "standard")} remaining.`;
+
+    if (useReadText) {
+      this.accessibilityManager.readText({ text: remainingText });
+    } else {
+      this.accessibilityManager.addHeading(remainingText);
+    }
+
+    this.accessibilityManager.setInitialPlayerAnnouncementReady();
+    this.isInitialPlayerOpen = false;
+  }
+
+  private announceBufferComplete = (event: any) => {
+    // If preroll ads are expected, wait for them to finish before announcing content
+    if (this.hasPrerollAds && this.isInitialPlayerOpen) {
+      log_debug("Waiting for preroll ads to finish", {
+        hasPrerollAds: this.hasPrerollAds,
+        isInitialPlayerOpen: this.isInitialPlayerOpen,
+      });
+
+      return;
+    }
+
+    // Gate content announcement until preroll finishes
+    if (this.isInitialPlayerOpen && !this.isPrerollActive) {
+      log_debug("Buffer complete - announcing content", {
+        currentTime: event.currentTime,
+        duration: event.duration,
+        isPrerollActive: this.isPrerollActive,
+      });
+
+      this.announceContentStart({
+        currentTime: event.currentTime,
+        duration: event.duration,
+      });
+    }
+  };
+
+  private announceResume = () => {
+    if (!this.isSeeking && !this.isInitialPlayerOpen) {
+      log_debug("Player resumed", {
+        contentPosition: this.player.playerState.contentPosition,
+        isSeeking: this.isSeeking,
+        isInitialPlayerOpen: this.isInitialPlayerOpen,
+      });
+
+      this.accessibilityManager.addHeading(
+        `Playing - ${this.secondsToTime(this.player.playerState.contentPosition, "standard")}`
+      );
+    }
+  };
+
+  private handleVideoProgress = (event: any) => {
+    if (event.currentTime > 0) {
+      this.seekStartPosition = event.currentTime;
+    }
+  };
+
+  private handleSeekComplete = (event: any) => {
+    if (this.seekStartPosition !== null) {
+      const seekDirection =
+        event.currentTime > this.seekStartPosition
+          ? SEEK_DIRECTION.FORWARD
+          : SEEK_DIRECTION.REWIND;
+
+      const seekAmount = Math.round(
+        Math.abs(event.currentTime - this.seekStartPosition)
+      );
+
+      log_debug("Seek completed", {
+        seekDirection,
+        seekAmount,
+        fromPosition: this.seekStartPosition,
+        toPosition: event.currentTime,
+      });
+
+      this.accessibilityManager.readText({
+        text: `Skipped ${seekDirection} ${this.secondsToTime(seekAmount, "standard")}`,
+      });
+
+      this.seekStartPosition = event.currentTime;
+    }
+
+    this.isSeeking = false;
+  };
+
+  private handleSeekStart = () => {
+    log_debug("Seek started");
+    this.isSeeking = true;
+  };
+
+  private handlePlayerClose = () => {
+    log_debug("Player closed - resetting state");
+    this.isInitialPlayerOpen = true;
+    this.accessibilityManager.resetInitialPlayerAnnouncementReady();
+  };
+
+  private announceAdBegin = (event: any) => {
+    this.isPrerollActive = true;
+
+    log_debug("Ad started", {
+      adDuration: event?.ad?.data?.duration,
+      isPrerollActive: this.isPrerollActive,
+    });
+
+    if (event?.ad?.data?.duration) {
+      this.accessibilityManager.readText({
+        text: `Sponsored. Ends in ${this.secondsToTime(event.ad.data.duration, "standard")}`,
+      });
+    }
+  };
+
+  private handleAdEnd = (_event: any) => {
+    this.isPrerollActive = false;
+
+    log_debug("Ad ended", {
+      isPrerollActive: this.isPrerollActive,
+      isInitialPlayerOpen: this.isInitialPlayerOpen,
+    });
+
+    // If initial entry still pending, trigger content announcement using latest player state
+    if (this.isInitialPlayerOpen) {
+      this.announceContentStart({ useReadText: true });
+    }
+  };
+
+  public init(): () => void {
+    if (!this.player) {
+      log_error("Failed to initialize PlayerTTS - no player provided");
+
+      return () => {};
+    }
+
+    log_debug("Initializing PlayerTTS listeners", {
+      listenerId: this.listenerId,
+    });
+
+    return this.player.addListener({
+      id: this.listenerId,
+      listener: {
+        onBufferComplete: this.announceBufferComplete,
+        onPlayerResume: this.announceResume,
+        onPlayerPause: this.announcePause,
+        onVideoProgress: this.handleVideoProgress,
+        onPlayerSeekStart: this.handleSeekStart,
+        onPlayerSeekComplete: this.handleSeekComplete,
+        onPlayerClose: this.handlePlayerClose,
+        onAdBegin: this.announceAdBegin,
+        onAdEnd: this.handleAdEnd,
+        onAdBreakEnd: this.handleAdEnd,
+      },
+    });
+  }
+
+  public destroy(): void {
+    log_debug("Destroying PlayerTTS", {
+      listenerId: this.listenerId,
+    });
+
+    if (this.player) {
+      this.player.removeListener(this.listenerId);
+    }
+
+    this.seekStartPosition = null;
+    this.handlePlayerClose();
+  }
+}

package/playerUtils/PlayerTTS/index.ts

@@ -0,0 +1 @@
+export { PlayerTTS } from "./PlayerTTS";

package/playerUtils/__tests__/configurationUtils.test.ts

@@ -1,72 +1,8 @@
 import * as utils from "../configurationUtils";
 
-const { modifyDefaultConfigValues, parseLanguageTracks } = utils;
-
-const configuration = {
-  general: { fields: [{ key: "general_1", initial_value: true }] },
-  styles: { fields: [{ key: "styles_1", initial_value: true }] },
-  localizations: {
-    fields: [{ key: "localizations_1", initial_value: true, label: "label" }],
-  },
-  custom_configuration_fields: [
-    { key: "custom_configuration_fields_1", initial_value: true },
-    { key: "custom_configuration_fields_2", initial_value: "black" },
-    {
-      group: true,
-      fields: [{ key: "custom_configuration_fields_3", initial_value: "red" }],
-    },
-  ],
-};
+const { parseLanguageTracks } = utils;
 
 describe("utilities", () => {
-  describe("modifyDefaultConfigValues", () => {
-    it("should not modify the configuration if a map key doesn't exist in configuration ", function () {
-      const res = modifyDefaultConfigValues(configuration, {
-        custom_configuration_fields: {
-          non_existing_key: { initial_value: "true" },
-        },
-      });
-
-      expect(res).toEqual(configuration);
-    });
-
-    it("should modify the key from mapping", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        styles: { styles_1: { initial_value: false } },
-      });
-
-      expect(currentResult.styles.fields[0].initial_value).toBe(false);
-    });
-
-    it("should add extra keys the key from mapping", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        styles: { styles_1: { extra_key: false } },
-      });
-
-      expect(currentResult.styles.fields[0].extra_key).toBeDefined();
-    });
-
-    it("should not remove existing keys that aren't being overwritten", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        localizations: { localizations_1: { initial_value: false } },
-      });
-
-      expect(currentResult.localizations.fields[0].label).toBeDefined();
-    });
-
-    it("should modify values in groups as well", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        custom_configuration_fields: {
-          custom_configuration_fields_3: { initial_value: "blue" },
-        },
-      });
-
-      expect(
-        currentResult.custom_configuration_fields[2].fields[0].initial_value
-      ).toBe("blue");
-    });
-  });
-
   describe("parseLanguageTracks", () => {
     const textTrack = { index: 0, id: "text-0" };
     const audioTrack = { index: 0, id: "audio-0" };

package/playerUtils/__tests__/getPlayerActionButtons.test.ts

@@ -0,0 +1,54 @@
+import { getPlayerActionButtons } from "../getPlayerActionButtons";
+import { selectActionButtons } from "../../conf/player/selectors";
+
+jest.mock("../../conf/player/selectors", () => ({
+  selectActionButtons: jest.fn(),
+}));
+
+describe("getPlayerActionButtons", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns an empty array if selectActionButtons returns undefined", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(undefined);
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual([]);
+  });
+
+  it("returns an empty array if selectActionButtons returns null", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(null);
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual([]);
+  });
+
+  it("returns an empty array if selectActionButtons returns empty string", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue("");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual([]);
+  });
+
+  it("returns the first two trimmed action buttons", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(" play , pause , stop ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["play", "pause"]);
+  });
+
+  it("returns only one button if only one is present", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(" play ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["play"]);
+  });
+
+  it("trims whitespace from button names", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue("  play  ,   pause  ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["play", "pause"]);
+  });
+
+  it("returns an empty array if selectActionButtons returns only commas", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(" , , ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["", ""]);
+  });
+});

package/playerUtils/_internals/__tests__/utils.test.ts

@@ -0,0 +1,71 @@
+import { getAllFields, getConfigurationDiff } from "../utils";
+
+describe("getAllFields", () => {
+  it("should return all field keys from flat configs", () => {
+    const config1 = {
+      fields: [{ key: "foo" }, { key: "bar" }],
+    };
+
+    const config2 = {
+      fields: [{ key: "baz" }],
+    };
+
+    expect(getAllFields(config1, config2)).toEqual(["foo", "bar", "baz"]);
+  });
+
+  it("should handle grouped fields", () => {
+    const config = {
+      fields: [
+        {
+          group: true,
+          fields: [{ key: "grouped1" }, { key: "grouped2" }],
+        },
+        { key: "single" },
+      ],
+    };
+
+    expect(getAllFields(config)).toEqual(["grouped1", "grouped2", "single"]);
+  });
+
+  it("should filter out fields without a key", () => {
+    const config = {
+      fields: [{ key: "foo" }, { notAKey: "bar" }],
+    };
+
+    expect(getAllFields(config)).toEqual(["foo"]);
+  });
+
+  it("should return an empty array if no fields are present", () => {
+    expect(getAllFields({})).toEqual([]);
+  });
+});
+
+describe("getConfigurationDiff", () => {
+  it("should return keys in defaultConfig not present in config", () => {
+    const defaultConfig = ["foo", "bar", "baz"];
+    const config = { foo: 1, baz: 2 };
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual(["bar"]);
+  });
+
+  it("should return all keys if config is empty", () => {
+    const defaultConfig = ["foo", "bar"];
+    const config = {};
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual(["foo", "bar"]);
+  });
+
+  it("should return an empty array if all keys are present", () => {
+    const defaultConfig = ["foo"];
+    const config = { foo: 1 };
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual([]);
+  });
+
+  it("should return defaultConfig if config has no matching keys", () => {
+    const defaultConfig = ["foo", "bar"];
+    const config = { baz: 1 };
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual(["foo", "bar"]);
+  });
+});

package/playerUtils/_internals/index.ts

@@ -0,0 +1 @@
+export * from "./utils";

package/playerUtils/_internals/utils.ts

@@ -0,0 +1,31 @@
+import {
+  flatMap,
+  get,
+  flatten,
+  difference,
+} from "@applicaster/zapp-react-native-utils/utils";
+
+const extractFields = (field: any) => {
+  if (field.group === true) {
+    return field.fields;
+  }
+
+  return field;
+};
+
+export const getAllFields = (...configs: any[]) => {
+  const allFields = flatMap(configs, (config) => get(config, "fields", []));
+
+  const processedFields = flatten(allFields.map(extractFields))
+    .map((field) => get(field, "key"))
+    .filter(Boolean);
+
+  return processedFields;
+};
+
+export const getConfigurationDiff = (
+  defaultConfig,
+  config: Record<string, any>
+) => {
+  return difference(defaultConfig, Object.keys(config));
+};

package/playerUtils/configurationUtils.ts

@@ -1,50 +1,6 @@
 import { parseJsonIfNeeded } from "../functionUtils";
 import * as R from "ramda";
 
-import { getNativeName as nativeNameUtil } from "../localizationUtils/localeLanguage";
-
-export const modifyDefaultConfigValues = (
-  configuration: ConfigurationKeys,
-  mapping: ConfigValuesMapping
-): DefaultConfiguration => {
-  return R.mapObjIndexed((value, key) => {
-    const isFieldlessKey = key === "custom_configuration_fields";
-    const keyMapping = mapping[key];
-    const fields = value?.fields || value;
-
-    if (!keyMapping) {
-      return value;
-    }
-
-    const mapper = (obj) => {
-      if (obj.fields) {
-        return R.mergeLeft({ fields: R.map(mapper)(obj.fields) })(obj);
-      }
-
-      return R.mergeLeft(keyMapping?.[obj.key])(obj);
-    };
-
-    const mappedFields = R.map(mapper)(fields);
-
-    return R.unless(() => isFieldlessKey, R.objOf("fields"))(mappedFields);
-  })(configuration);
-};
-
-export function nativeName(localeCode) {
-  try {
-    const {
-      getNativeName,
-    } = require("@applicaster/zapp-react-native-utils/localizationUtils/localeLanguage");
-
-    return getNativeName(localeCode);
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn("Could not load localeLanguage utils from QB", error);
-
-    return nativeNameUtil(localeCode);
-  }
-}
-
 const setTrackType = R.curry(
   (
     type: QuickBrickPlayer.TrackType,

package/playerUtils/getPlayerActionButtons.ts

@@ -0,0 +1,17 @@
+import { map, take, trim } from "../utils";
+import { selectActionButtons } from "../conf/player/selectors";
+
+/**
+ * Returns the first two action buttons from the configuration.
+ * @param {Object} configuration - The player configuration object.
+ * @returns {Array} An array containing the first two action buttons.
+ */
+export const getPlayerActionButtons = (configuration: any) => {
+  const buttonsString = selectActionButtons(configuration);
+
+  if (!buttonsString) {
+    return [];
+  }
+
+  return take(2, map(buttonsString.split(","), trim));
+};