@applicaster/zapp-react-native-utils 13.0.0-alpha.6525006318 → 13.0.0-alpha.7210171818

package/appUtils/keyCodes/keysByPlatform.js

@@ -77,6 +77,9 @@ const web = {
   Exit: { code: "Exit", keyCode: null },
   Escape: { code: "Escape", keyCode: 27 },
   EscapeDevice: { code: "Escape", keyCode: 27 },
+  Z: { code: "KeyZ", keyCode: 90 },
+  X: { code: "KeyX", keyCode: 88 },
+  C: { code: "KeyC", keyCode: 67 },
 };
 
 const android_tv = {

package/appUtils/keyInputHandler/KeyInputHandler.ts

@@ -0,0 +1,90 @@
+
+export type SeekKeyHandlerListener = {
+  onRewindPress: () => boolean;
+  // onRewindLongPress: () => boolean;
+  onForwardPress: () => boolean;
+  // onForwardLongPress: () => boolean;
+  onRewindPressOut: () => void;
+  onForwardPressOut: () => void;
+}
+
+export class KeyInputHandler {
+  private static instance: KeyInputHandler;
+
+  public static getInstance() {
+    if (!KeyInputHandler.instance) {
+      KeyInputHandler.instance = new KeyInputHandler();
+    }
+
+    return KeyInputHandler.instance;
+  }
+
+  constructor() {
+    this.listeners = [];
+  }
+
+  private listeners: SeekKeyHandlerListener[] = [];
+
+  addListener = (listener: SeekKeyHandlerListener) => {
+    this.listeners.splice(0, 0, listener);
+
+    return () =>
+      this.removeListener(listener);
+  }
+
+  removeListener = (listener: SeekKeyHandlerListener) => {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+  }
+
+  onRewindPress = () => {
+    for (const element of this.listeners) {
+      if (element.onRewindPress()) {
+        break;
+      }
+    }
+  }
+
+  // onRewindLongPress = () => {
+  //   for (const element of this.listeners) {
+  //     if (element.onRewindLongPress()) {
+  //       break;
+  //     }
+  //   }
+  // }
+
+  onForwardPress = () => {
+    for (const element of this.listeners) {
+      if (element.onForwardPress()) {
+        break;
+      }
+    }
+  }
+
+  // onForwardLongPress = () => {
+  //   for (const element of this.listeners) {
+  //     if (element.onForwardLongPress()) {
+  //       break;
+  //     }
+  //   }
+  // }
+
+  // TODO: Event should be send to listeners who handled down event
+  onRewindPressOut = () => {
+    this.listeners.forEach((listener) => listener.onRewindPressOut());
+  }
+
+  onForwardPressOut = () => {
+    this.listeners.forEach((listener) => listener.onForwardPressOut());
+  }
+
+  getSeekMethods = () => {
+    return {
+      onForwardPress: this.onForwardPress,
+      onRewindPress: this.onRewindPress,
+      // onForwardLongPress: this.onForwardLongPress,
+      // onRewindLongPress: this.onRewindLongPress,
+      onForwardPressOut: this.onForwardPressOut,
+      onRewindPressOut: this.onRewindPressOut
+    };
+  }
+}

package/appUtils/playerManager/DelayedSeekPlayerWrapper.tsx

@@ -0,0 +1,180 @@
+import { Player } from "./player";
+import { BehaviorSubject } from "rxjs";
+
+export class DelayedSeekPlayerWrapper extends Player {
+  private wrappedPlayer: Player;
+  private delayedSeekPosition: number;
+  private wasPlaying: boolean;
+
+  constructor(props, player: Player) {
+    super(props);
+    this.wrappedPlayer = player;
+    this.delayedSeekPosition = null;
+
+    this.wrappedPlayer.addListener({
+      id: "Master-Wrapper-Listener",
+      listener: this,
+    });
+
+    this.onPlayerSeekComplete = this.onPlayerSeekComplete.bind(this);
+  }
+
+  getOverlayObservable = () => {
+    return this.wrappedPlayer.getOverlayObservable();
+  };
+
+  getEntryObservable = (): BehaviorSubject<ZappEntry | null> => {
+    return this.wrappedPlayer.getEntryObservable();
+  };
+
+  getEntry = (): ZappEntry | null => this.wrappedPlayer.getEntry();
+
+  getListener = (): QuickBrickPlayer.SharedPlayerCallBacks => {
+    return this.wrappedPlayer.getListener();
+  };
+
+  togglePlayPause = () => {
+    this.wrappedPlayer.togglePlayPause();
+  };
+
+  selectTrack = (_track) => this.wrappedPlayer.selectTrack(_track);
+
+  // Implement all default methods by delegating them to wrapped player
+  public seekTo = (position: number) => {
+    this.wrappedPlayer.seekTo(position);
+  };
+
+  public isPlaying = () => {
+    return this.wrappedPlayer.isPlaying();
+  };
+
+  public isPaused = () => {
+    return this.wrappedPlayer.isPaused();
+  };
+
+  public play = () => {
+    this.wrappedPlayer.play();
+  };
+
+  public pause = () => {
+    this.wrappedPlayer.pause();
+  };
+
+  getState = () => {
+    const currentState = this.wrappedPlayer.getState();
+
+    if (this.delayedSeekPosition === null) {
+      return currentState;
+    }
+
+    return {
+      ...currentState,
+      contentPosition: this.delayedSeekPosition,
+      isPaused: false,
+      seekPosition: this.delayedSeekPosition,
+    };
+  };
+
+  forward = (deltaTime: number) => {
+    if (this.delayedSeekPosition !== null) {
+      this.delayedSeekPosition += deltaTime;
+      this.playerState.seekPosition = this.delayedSeekPosition;
+
+      this.onVideoProgress({
+        currentTime: this.playerState.seekPosition,
+        duration: this.getDuration(),
+        seekableDuration: this.playerState.seekableDuration,
+        isLive: this.playerState.isLive,
+      });
+
+      // this.scheduleResumePlayback(DELAYED_SEEK_DELAY, this.delayedSeekPosition);
+
+      return;
+    }
+
+    if (this.playerState.seekPosition == null) {
+      this.playerState.seekPosition = this.playerState.contentPosition;
+    }
+
+    this.playerState.seekPosition += deltaTime;
+
+    this.wrappedPlayer.forward(deltaTime);
+  };
+
+  rewind = (deltaTime: number) => {
+    if (this.delayedSeekPosition !== null) {
+      this.delayedSeekPosition -= deltaTime;
+
+      if (this.delayedSeekPosition < 0) {
+        this.delayedSeekPosition = 0;
+      }
+
+      this.playerState.seekPosition = this.delayedSeekPosition;
+
+      this.onVideoProgress({
+        currentTime: this.playerState.seekPosition,
+        duration: this.getDuration(),
+        seekableDuration: this.playerState.seekableDuration,
+        isLive: this.playerState.isLive,
+      });
+
+      // this.scheduleResumePlayback(DELAYED_SEEK_DELAY, this.delayedSeekPosition);
+
+      return;
+    }
+
+    if (this.playerState.seekPosition == null) {
+      this.playerState.seekPosition = this.playerState.contentPosition;
+    }
+
+    this.playerState.seekPosition -= deltaTime;
+    this.wrappedPlayer.rewind(deltaTime);
+  };
+
+  public getConfig = () => this.wrappedPlayer.getConfig();
+
+  // TODO: replace with enum of supported orientations
+  isFullScreenSupported(): boolean {
+    return this.wrappedPlayer.isFullScreenSupported();
+  }
+
+  public supportsNativeControls = (): boolean =>
+    this.wrappedPlayer.supportsNativeControls();
+
+  public supportNativeCast = (): boolean =>
+    this.wrappedPlayer.supportNativeCast();
+
+  public isInDelayedSeek = () => this.delayedSeekPosition !== null;
+
+  public enterDelayedSeek() {
+    if (this.delayedSeekPosition !== null) {
+      return;
+    }
+
+    if (this.playerState.seekPosition === null) {
+      this.playerState.seekPosition = this.playerState.contentPosition;
+    }
+
+    this.delayedSeekPosition = this.playerState.seekPosition;
+
+    if (!this.isPaused()) {
+      this.wasPlaying = true;
+      this.wrappedPlayer.pause();
+    }
+  }
+
+  public exitDelayedSeek() {
+    if (this.delayedSeekPosition === null) {
+      return;
+    }
+
+    this.wrappedPlayer.seekTo(this.delayedSeekPosition);
+
+    if (this.wasPlaying) {
+      this.wasPlaying = false;
+      this.wrappedPlayer.play();
+    }
+
+    this.delayedSeekPosition = null;
+  }
+}

package/appUtils/playerManager/player.ts

@@ -5,6 +5,7 @@ import { createLogger, utilsLogger } from "../../logger";
 import { getBoolFromConfigValue } from "../../configurationUtils";
 import { PlayerRole, SharedPlayerCallBacksKeys } from "./conts";
 import { OverlaysObserver } from "./OverlayObserver/OverlaysObserver";
+import { TVSeekController } from "../../reactHooks/player/TVSeekControlller/TVSeekController";
 
 const logger = createLogger({
   category: "PlayerController",
@@ -49,6 +50,8 @@ export class Player {
     [key: string]: QuickBrickPlayer.SharedPlayerCallBacks;
   } = {};
 
+  public seekController?: TVSeekController | null;
+
   get entry(): ZappEntry | null {
     return this._entry;
   }
@@ -59,6 +62,8 @@ export class Player {
   }
 
   constructor(props) {
+    this.seekController = null;
+
     this.playerState = {
       // We want isLive null by default to be able not to show controls if we do not know type
       isLive: null,
@@ -91,6 +96,8 @@ export class Player {
     this.onVideoProgress = this.onVideoProgress.bind(this);
     this.onVideoLoad = this.onVideoLoad.bind(this);
     this.isFullScreenSupported = this.isFullScreenSupported.bind(this);
+    this.onPlayerSeekComplete = this.onPlayerSeekComplete.bind(this);
+
     this.entryObservable = null;
   }
 
@@ -321,7 +328,7 @@ export class Player {
    * You should use dispatchPlayerEvent at PlayerContainer or call playerManager.invokeHandler directly
    * This allows you to use one method for everything.
    */
-  onSeekStart = (event: QuickBrickPlayer.OnSeekStartEvent) => {
+  onPlayerSeekStart = (event: QuickBrickPlayer.OnSeekStartEvent) => {
     const { isLive, seekableDuration, currentTime, duration, seekTime } = event;
 
     this.setPlaybackState({ currentTime, duration, seekableDuration, isLive });
@@ -336,10 +343,11 @@ export class Player {
     });
   };
 
-  onSeekComplete = (event: QuickBrickPlayer.OnSeekCompleteEvent) => {
+  onPlayerSeekComplete(event: QuickBrickPlayer.OnSeekCompleteEvent) {
     const { isLive, seekableDuration, currentTime, duration } = event;
 
     this.setPlaybackState({ currentTime, duration, seekableDuration, isLive });
+
     this.playerState.seekPosition = null;
 
     if (!isLive) {
@@ -350,7 +358,7 @@ export class Player {
       callbackName: SharedPlayerCallBacksKeys.OnPlayerSeekComplete,
       event,
     });
-  };
+  }
 
   onVideoEnd = (event) => {
     this.invokeListenersUpdate({
@@ -653,8 +661,8 @@ export class Player {
   };
 
   public getListener = (): QuickBrickPlayer.SharedPlayerCallBacks => ({
-    onPlayerSeekStart: this.onSeekStart,
-    onPlayerSeekComplete: this.onSeekComplete,
+    onPlayerSeekStart: this.onPlayerSeekStart,
+    onPlayerSeekComplete: this.onPlayerSeekComplete,
     onVideoEnd: this.onVideoEnd,
     onError: this.onError,
     onVideoError: this.onVideoError,
@@ -733,5 +741,10 @@ export class Player {
 
   public supportsNativeControls = (): boolean => false;
   public supportNativeCast = (): boolean => false;
+
+  public isInDelayedSeek = (): boolean => false;
+  public enterDelayedSeek() {}
+
+  public exitDelayedSeek() {}
   public destroy = () => {};
 }

package/appUtils/playerManager/playerNative.ts

@@ -222,9 +222,10 @@ export class PlayerNative extends Player {
 
   onVideoLoad = (event) => {
     if (this.startPosition) {
-      super.onVideoLoad({ ...event, ignoreContinueWatching: true });
       this.seekTo(this.startPosition);
       this.startPosition = null;
+
+      super.onVideoLoad({ ...event, ignoreContinueWatching: true });
     } else {
       super.onVideoLoad(event);
     }

package/appUtils/playerManager/usePlayerControllerSetup.tsx

@@ -5,6 +5,8 @@ import { playerManager } from "./index";
 import { useValidatePlayerConfig } from "../../playerUtils/useValidatePlayerConfig";
 import { PlayerRole } from "./conts";
 import { isAppleTV } from "@applicaster/zapp-react-native-ui-components/Helpers/Platform";
+import { isTV } from "../../reactUtils";
+import { DelayedSeekPlayerWrapper } from "./DelayedSeekPlayerWrapper";
 
 // TODO: Rename to ControllerType
 export const usePlayerControllerSetup = ({
@@ -39,7 +41,7 @@ export const usePlayerControllerSetup = ({
       ? { supports_native_controls: true, ...config }
       : config;
 
-    const newPlayerController = new ControllerType({
+    const combinedProps = {
       player: ref,
       listener: props as any,
       config: newConfig,
@@ -47,9 +49,21 @@ export const usePlayerControllerSetup = ({
       entry,
       playerPluginId: pluginId,
       playerRole: PlayerRole.Primary,
-    });
+    };
 
-    setPlayerController(newPlayerController);
+    if (isTV()) {
+      const wrappedPlayerController = new ControllerType({
+        ...combinedProps,
+        playerRole: PlayerRole.Unspecified,
+        playerId: playerId + "." + "wrapped",
+      });
+
+      setPlayerController(
+        new DelayedSeekPlayerWrapper(combinedProps, wrappedPlayerController)
+      );
+    } else {
+      setPlayerController(new ControllerType(combinedProps));
+    }
   }, [playerId, entry?.id]);
 
   React.useEffect(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "13.0.0-alpha.6525006318",
+  "version": "13.0.0-alpha.7210171818",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.6525006318",
+    "@applicaster/applicaster-types": "13.0.0-alpha.7210171818",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

package/reactHooks/feed/__tests__/useFeedLoader.test.tsx

@@ -135,7 +135,11 @@ describe("useFeedLoader", () => {
       );
 
       expect(result.current.data).toBeNull();
-      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {});
+
+      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
+        clearCache: true,
+        riverId: undefined,
+      });
 
       const store2 = mockStore({
         plugins: [],
@@ -172,7 +176,11 @@ describe("useFeedLoader", () => {
       );
 
       expect(result.current.data).toBeNull();
-      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {});
+
+      expect(loadPipesDataSpy).toBeCalledWith(feedUrl, {
+        clearCache: true,
+        riverId: undefined,
+      });
 
       const store2 = mockStore({
         plugins: [],

package/reactHooks/feed/useFeedLoader.tsx

@@ -5,7 +5,7 @@ import { loadPipesData } from "@applicaster/zapp-react-native-redux/ZappPipes";
 import { useZappPipesFeed } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { reactHooksLogger } from "../logger";
-import { useIsInitialRender, shouldUseCachedData } from "../utils";
+import { useIsInitialRender, shouldDispatchData } from "../utils";
 import { useInflatedUrl } from "./useInflatedUrl";
 import { useRoute } from "../navigation";
 
@@ -89,13 +89,18 @@ export const useFeedLoader = ({
     }
   }, [callableFeedUrl, currentFeed?.data]);
 
-  // If feed doesn't exist, load it
   useEffect(() => {
     if (
-      shouldUseCachedData(callableFeedUrl, currentFeed, pipesOptions.clearCache)
+      shouldDispatchData(callableFeedUrl, currentFeed, pipesOptions.clearCache)
     ) {
       if (callableFeedUrl) {
-        dispatch(loadPipesData(callableFeedUrl, { ...pipesOptions, riverId }));
+        dispatch(
+          loadPipesData(callableFeedUrl, {
+            ...pipesOptions,
+            clearCache: true,
+            riverId,
+          })
+        );
       } else {
         logger.info({
           message:

package/reactHooks/player/TVSeekControlller/ISeekController.ts

@@ -0,0 +1,7 @@
+import { SEEK_TYPE } from "../const";
+
+export interface ISeekController {
+  onStartSeek(seekType: SEEK_TYPE): void;
+  onSeekEnd?(): void;
+  reset(): void;
+}

package/reactHooks/player/TVSeekControlller/LongPressSeekController.ts

@@ -0,0 +1,106 @@
+import { ISeekController } from "./ISeekController";
+import { SEEK_TYPE } from "../const";
+import {
+  log_debug,
+  log_error,
+  log_verbose,
+  TVSeekController,
+} from "./TVSeekController";
+import { interval, Subscription } from "rxjs";
+import { tap } from "rxjs/operators";
+
+/**
+ * Example interface for the configuration needed for long-press seeking.
+ */
+interface LongPressConfig {
+  LONG_PRESS_THRESHOLD: number; // ms
+  TIMER_INTERVAL_MS: number; // ms
+  SKIP_INCREMENT_STEP: number; // seconds
+  MAX_SKIP_PER_TICK: number; // seconds
+  INITIAL_SKIP_AMOUNT: number; // e.g., 10s to start
+}
+
+export class LongPressSeekController implements ISeekController {
+  private pressStartTime = 0;
+  private isLongPressActive = false;
+  private currentSkipAmount = 0;
+  private subscription: Subscription | null = null;
+
+  constructor(
+    private parent: TVSeekController,
+    private config: LongPressConfig
+  ) {}
+
+  onStartSeek(seekType: SEEK_TYPE) {
+    this.cleanUpSubscription();
+
+    log_debug(
+      `LongPressSeekController: start long press seek type:${seekType}.`
+    );
+
+    this.parent.currentSeekType = seekType;
+    this.parent.pausePlayer();
+
+    this.pressStartTime = Date.now();
+    this.isLongPressActive = true;
+    this.currentSkipAmount = this.config.INITIAL_SKIP_AMOUNT;
+
+    // Start the interval immediately without waiting for a threshold.
+    this.subscription = interval(this.config.TIMER_INTERVAL_MS).pipe(
+      tap(() => {
+        this.parent.handleDelayedSeek(
+          this.parent.currentSeekType,
+          this.currentSkipAmount
+        );
+
+        log_debug(
+          `LongPressSeekController: handle delayed seek type: ${seekType} - currentSkipAmount: ${this.currentSkipAmount}.`
+        );
+
+        this.currentSkipAmount = Math.min(
+          this.currentSkipAmount + this.config.SKIP_INCREMENT_STEP,
+          this.config.MAX_SKIP_PER_TICK
+        );
+      })
+    ).subscribe({
+      complete: () =>
+        log_verbose("LongPressSeekController: Long press subscription complete"),
+      error: (err) =>
+        log_error("LongPressSeekController: Long press subscription error", err),
+    });
+  }
+
+  onSeekEnd() {
+    const pressDuration = Date.now() - this.pressStartTime;
+
+    if (
+      this.isLongPressActive &&
+      pressDuration > this.config.LONG_PRESS_THRESHOLD
+    ) {
+      const offset = this.parent.delayedSeekOffset;
+
+      if (offset) {
+        log_debug(
+          `LongPressSeekController: onPressEnd for LongPressSeekController, seek offset: ${offset}`
+        );
+
+        this.parent.seekPlayer(offset);
+      }
+    }
+
+    this.parent.resetAll();
+  }
+
+  reset() {
+    this.isLongPressActive = false;
+    this.currentSkipAmount = 0;
+    this.cleanUpSubscription();
+  }
+
+  private cleanUpSubscription() {
+    if (this.subscription) {
+      this.subscription.unsubscribe();
+      this.subscription = null;
+    }
+  }
+}

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -0,0 +1,199 @@
+import { BehaviorSubject } from "rxjs";
+import { TapSeekController } from "./TapSeekController";
+import { LongPressSeekController } from "./LongPressSeekController";
+import { playerManager } from "../../../appUtils";
+import { SEEK_TYPE } from "../const";
+import { createLogger } from "../../../logger";
+import { Player } from "../../../appUtils/playerManager/player";
+import { SeekKeyHandlerListener } from "../../../appUtils/keyInputHandler/KeyInputHandler";
+import { ISeekController } from "./ISeekController";
+
+export const { log_warning, log_debug, log_info, log_error, log_verbose } =
+  createLogger({
+    category: "General",
+    subsystem: "TVSeekController",
+  });
+
+export enum SEEK_STRATEGY {
+  TAP_SEEK = "TAP_SEEK",
+  AUTO_SEEK = "AUTO_SEEK",
+}
+
+export class TVSeekController implements SeekKeyHandlerListener {
+  // -- SHARED STATE ACROSS STRATEGIES --
+  public currentSeekType: SEEK_TYPE | null = null;
+  public delayedSeekOffset: number | null = null;
+  private controller: Player;
+  private delayedSeekProgressSubject = new BehaviorSubject<number | null>(null);
+
+  private currentSeekController: ISeekController;
+
+  // -- STRATEGY INSTANCES --
+  private tapSeekController: TapSeekController;
+  private longPressSeekController: LongPressSeekController;
+  private longPressThresholdTimeout: any | null = null;
+
+  // Example config for long press
+  private config = {
+    LONG_PRESS_THRESHOLD: 500,
+    TIMER_INTERVAL_MS: 300,
+    SKIP_INCREMENT_STEP: 5,
+    MAX_SKIP_PER_TICK: 300,
+    INITIAL_SKIP_AMOUNT: 10,
+  };
+
+  constructor(controller: Player) {
+    this.controller = controller;
+    this.tapSeekController = new TapSeekController(this);
+
+    this.longPressSeekController = new LongPressSeekController(
+      this,
+      this.config
+    );
+  }
+
+  getDelayedSeekProgressObservable = () => {
+    return this.delayedSeekProgressSubject;
+  }
+
+  setStrategy = (seekStrategy: SEEK_STRATEGY) => {
+    switch (seekStrategy) {
+      case SEEK_STRATEGY.TAP_SEEK:
+        clearTimeout(this.longPressThresholdTimeout);
+        this.longPressThresholdTimeout = null;
+        this.currentSeekController = this.tapSeekController;
+
+        break;
+      case SEEK_STRATEGY.AUTO_SEEK:
+        this.currentSeekController.reset();
+        this.currentSeekController = this.longPressSeekController;
+        break;
+      default:
+    }
+  }
+
+  handleStartSeek = (seekType: SEEK_TYPE) => {
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
+    this.currentSeekController.onStartSeek(seekType);
+    log_verbose(`handleStartSeek: TAP seekType: ${seekType}`);
+
+    this.longPressThresholdTimeout = setTimeout(() => {
+      log_verbose(`handleStartSeek: longPressThresholdTimeout:  TIMEOUT, START AUTO_SEEK seekType: ${seekType}`);
+     this.setStrategy(SEEK_STRATEGY.AUTO_SEEK);
+      this.currentSeekController.onStartSeek(seekType);
+    }, this.config.LONG_PRESS_THRESHOLD);
+  }
+
+  onForwardPress = (): boolean => {
+    this.handleStartSeek(SEEK_TYPE.FORWARD);
+
+    return true;
+  };
+
+  onRewindPress = (): boolean => {
+    this.handleStartSeek(SEEK_TYPE.REWIND);
+
+    return true;
+  };
+
+  onSeekEnd = () => {
+    this.currentSeekController.onSeekEnd();
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
+  }
+
+  onRewindPressOut = () => {
+    const isAutoSeek = this.currentSeekController === this.longPressSeekController;
+
+    log_verbose(`handleStartSeek: onRewindPressOut, isAutoSeek: ${isAutoSeek}`);
+
+    this.onSeekEnd();
+  }
+
+  onForwardPressOut = () => {
+    const isAutoSeek = this.currentSeekController === this.longPressSeekController;
+
+    log_verbose(`handleStartSeek: onForwardPressOut, isAutoSeek: ${isAutoSeek}`);
+    this.onSeekEnd();
+  }
+
+  // ---------------------------
+  // SHARED METHODS
+  // ---------------------------
+
+  /** Called by either strategy to accumulate offset while paused. */
+  handleDelayedSeek(eventType: SEEK_TYPE, skipTime: number) {
+    const player = this.getPlayer();
+    if (!player) return;
+
+    // If not previously delayed, we pause the first time
+    if (this.delayedSeekOffset === null) {
+      this.pausePlayer();
+    }
+
+    const newOffset = (this.delayedSeekOffset || 0) + skipTime;
+    const currentPos = player.getPosition();
+    let targetPos = currentPos;
+
+    if (eventType === SEEK_TYPE.FORWARD) {
+      targetPos = Math.min(currentPos + newOffset, player.getDuration());
+    } else {
+      targetPos = Math.max(0, currentPos - newOffset);
+    }
+
+    this.delayedSeekOffset = newOffset;
+
+    log_debug(
+      `TVSeekController: handleDelayedSeek - targetPos: ${targetPos}, offset: ${newOffset}, skipTime: ${skipTime}`
+    );
+
+    this.delayedSeekProgressSubject.next(targetPos);
+  }
+
+  seekPlayer(offset: number) {
+    const player = this.getPlayer();
+    if (!player || !this.currentSeekType) return;
+    player[this.currentSeekType](offset);
+    this.playerPlay();
+  }
+
+  playerPlay() {
+    const player = this.getPlayer();
+    if (!player) return;
+
+    if (player.isPaused()) {
+      player.play();
+    }
+  }
+
+  pausePlayer() {
+    const player = this.getPlayer();
+    if (!player) return;
+    player.pause();
+  }
+
+  /**
+   * Reset *all* relevant state and strategy controllers
+   */
+  resetAll() {
+    log_debug("TVSeekController: Reset all states");
+    this.currentSeekType = null;
+    this.delayedSeekOffset = null;
+
+    this.delayedSeekProgressSubject.next(null);
+
+    this.tapSeekController.reset();
+    this.longPressSeekController.reset();
+
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
+  }
+
+  private getPlayer() {
+    const player = playerManager.getInstanceController();
+
+    if (!player) {
+      log_warning("TVSeekController: No valid player controller found");
+    }
+
+    return player;
+  }
+}

package/reactHooks/player/TVSeekControlller/TapSeekController.ts

@@ -0,0 +1,75 @@
+import { ISeekController } from "./ISeekController";
+import { SEEK_TYPE, MAX_SEEK_TIME, SKIP_TIME_BASE } from "../const";
+import { log_debug, TVSeekController } from "./TVSeekController";
+
+const getSkipTime = (multiplier: number) =>
+  Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
+
+export class TapSeekController implements ISeekController {
+  private tapSequenceTimeout: any | null = null;
+  private seekMultiplier = 1;
+  private readonly ON_PRESS_RESET_DURATION = 500; // ms
+
+  constructor(private parent: TVSeekController) {}
+
+  onStartSeek = (seekType: SEEK_TYPE) => {
+    log_debug(`TapSeekController: start tap seek type: ${seekType}.`);
+
+    const prevSeekType = this.parent.currentSeekType;
+
+    if (prevSeekType !== seekType) {
+      this.reset();
+    }
+
+    this.parent.currentSeekType = seekType;
+
+    if (this.tapSequenceTimeout) {
+      clearTimeout(this.tapSequenceTimeout);
+      this.tapSequenceTimeout = null;
+    }
+
+    const clicksBeforePause = 0;
+    const skipTime = getSkipTime(this.seekMultiplier);
+
+    if (this.seekMultiplier > clicksBeforePause) {
+      log_debug(
+        `TapSeekController: handle delayed seek type:${seekType} - skipTime: ${skipTime}.`
+      );
+
+      this.parent.handleDelayedSeek(seekType, skipTime);
+    } else {
+      log_debug(
+        `TapSeekController: handle seek type:${seekType} - skipTime: ${skipTime}.`
+      );
+
+      this.parent.seekPlayer(skipTime);
+    }
+
+    this.seekMultiplier++;
+  }
+
+  onSeekEnd = () => {
+    this.tapSequenceTimeout = setTimeout(() => {
+      if (this.parent.delayedSeekOffset !== null) {
+        this.parent.seekPlayer(this.parent.delayedSeekOffset);
+      }
+
+      log_debug(
+        `TapSeekController: Tap sequence timeout fired, delayedSeekOffset: ${this.parent.delayedSeekOffset}.`
+      );
+
+      this.parent.resetAll();
+    }, this.ON_PRESS_RESET_DURATION);
+  };
+
+  reset = () => {
+    log_debug("TapSeekController: Reset states");
+
+    this.seekMultiplier = 1;
+
+    if (this.tapSequenceTimeout) {
+      clearTimeout(this.tapSequenceTimeout);
+      this.tapSequenceTimeout = null;
+    }
+  }
+}

package/reactHooks/player/const.ts

@@ -4,7 +4,7 @@ export const ON_PRESS_RESET_DURATION = 2000;
 
 export const ON_HOLD_INTERVAL = 500;
 
-export const MAX_SEEK_TIME = 600;
+export const MAX_SEEK_TIME = 60;
 
 export enum SEEK_TYPE {
   FORWARD = "forward",

package/reactHooks/player/index.ts

@@ -1,7 +1 @@
 export { useLanguageData } from "./useLanguageData";
-
-export { useAutoSeek } from "./useAutoSeek";
-
-export { useTapSeek } from "./useTapSeek";
-
-export { useSeek, withUseSeek } from "./useSeek";

package/reactHooks/utils/index.ts

@@ -33,7 +33,7 @@ export const useIsInitialRender = (): boolean => {
 
 export const checkIsLocalFeed = (feedUrl) => feedUrl?.startsWith("pipesv2://");
 
-export const shouldUseCachedData = (
+export const shouldDispatchData = (
   url: string,
   feed: ZappPipesData | null,
   clearCache: boolean

package/reactHooks/player/__tests__/useAutoSeek.test.tsx

@@ -1,116 +0,0 @@
-import { act, renderHook } from "@testing-library/react-hooks";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
-
-import { ON_HOLD_INTERVAL, SEEK_TYPE, SKIP_TIME_BASE } from "../const";
-
-import { useAutoSeek } from "../useAutoSeek";
-
-jest.useFakeTimers();
-
-const rewind = jest.fn();
-const forward = jest.fn();
-
-jest
-  .spyOn(playerManager, "getInstanceController")
-  // @ts-ignore
-  .mockImplementation(() => ({ rewind, forward }));
-
-describe("useAutoSeek", () => {
-  beforeEach(() => {
-    rewind.mockReset();
-    forward.mockReset();
-  });
-
-  describe("autoSeekStart", () => {
-    it("should call forward method on playerInstance", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalled();
-      result.current.autoSeekStop();
-    });
-
-    it("should call rewind method on playerManager", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.REWIND);
-      });
-
-      expect(rewind).toBeCalled();
-      result.current.autoSeekStop();
-    });
-
-    it("should call rewind with default skip time", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.REWIND);
-      });
-
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-      result.current.autoSeekStop();
-    });
-
-    it("should call forward with default skip time", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-      result.current.autoSeekStop();
-    });
-
-    it("should call rewind in intervals set in configuration", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.REWIND);
-      });
-
-      expect(rewind).toBeCalled();
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(rewind).toBeCalledTimes(4);
-      result.current.autoSeekStop();
-    });
-
-    it("should call forward in intervals set in configuration", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalled();
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(forward).toBeCalledTimes(4);
-      result.current.autoSeekStop();
-    });
-  });
-
-  describe("autoSeekStop", () => {
-    it("should stop calling playerManager method after autoSeekStop is called", () => {
-      const { result } = renderHook(() => useAutoSeek());
-
-      act(() => {
-        result.current.autoSeekStart(SEEK_TYPE.FORWARD);
-      });
-
-      expect(forward).toBeCalled();
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(forward).toBeCalledTimes(4);
-
-      act(() => {
-        result.current.autoSeekStop();
-      });
-
-      jest.advanceTimersByTime(ON_HOLD_INTERVAL * 3);
-      expect(forward).toBeCalledTimes(4);
-    });
-  });
-});

package/reactHooks/player/__tests__/useTapSeek.test.ts

@@ -1,94 +0,0 @@
-import { renderHook } from "@testing-library/react-hooks";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
-import { useTapSeek } from "../useTapSeek";
-
-import { ON_PRESS_RESET_DURATION, SEEK_TYPE, SKIP_TIME_BASE } from "../const";
-
-const rewind = jest.fn();
-const forward = jest.fn();
-
-jest
-  .spyOn(playerManager, "getInstanceController")
-  // @ts-ignore
-  .mockImplementation(() => ({ rewind, forward }));
-
-describe("useTapSeek", () => {
-  beforeEach(() => {
-    rewind.mockReset();
-    forward.mockReset();
-  });
-
-  describe("forward", () => {
-    it("should call forward method on playerManager", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalled();
-    });
-
-    it("should call forward with default skip time", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-    });
-
-    it("should multiply skip time for every call", async () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE * 2);
-    });
-
-    it("should reset multiplier if waiting more then resetDuration between press actions", () => {
-      const { result, waitFor } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-      waitFor(jest.fn(), { timeout: ON_PRESS_RESET_DURATION });
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-    });
-  });
-
-  describe("rewind", () => {
-    it("should call rewind method on playerManager", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalled();
-    });
-
-    it("should call rewind with default skip time", () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-    });
-
-    it("should multiply skip time for every call", async () => {
-      const { result } = renderHook(() => useTapSeek());
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE * 2);
-    });
-  });
-
-  describe("mixed usage", () => {
-    it("should reset timer if different type of event is emitted", () => {
-      const { result } = renderHook(() => useTapSeek());
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE);
-
-      result.current(SEEK_TYPE.REWIND);
-      expect(rewind).toBeCalledWith(SKIP_TIME_BASE * 2);
-
-      result.current(SEEK_TYPE.FORWARD);
-      expect(forward).toBeCalledWith(SKIP_TIME_BASE);
-    });
-  });
-});

package/reactHooks/player/useAutoSeek.tsx

@@ -1,87 +0,0 @@
-import React, { useEffect, useState } from "react";
-import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
-import {
-  MAX_SEEK_TIME,
-  ON_HOLD_INTERVAL,
-  SEEK_TYPE,
-  SKIP_TIME_BASE,
-} from "./const";
-import { noop } from "../../functionUtils";
-
-export const useAutoSeek = (resetHUDTimer = noop) => {
-  const [isRunning, setIsRunning] = useState<boolean>(false);
-  const [direction, setDirection] = useState<Nullable<SEEK_TYPE>>(null);
-  const [multiplier, setMultiplier] = useState(1);
-  const intervalTimer = React.useRef(null);
-  const prevRunning = usePrevious(isRunning);
-
-  const clearIntervalTimer = () => {
-    try {
-      clearInterval(intervalTimer.current);
-    } catch (err) {
-      intervalTimer.current = null;
-    }
-  };
-
-  const setIntervalTimer = (cb) => {
-    clearIntervalTimer();
-    intervalTimer.current = setInterval(cb, ON_HOLD_INTERVAL);
-  };
-
-  const resetState = () => {
-    setIsRunning(false);
-    setDirection(null);
-    setMultiplier(1);
-    clearIntervalTimer();
-  };
-
-  useEffect(() => {
-    const player = playerManager.getInstanceController();
-
-    if (!player) return;
-
-    if (direction) {
-      player[direction](Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
-      resetHUDTimer();
-    }
-  }, [multiplier, direction]);
-
-  useEffect(() => {
-    if (isRunning && isRunning !== prevRunning) {
-      setIntervalTimer(() => {
-        setMultiplier((prev) => {
-          return prev + 1;
-        });
-      });
-    } else if (!isRunning && isRunning !== prevRunning) {
-      resetState();
-    }
-
-    return () => {
-      clearIntervalTimer();
-    };
-  }, [isRunning, direction]);
-
-  const autoSeekStop = React.useCallback(() => {
-    resetState();
-  }, []);
-
-  const autoSeekStart = React.useCallback(
-    (eventType: SEEK_TYPE) => {
-      // Check if there is another session running
-      if (isRunning) {
-        autoSeekStop();
-      }
-
-      setDirection(eventType);
-      setIsRunning(true);
-    },
-    [isRunning]
-  );
-
-  return React.useMemo(
-    () => ({ autoSeekStart, autoSeekStop }),
-    [autoSeekStart, autoSeekStop]
-  );
-};

package/reactHooks/player/useSeek.tsx

@@ -1,66 +0,0 @@
-import React from "react";
-import { SEEK_TYPE } from "./const";
-import { useTapSeek } from "./useTapSeek";
-import { useAutoSeek } from "./useAutoSeek";
-import { noop } from "../../functionUtils";
-
-export const useSeek = (resetHUDTimer = noop) => {
-  const handlePressEvent = useTapSeek();
-  const { autoSeekStart, autoSeekStop } = useAutoSeek(resetHUDTimer);
-
-  const onForwardPress = () => {
-    handlePressEvent(SEEK_TYPE.FORWARD);
-  };
-
-  const onRewindPress = () => {
-    handlePressEvent(SEEK_TYPE.REWIND);
-  };
-
-  const onForwardPressIn = () => {
-    autoSeekStart(SEEK_TYPE.FORWARD);
-  };
-
-  const onForwardPressOut = () => {
-    autoSeekStop();
-  };
-
-  const onRewindPressIn = () => {
-    autoSeekStart(SEEK_TYPE.REWIND);
-  };
-
-  const onRewindLongPress = () => {
-    autoSeekStart(SEEK_TYPE.REWIND);
-  };
-
-  const onForwardLongPress = () => {
-    autoSeekStart(SEEK_TYPE.FORWARD);
-  };
-
-  const onRewindPressOut = () => {
-    autoSeekStop();
-  };
-
-  return React.useMemo(
-    () => ({
-      onForwardPress,
-      onRewindPress,
-      onForwardPressIn,
-      onForwardPressOut,
-      onRewindPressIn,
-      onRewindPressOut,
-      onRewindLongPress,
-      onForwardLongPress,
-    }),
-    [handlePressEvent, autoSeekStart]
-  );
-};
-
-export const withUseSeek = (Component) =>
-  Object.assign(
-    (props) => {
-      const seekMethods = useSeek(props?.resetHUDTimer);
-
-      return <Component {...props} seekMethods={seekMethods} />;
-    },
-    { displayName: "WithUseSeek" }
-  );

package/reactHooks/player/useTapSeek.tsx

@@ -1,58 +0,0 @@
-import { useCallback, useRef } from "react";
-import * as R from "ramda";
-import {
-  MAX_SEEK_TIME,
-  ON_PRESS_RESET_DURATION,
-  SEEK_TYPE,
-  SKIP_TIME_BASE,
-} from "./const";
-import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
-
-type SeekType = SEEK_TYPE | null;
-
-const getSkipTime = (multiplier) => {
-  const skipTime = R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
-
-  return skipTime;
-};
-
-export const useTapSeek = () => {
-  const onPressMultiplier = useRef(1);
-  const lastPressTime = useRef(0);
-  const currentOnPressEventType = useRef<SeekType>(null);
-
-  const resetMultiplier = useCallback(() => {
-    onPressMultiplier.current = 1;
-  }, []);
-
-  const handlePressEvent = useCallback(
-    (eventType) => {
-      const player = playerManager.getInstanceController();
-      if (!player) return;
-
-      const now = Date.now();
-      const timeSinceLastPress = now - lastPressTime.current;
-      const isSameEventType = eventType === currentOnPressEventType.current;
-
-      const isWithinResetDuration =
-        timeSinceLastPress <= ON_PRESS_RESET_DURATION;
-
-      const shouldIncreaseMultiplier = isSameEventType && isWithinResetDuration;
-
-      if (shouldIncreaseMultiplier) {
-        onPressMultiplier.current += 1;
-      } else {
-        resetMultiplier();
-      }
-
-      const seekTime = getSkipTime(onPressMultiplier.current);
-      player[eventType](seekTime);
-
-      lastPressTime.current = now;
-      currentOnPressEventType.current = eventType;
-    },
-    [resetMultiplier]
-  );
-
-  return handlePressEvent;
-};