@applicaster/zapp-react-native-utils 15.0.0-alpha.2413435535 → 15.0.0-alpha.2535277107

package/appUtils/accessibilityManager/const.ts

@@ -31,6 +31,10 @@ export const BUTTON_ACCESSIBILITY_KEYS = {
       hint: "accessibility_close_mini_hint",
     },
   },
+  back_to_live: {
+    label: "back_to_live_label",
+    hint: "",
+  },
   maximize: {
     label: "accessibility_maximize_label",
     hint: "accessibility_maximize_hint",

package/appUtils/accessibilityManager/hooks.ts

@@ -17,28 +17,13 @@ export const useAccessibilityManager = (
     return AccessibilityManager.getInstance();
   }, []);
 
-  const [accessibilityManagerState, setAccessibilityManagerState] =
-    useState<AccessibilityState>(accessibilityManager.getState());
-
   useEffect(() => {
     if (pluginConfiguration) {
       accessibilityManager.updateLocalizations(pluginConfiguration);
     }
   }, [pluginConfiguration, accessibilityManager]);
 
-  useEffect(() => {
-    const subscription = accessibilityManager.getStateAsObservable().subscribe({
-      next: (newState) => {
-        setAccessibilityManagerState(newState);
-      },
-    });
-
-    return () => subscription.unsubscribe();
-  }, [accessibilityManager]);
-
-  return Object.assign(accessibilityManager, {
-    accessibilityManagerState,
-  });
+  return accessibilityManager;
 };
 
 export const useInitialAnnouncementReady = (
@@ -74,3 +59,23 @@ export const useAnnouncementActive = (
 
   return isActive;
 };
+
+export const useAccessibilityState = (
+  pluginConfiguration: Record<string, any> = {}
+) => {
+  const accessibilityManager = useAccessibilityManager(pluginConfiguration);
+
+  const [state, setState] = useState<AccessibilityState>(
+    accessibilityManager.getState()
+  );
+
+  useEffect(() => {
+    const subscription = accessibilityManager
+      .getStateAsObservable()
+      .subscribe(setState);
+
+    return () => subscription.unsubscribe();
+  }, [accessibilityManager]);
+
+  return state;
+};

package/appUtils/platform/platformUtils.ts

@@ -234,34 +234,66 @@ export class TTSManager {
         });
       } catch (error) {
         log_debug("webOS settings service request error", { error });
+        // Fallback to false if the service is not available
         this.screenReaderEnabled$.next(false);
       }
     }
 
-    if (isSamsungPlatform() && typeof window.tizen !== "undefined") {
+    if (isSamsungPlatform() && typeof window.webapis !== "undefined") {
       try {
         if (
-          window.tizen.accessibility &&
-          typeof window.tizen.accessibility
-            .addVoiceGuideStatusChangeListener === "function"
+          window.webapis?.tvinfo &&
+          typeof window.webapis.tvinfo.getMenuValue === "function" &&
+          typeof window.webapis.tvinfo.addCaptionChangeListener === "function"
         ) {
+          // Get initial Voice Guide status
+          const initialStatus = window.webapis.tvinfo.getMenuValue(
+            window.webapis.tvinfo.TvInfoMenuKey.VOICE_GUIDE_KEY
+          );
+
+          const isEnabled =
+            initialStatus === window.webapis.tvinfo.TvInfoMenuValue.ON;
+
+          log_debug("Samsung Voice Guide initial status", {
+            isEnabled,
+            initialStatus,
+          });
+
+          this.screenReaderEnabled$.next(isEnabled);
+
+          // Listen for Voice Guide status changes
+          const onChange = () => {
+            const currentStatus = window.webapis.tvinfo.getMenuValue(
+              window.webapis.tvinfo.TvInfoMenuKey.VOICE_GUIDE_KEY
+            );
+
+            const enabled =
+              currentStatus === window.webapis.tvinfo.TvInfoMenuValue.ON;
+
+            log_debug("Samsung Voice Guide status changed", {
+              enabled,
+              currentStatus,
+            });
+
+            this.screenReaderEnabled$.next(enabled);
+          };
+
           this.samsungListenerId =
-            window.tizen.accessibility.addVoiceGuideStatusChangeListener(
-              (enabled: boolean) => {
-                log_debug("Samsung Voice Guide status changed", { enabled });
-                this.screenReaderEnabled$.next(!!enabled);
-              }
+            window.webapis.tvinfo.addCaptionChangeListener(
+              window.webapis.tvinfo.TvInfoMenuKey.VOICE_GUIDE_KEY,
+              onChange
             );
 
           log_debug("Samsung Voice Guide listener registered", {
             listenerId: this.samsungListenerId,
           });
         } else {
-          log_debug("Samsung accessibility API not available");
+          log_debug("Samsung TvInfo API not available");
           this.screenReaderEnabled$.next(false);
         }
       } catch (error) {
         log_debug("Samsung Voice Guide listener error", { error });
+        // Fallback to false if the service is not available
         this.screenReaderEnabled$.next(false);
       }
     }
@@ -282,31 +314,14 @@ export class TTSManager {
   readText(text: string) {
     this.ttsState$.next(true);
 
-    if (
-      isSamsungPlatform() &&
-      typeof window.tizen !== "undefined" &&
-      window.tizen.speech
-    ) {
-      try {
-        const successCallback = () => {
-          log_debug("Samsung TTS play started successfully");
-          // Estimate reading time and set inactive when done
-          this.scheduleTTSComplete(text);
-        };
-
-        const errorCallback = (error: any) => {
-          log_debug("Samsung TTS error", { error: error?.message || error });
-          this.ttsState$.next(false);
-        };
+    if (isSamsungPlatform() && window.speechSynthesis) {
+      const utterance = new SpeechSynthesisUtterance(text);
 
-        // Clear any previous speech before speaking new text
-        window.tizen.speech.stop();
+      window.speechSynthesis.cancel(); // Cancel previous speech before speaking new text
+      window.speechSynthesis.speak(utterance);
 
-        window.tizen.speech.speak(text, successCallback, errorCallback);
-      } catch (error) {
-        log_debug("Samsung TTS speak() error", { error });
-        this.ttsState$.next(false);
-      }
+      // Estimate reading time and set inactive when done
+      this.scheduleTTSComplete(text);
     }
 
     if (isLgPlatform() && window.webOS?.service) {

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -5,6 +5,7 @@ import { createLogger, utilsLogger } from "../../../logger";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import {
   findPluginByIdentifier,
+  loadFeedEntry,
   loadFeedAndPrefetchThumbnailImage,
   parseTimeToSeconds,
   retrieveFeedUrl,
@@ -26,6 +27,19 @@ type ChapterMarkerOriginal = {
   actions: ActionChapter[];
 };
 
+export type LiveMetadataEvent = {
+  programId: string;
+  assetId: string;
+  title: string;
+  programStartTime: string;
+  programEndTime: string;
+};
+
+export type LiveMetadataConfig = {
+  updateUrl: string;
+  updateInterval: number;
+};
+
 export type TitleSummaryEvent = {
   title: string | number;
   summary: string | number;
@@ -50,11 +64,13 @@ export type PlayNextState = PlayNextConfig & {
 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 liveMetadataUpdateInterval: any;
   private releasePlayerObserver?: () => void;
   readonly entry: ZappEntry;
   private chapterMarkerEvents: ChapterMarkerEvent[];
@@ -66,13 +82,17 @@ export class OverlaysObserver {
     this.chapterSubject = new BehaviorSubject(null);
     this.playNextSubject = new BehaviorSubject(null);
 
+    this.player = player;
+    this.entry = player.getEntry();
+
     this.titleSummarySubject = new BehaviorSubject<TitleSummaryEvent>({
-      title: player.getEntry()?.title || "",
-      summary: player.getEntry()?.summary || "",
+      title: this.entry?.title || "",
+      summary: this.entry?.summary || "",
     });
 
-    this.entry = player.getEntry();
-    this.player = player;
+    this.liveMetadataSubject = new BehaviorSubject<LiveMetadataEvent>(
+      this.entry?.extensions?.liveMetadata || null
+    );
 
     this.chapterMarkerEvents = this.prepareChapterMarkers();
     this.releasePlayerObserver = this.subscribeToPlayerEvents();
@@ -80,7 +100,9 @@ export class OverlaysObserver {
     this.reloadData = () => {};
     this.updateTitleAndDescription = () => {};
     this.feedDataInterval = null;
+    this.liveMetadataUpdateInterval = null;
     void this.preparePlayNext();
+    void this.prepareLiveMetadata();
   }
 
   private setupFeedDataInterval(interval: number) {
@@ -98,6 +120,13 @@ export class OverlaysObserver {
     }
   }
 
+  public clearLiveMetadataUpdateInterval() {
+    if (this.liveMetadataUpdateInterval) {
+      clearInterval(this.liveMetadataUpdateInterval);
+      this.liveMetadataUpdateInterval = null;
+    }
+  }
+
   public setFeedDataHandlers(
     feedUrl: string,
     reloadData: () => void,
@@ -197,6 +226,48 @@ export class OverlaysObserver {
     }
   };
 
+  prepareLiveMetadata = async () => {
+    if (!this.player?.isLive?.()) {
+      log_debug("prepareLiveMetadata: Player is not live. Skipping...");
+
+      return;
+    }
+
+    const config: LiveMetadataConfig =
+      this.entry?.extensions?.liveMetadataConfig;
+
+    if (!config?.updateUrl || !config?.updateInterval) {
+      log_debug(
+        "prepareLiveMetadata: Live metadata configuration is not available. Skipping...",
+        { config }
+      );
+
+      return;
+    }
+
+    const reloadData = async () => {
+      try {
+        const entry = await loadFeedEntry(config.updateUrl, this.entry);
+
+        this.onLiveMetadataUpdated(entry?.extensions?.liveMetadata || null);
+      } catch (error) {
+        log_error("prepareLiveMetadata: Metadata fetching failed", {
+          error,
+          config,
+        });
+      }
+    };
+
+    log_debug("prepareLiveMetadata: Setting up live metadata observer update", {
+      config,
+    });
+
+    const interval = Number(config?.updateInterval) || 60;
+
+    this.clearLiveMetadataUpdateInterval();
+    this.liveMetadataUpdateInterval = setInterval(reloadData, interval * 1000);
+  };
+
   // TODO: Hack for video end, will be replaced with playlist prev/next in the future
   getPlayNextEntry = () =>
     !this.isCanceledByUser ? this.playNextConfig?.entry : null;
@@ -317,9 +388,11 @@ export class OverlaysObserver {
   onPlayerClose = () => {
     this.chapterSubject.complete();
     this.playNextSubject.complete();
+    this.liveMetadataSubject.complete();
     this.titleSummarySubject.complete();
     this.releasePlayerObserver?.();
     this.clearFeedDataInterval();
+    this.clearLiveMetadataUpdateInterval();
     this.releasePlayerObserver = null;
   };
 
@@ -352,4 +425,21 @@ export class OverlaysObserver {
         (prev, curr) => prev?.triggerTime === curr?.triggerTime
       )
     );
+
+  private onLiveMetadataUpdated = (liveMetadataEvent: LiveMetadataEvent) => {
+    this.liveMetadataSubject.next(liveMetadataEvent);
+  };
+
+  public getLiveMetadataObservable = (): Observable<LiveMetadataEvent> => {
+    return this.liveMetadataSubject.pipe(
+      distinctUntilChanged(
+        (prev, curr) =>
+          prev?.programId === curr?.programId && prev?.assetId === curr?.assetId
+      )
+    );
+  };
+
+  public getLiveMetadataValue = (): LiveMetadataEvent => {
+    return this.liveMetadataSubject.value;
+  };
 }

package/appUtils/playerManager/OverlayObserver/utils.ts

@@ -92,22 +92,26 @@ export const prefetchImage = (playableItem: ZappEntry, config: any = {}) => {
   }
 };
 
-export const loadFeedAndPrefetchThumbnailImage = async (
-  playNextFeedUrl: string,
-  entry: ZappEntry,
-  playNextPlugin
-) => {
+/**
+ * Loads a feed entry from the given feed URL using the provided Zapp entry as context.
+ *
+ * @param {string} feedUrl - The URL of the feed to load the entry from.
+ * @param {ZappEntry} entry - The Zapp entry to use as context for the request.
+ * @returns {Promise<ZappEntry>} A promise that resolves to the loaded Zapp entry.
+ * @throws {Error} If the feed loading fails or no entry is found in the response.
+ */
+export const loadFeedEntry = async (feedUrl: string, entry: ZappEntry) => {
   const requestBuilder = new RequestBuilder()
     .setEntryContext(entry)
     .setScreenContext({} as ZappRiver)
-    .setUrl(playNextFeedUrl);
+    .setUrl(feedUrl);
 
   const responseObject = await requestBuilder.call<ZappEntry>();
   const responseHelper = new PipesClientResponseHelper(responseObject);
 
   if (responseHelper.error) {
     log_error(
-      `loadFeedAndPrefetchThumbnailImage: loading failed with error: ${responseHelper.error.message}. Play next observer, will not be executed`,
+      `loadFeedEntry: loading failed with error: ${responseHelper.error.message}. Observer will not be executed`,
       {
         response: responseHelper.getLogsData(),
       }
@@ -116,29 +120,37 @@ export const loadFeedAndPrefetchThumbnailImage = async (
     throw responseHelper.error;
   } else {
     log_info(
-      `loadFeedAndPrefetchThumbnailImage: Play next url was successfully loaded for url: ${playNextFeedUrl}. Prefetching image`,
+      `loadFeedEntry: Feed was successfully loaded for url: ${feedUrl}`,
       responseHelper.getLogsData()
     );
 
-    const playNextEntry = responseHelper.responseData?.entry[0];
+    const entry = responseHelper.responseData?.entry[0];
 
-    if (!playNextEntry) {
-      log_error(
-        "loadFeedAndPrefetchThumbnailImage: Can not retrieve play next entry, feed was loaded but no entry was found",
-        responseHelper.getLogsData()
-      );
+    if (!entry) {
+      const error =
+        "loadFeedEntry: Can not retrieve entry, feed was loaded but no entry was found";
 
-      throw new Error(
-        "Can not retrieve play next entry, feed was loaded but no entry was found"
-      );
-    }
+      log_error(error, responseHelper.getLogsData());
 
-    prefetchImage(playNextEntry, playNextPlugin?.configuration);
+      throw new Error(error);
+    }
 
-    return playNextEntry;
+    return entry;
   }
 };
 
+export const loadFeedAndPrefetchThumbnailImage = async (
+  playNextFeedUrl: string,
+  entry: ZappEntry,
+  playNextPlugin
+) => {
+  const playNextEntry = await loadFeedEntry(playNextFeedUrl, entry);
+
+  prefetchImage(playNextEntry, playNextPlugin?.configuration);
+
+  return playNextEntry;
+};
+
 export const findPluginByIdentifier = (
   identifier: string,
   plugins: ZappPlugin[]

package/appUtils/playerManager/player.ts

@@ -250,6 +250,10 @@ export class Player {
       return false;
     }
 
+    if (!Number.isFinite(duration)) {
+      return this.getSeekableDuration() > 0;
+    }
+
     return duration > 0;
   };
 

package/appUtils/playerManager/usePlayerState.tsx

@@ -2,7 +2,7 @@ import * as React from "react";
 import { Player } from "./player";
 import { usePlayer } from "./usePlayer";
 
-type PlayerState = {
+export type PlayerState = {
   currentTime: number;
   duration: number;
   seekableDuration: number;
@@ -10,6 +10,8 @@ type PlayerState = {
   isPaused: boolean;
   isBuffering: boolean;
   isReadyToPlay: boolean;
+  trackState?: QuickBrickPlayer.TracksState;
+  isAd: boolean;
 };
 
 export const usePlayerState = (
@@ -24,6 +26,8 @@ export const usePlayerState = (
     isPaused: null,
     isBuffering: false,
     isReadyToPlay: false,
+    trackState: null,
+    isAd: false,
   });
 
   const player: Player = usePlayer(playerId);
@@ -37,6 +41,8 @@ export const usePlayerState = (
       isPaused: player.isPaused(),
       isBuffering: player.isBuffering(),
       isReadyToPlay: player.isReadyToPlay(),
+      trackState: player.getTracksState(),
+      isAd: player.isAd(),
     });
   }, [player]);
 
@@ -54,10 +60,16 @@ export const usePlayerState = (
           onPlayerPause: onPlayerChangeState,
           onPlayerResume: onPlayerChangeState,
           onPlayerSeekComplete: onPlayerChangeState,
+          onTracksChanged: onPlayerChangeState,
+          onAdBreakBegin: onPlayerChangeState,
+          onAdBreakEnd: onPlayerChangeState,
+          onAdBegin: onPlayerChangeState,
+          onAdEnd: onPlayerChangeState,
+          onAdError: onPlayerChangeState,
         },
       });
     }
-  }, [player]);
+  }, [listenerId, onPlayerChangeState, player]);
 
   return state;
 };

package/cellUtils/index.ts

@@ -9,10 +9,7 @@ import {
 } from "@applicaster/zapp-react-native-utils/stringUtils";
 import { cellUtilsLogger } from "@applicaster/zapp-react-native-utils/cellUtils/logger";
 import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
-import {
-  isNotNil,
-  isNilOrEmpty,
-} from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
 
 import { toNumberWithDefault, toNumberWithDefaultZero } from "../numberUtils";
 
@@ -509,9 +506,6 @@ export const getImageContainerMarginStyles = ({ value }: { value: any }) => {
   };
 };
 
-export const withoutNilOrEmpty = (arr: string[]): string[] =>
-  arr.filter((item) => !isNilOrEmpty(item));
-
 export const isTextLabel = (key: string): boolean =>
   key.includes("text_label_") && key.endsWith("_switch");
 
@@ -531,7 +525,6 @@ export const hasTextLabelsEnabled = (
 
   const pickedValues = Object.values(picked);
 
-  // Check if any switch value is truthy (true, "true", "1", etc.)
   return pickedValues.some((value) => {
     if (typeof value === "boolean") {
       return value === true;

package/manifestUtils/defaultManifestConfigurations/player.js

@@ -335,6 +335,13 @@ function getPlayerConfiguration({ platform, version }) {
   };
 
   if (isTV(platform)) {
+    localizations.fields.push({
+      key: "back_to_live_label",
+      label: "Back to live label",
+      initial_value: "Back To Live",
+      type: "text_input",
+    });
+
     styles.fields.push(
       fieldsGroup("Always Show Scrub Bar & Timestamp", "", [
         {
@@ -447,7 +454,7 @@ function getPlayerConfiguration({ platform, version }) {
       ),
       fieldsGroup(
         "Skip Button",
-        "This section allows you to configure the skip button styles for tv",
+        "This section allows you to configure the skip button behaviour",
         [
           {
             type: "switch",
@@ -464,6 +471,12 @@ function getPlayerConfiguration({ platform, version }) {
             label: "Persistent Button Toggle",
             initial_value: true,
           },
+        ]
+      ),
+      fieldsGroup(
+        "Labeled Button Style",
+        "This section allows you to configure the labeled button styles",
+        [
           {
             type: "color_picker_rgba",
             label_tooltip: "",
@@ -619,6 +632,44 @@ function getPlayerConfiguration({ platform, version }) {
     );
   }
 
+  if (isTV(platform)) {
+    general.fields.push(
+      {
+        key: "liveSeekingEnabled",
+        label: "Live Seeking Enabled",
+        initial_value: false,
+        type: "switch",
+        label_tooltip: "Enable Live Seek",
+      },
+      {
+        key: "minimumAllowedSeekableDurationInSeconds",
+        label: "Minimum allowed seekable duration in seconds",
+        initial_value: 300,
+        type: "number_input",
+        label_tooltip:
+          "If duration less than this value, player will disable 'liveSeekingEnabled' value",
+      },
+      {
+        key: "live_image",
+        label: "Live badge",
+        type: "uploader",
+        label_tooltip: "Override default live badge / icon",
+      },
+      {
+        key: "live_width",
+        label: "Live badge width",
+        type: "number_input",
+        initial_value: 85,
+      },
+      {
+        key: "live_height",
+        label: "Live badge height",
+        type: "number_input",
+        initial_value: 50,
+      }
+    );
+  }
+
   if (isMobile(platform)) {
     general.fields.push(
       {

package/manifestUtils/keys.js

@@ -959,6 +959,27 @@ const TV_CELL_LABEL_FIELDS = [
     rules: "conditional",
     conditions: [{ key: "switch", section: "styles", value: true }],
   },
+  {
+    type: ZAPPIFEST_FIELDS.font_selector.roku,
+    suffix: "roku font family",
+    tooltip: "",
+    rules: "conditional",
+    conditions: [{ key: "switch", section: "styles", value: true }],
+  },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "roku font size",
+    tooltip: "",
+    rules: "conditional",
+    conditions: [{ key: "switch", section: "styles", value: true }],
+  },
+  {
+    type: ZAPPIFEST_FIELDS.number_input,
+    suffix: "roku line height",
+    tooltip: "",
+    rules: "conditional",
+    conditions: [{ key: "switch", section: "styles", value: true }],
+  },
   {
     type: ZAPPIFEST_FIELDS.select,
     suffix: "text alignment",

package/manifestUtils/sharedConfiguration/screenPicker/utils.js

@@ -3,6 +3,7 @@ const defaultPlatforms = {
   android_tv: "Android TV",
   lg_tv: "LG TV",
   samsung_tv: "Samsung TV",
+  roku: "Roku TV",
 };
 
 const global_defaults = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "15.0.0-alpha.2413435535",
+  "version": "15.0.0-alpha.2535277107",
   "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": "15.0.0-alpha.2413435535",
+    "@applicaster/applicaster-types": "15.0.0-alpha.2535277107",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/playerUtils/usePlayerTTS.ts

@@ -1,14 +1,16 @@
 import * as React from "react";
 import { usePlayer } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer";
-import { useAccessibilityManager } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager/hooks";
+import {
+  useAccessibilityManager,
+  useAccessibilityState,
+} from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager/hooks";
 import { PlayerTTS } from "@applicaster/zapp-react-native-utils/playerUtils/PlayerTTS";
 
 export const usePlayerTTS = () => {
   const player = usePlayer();
   const accessibilityManager = useAccessibilityManager({});
-
-  const isScreenReaderEnabled =
-    accessibilityManager.accessibilityManagerState.screenReaderEnabled;
+  const accessibilityState = useAccessibilityState();
+  const isScreenReaderEnabled = accessibilityState.screenReaderEnabled;
 
   React.useEffect(() => {
     if (player && accessibilityManager && isScreenReaderEnabled) {

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -147,17 +147,34 @@ export class TVSeekController
 
     let targetPos = currentPos;
 
-    if (this.currentSeekType === SEEK_TYPE.FORWARD) {
-      targetPos = Math.min(
-        currentPos + offset,
-        this.playerController.getSeekableDuration()
-      );
-    } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
-      targetPos = Math.max(0, currentPos - offset);
+    const isLive = this.playerController.isLive();
+
+    if (isLive) {
+      if (this.currentSeekType === SEEK_TYPE.REWIND) {
+        targetPos = Math.min(
+          currentPos + offset,
+          this.playerController.getSeekableDuration()
+        );
+      } else if (this.currentSeekType === SEEK_TYPE.FORWARD) {
+        targetPos = Math.max(0, currentPos - offset);
+      } else {
+        log_warning(
+          `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+        );
+      }
     } else {
-      log_warning(
-        `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
-      );
+      if (this.currentSeekType === SEEK_TYPE.FORWARD) {
+        targetPos = Math.min(
+          currentPos + offset,
+          this.playerController.getSeekableDuration()
+        );
+      } else if (this.currentSeekType === SEEK_TYPE.REWIND) {
+        targetPos = Math.max(0, currentPos - offset);
+      } else {
+        log_warning(
+          `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+        );
+      }
     }
 
     log_debug(