@applicaster/zapp-react-native-utils 13.0.8-alpha.1940580104 → 13.0.8-alpha.4487353250

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "13.0.8-alpha.1940580104",
+  "version": "13.0.8-alpha.4487353250",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.8-alpha.1940580104",
+    "@applicaster/applicaster-types": "13.0.8-alpha.4487353250",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/playerUtils/PlayerTTS/PlayerTTS.ts

@@ -1,12 +1,40 @@
-import { AccessibilityManager } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager";
 import uuidv4 from "uuid/v4";
-import { Player } from "../../appUtils/playerManager/player";
+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;
@@ -14,11 +42,20 @@ export class PlayerTTS {
   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 {
@@ -64,9 +101,7 @@ export class PlayerTTS {
     const ten = Math.floor(num / 10);
     const one = num % 10;
 
-    if (one === 0) return tens[ten];
-
-    return `${tens[ten]} ${ones[one]}`;
+    return one === 0 ? tens[ten] : `${tens[ten]} ${ones[one]}`;
   }
 
   private secondsToTime(
@@ -79,17 +114,19 @@ export class PlayerTTS {
     const remainingSeconds = Math.floor(seconds % 60);
 
     if (format === "standard") {
-      if (minutes === 0) {
-        if (remainingSeconds === 0) return "0";
+      const parts = [];
 
-        return `${remainingSeconds} second${remainingSeconds !== 1 ? "s" : ""}`;
+      if (minutes > 0) {
+        parts.push(`${minutes} minute${minutes !== 1 ? "s" : ""}`);
       }
 
-      if (remainingSeconds === 0) {
-        return `${minutes} minute${minutes !== 1 ? "s" : ""}`;
+      if (remainingSeconds > 0) {
+        parts.push(
+          `${remainingSeconds} second${remainingSeconds !== 1 ? "s" : ""}`
+        );
       }
 
-      return `${minutes} minute${minutes !== 1 ? "s" : ""} ${remainingSeconds} second${remainingSeconds !== 1 ? "s" : ""}`;
+      return parts.length > 0 ? parts.join(" ") : "0";
     } else {
       if (minutes === 0) {
         if (remainingSeconds === 0) return "zero";
@@ -113,10 +150,6 @@ export class PlayerTTS {
     }
   }
 
-  private announceLoading = () => {
-    this.accessibilityManager.addHeading("Loading");
-  };
-
   private announcePause = () => {
     if (!this.isSeeking) {
       this.accessibilityManager.addHeading(
@@ -125,29 +158,84 @@ export class PlayerTTS {
     }
   };
 
+  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 (this.isInitialPlayerOpen) {
-      const timeRemaining = event.duration - event.currentTime;
-      const title = (this.player.entry.title as string) || "";
-      const summary = (this.player.entry.summary as string) || "";
-      this.accessibilityManager.addHeading(`Playing - ${title}`);
-      this.accessibilityManager.addHeading(summary);
+    // 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,
+      });
 
-      this.accessibilityManager.addHeading(
-        `Playing from ${this.secondsToTime(event.currentTime, "standard")}`
-      );
+      return;
+    }
 
-      this.accessibilityManager.addHeading(
-        `${this.secondsToTime(timeRemaining, "standard")} remaining.`
-      );
+    // 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.accessibilityManager.setInitialPlayerAnnouncementReady();
-      this.isInitialPlayerOpen = false;
+      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")}`
       );
@@ -171,6 +259,13 @@ export class PlayerTTS {
         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")}`,
       });
@@ -182,15 +277,24 @@ export class PlayerTTS {
   };
 
   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")}`,
@@ -198,15 +302,34 @@ export class PlayerTTS {
     }
   };
 
+  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: {
-        onBufferStart: this.announceLoading,
         onBufferComplete: this.announceBufferComplete,
         onPlayerResume: this.announceResume,
         onPlayerPause: this.announcePause,
@@ -215,11 +338,17 @@ export class PlayerTTS {
         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);
     }