@applicaster/zapp-react-native-utils 13.0.0-alpha.2635505531 → 13.0.0-alpha.3334148221

package/appUtils/keyCodes/keysByPlatform.js

@@ -77,9 +77,6 @@ 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/playerManager/index.ts

@@ -169,8 +169,12 @@ export class PlayerManager {
     this.addPlayer(id, playerController);
 
     if (playerController.playerRole === PlayerRole.Primary) {
-      if (playerController.playerPluginId !== "QuickBrickPlayerPlugin") {
-        RNPlayerManager?.["QuickBrickPlayerPlugin"]?.stopBackgroundPlayback?.();
+      if (RNPlayerManager) {
+        Object.keys(RNPlayerManager).forEach((pluginId) => {
+          if (pluginId !== playerController.playerPluginId) {
+            RNPlayerManager[pluginId]?.stopBackgroundPlayback?.();
+          }
+        });
       }
 
       playerController.addListener({

package/appUtils/playerManager/player.ts

@@ -91,8 +91,6 @@ 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;
   }
 
@@ -323,7 +321,7 @@ export class Player {
    * You should use dispatchPlayerEvent at PlayerContainer or call playerManager.invokeHandler directly
    * This allows you to use one method for everything.
    */
-  onPlayerSeekStart = (event: QuickBrickPlayer.OnSeekStartEvent) => {
+  onSeekStart = (event: QuickBrickPlayer.OnSeekStartEvent) => {
     const { isLive, seekableDuration, currentTime, duration, seekTime } = event;
 
     this.setPlaybackState({ currentTime, duration, seekableDuration, isLive });
@@ -338,11 +336,10 @@ export class Player {
     });
   };
 
-  onPlayerSeekComplete(event: QuickBrickPlayer.OnSeekCompleteEvent) {
+  onSeekComplete = (event: QuickBrickPlayer.OnSeekCompleteEvent) => {
     const { isLive, seekableDuration, currentTime, duration } = event;
 
     this.setPlaybackState({ currentTime, duration, seekableDuration, isLive });
-
     this.playerState.seekPosition = null;
 
     if (!isLive) {
@@ -353,7 +350,7 @@ export class Player {
       callbackName: SharedPlayerCallBacksKeys.OnPlayerSeekComplete,
       event,
     });
-  }
+  };
 
   onVideoEnd = (event) => {
     this.invokeListenersUpdate({
@@ -656,8 +653,8 @@ export class Player {
   };
 
   public getListener = (): QuickBrickPlayer.SharedPlayerCallBacks => ({
-    onPlayerSeekStart: this.onPlayerSeekStart,
-    onPlayerSeekComplete: this.onPlayerSeekComplete,
+    onPlayerSeekStart: this.onSeekStart,
+    onPlayerSeekComplete: this.onSeekComplete,
     onVideoEnd: this.onVideoEnd,
     onError: this.onError,
     onVideoError: this.onVideoError,
@@ -736,10 +733,5 @@ 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,10 +222,9 @@ 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,8 +5,6 @@ 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 = ({
@@ -41,7 +39,7 @@ export const usePlayerControllerSetup = ({
       ? { supports_native_controls: true, ...config }
       : config;
 
-    const combinedProps = {
+    const newPlayerController = new ControllerType({
       player: ref,
       listener: props as any,
       config: newConfig,
@@ -49,21 +47,9 @@ export const usePlayerControllerSetup = ({
       entry,
       playerPluginId: pluginId,
       playerRole: PlayerRole.Primary,
-    };
-
-    if (isTV()) {
-      const wrappedPlayerController = new ControllerType({
-        ...combinedProps,
-        playerRole: PlayerRole.Unspecified,
-        playerId: playerId + "." + "wrapped",
-      });
+    });
 
-      setPlayerController(
-        new DelayedSeekPlayerWrapper(combinedProps, wrappedPlayerController)
-      );
-    } else {
-      setPlayerController(new ControllerType(combinedProps));
-    }
+    setPlayerController(newPlayerController);
   }, [playerId, entry?.id]);
 
   React.useEffect(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "13.0.0-alpha.2635505531",
+  "version": "13.0.0-alpha.3334148221",
   "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.2635505531",
+    "@applicaster/applicaster-types": "13.0.0-alpha.3334148221",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

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

@@ -9,18 +9,11 @@ jest.useFakeTimers();
 
 const rewind = jest.fn();
 const forward = jest.fn();
-const exitDelayedSeek = jest.fn();
-const enterDelayedSeek = jest.fn();
 
 jest
   .spyOn(playerManager, "getInstanceController")
   // @ts-ignore
-  .mockImplementation(() => ({
-    rewind,
-    forward,
-    exitDelayedSeek,
-    enterDelayedSeek,
-  }));
+  .mockImplementation(() => ({ rewind, forward }));
 
 describe("useAutoSeek", () => {
   beforeEach(() => {

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 = 60;
+export const MAX_SEEK_TIME = 600;
 
 export enum SEEK_TYPE {
   FORWARD = "forward",

package/reactHooks/player/useAutoSeek.tsx

@@ -13,24 +13,20 @@ 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 setIntervalTimer = (cb) => {
-    if (intervalTimer.current) {
-      return;
-    }
-
-    intervalTimer.current = setInterval(() => {
+  const clearIntervalTimer = () => {
+    try {
+      clearInterval(intervalTimer.current);
+    } catch (err) {
       intervalTimer.current = null;
-      cb();
-    }, ON_HOLD_INTERVAL);
+    }
   };
 
-  const clearIntervalTimer = () => {
-    clearInterval(intervalTimer.current);
-    intervalTimer.current = null;
+  const setIntervalTimer = (cb) => {
+    clearIntervalTimer();
+    intervalTimer.current = setInterval(cb, ON_HOLD_INTERVAL);
   };
 
   const resetState = () => {
@@ -41,21 +37,6 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
   };
 
   useEffect(() => {
-    const player = playerManager.getInstanceController();
-    if (!player) return;
-
-    if (isRunning) {
-      player?.enterDelayedSeek();
-    } else if (!isRunning) {
-      player.exitDelayedSeek();
-    }
-  }, [isRunning]);
-
-  useEffect(() => {
-    if (!isRunning) {
-      return;
-    }
-
     const player = playerManager.getInstanceController();
 
     if (!player) return;
@@ -64,7 +45,7 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
       player[direction](Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
       resetHUDTimer();
     }
-  }, [multiplier, direction, isRunning]);
+  }, [multiplier, direction]);
 
   useEffect(() => {
     if (isRunning && isRunning !== prevRunning) {
@@ -96,7 +77,7 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
       setDirection(eventType);
       setIsRunning(true);
     },
-    [isRunning, autoSeekStop]
+    [isRunning]
   );
 
   return React.useMemo(

package/reactHooks/player/useSeek.tsx

@@ -1,9 +1,58 @@
-import React, { useMemo } from "react";
+import React from "react";
+import { SEEK_TYPE } from "./const";
+import { useTapSeek } from "./useTapSeek";
+import { useAutoSeek } from "./useAutoSeek";
 import { noop } from "../../functionUtils";
-import { TVSeekController } from "./TVSeekControlller/TVSeekController";
 
 export const useSeek = (resetHUDTimer = noop) => {
-  return useMemo(() => TVSeekController.getInstance().getSeekMethods(), []);
+  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) =>

package/reactHooks/player/useTapSeek.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef } from "react";
 import * as R from "ramda";
 import {
   MAX_SEEK_TIME,
@@ -10,11 +10,13 @@ import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
 
 type SeekType = SEEK_TYPE | null;
 
-const getSkipTime = (multiplier) =>
-  R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
+const getSkipTime = (multiplier) => {
+  const skipTime = R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
+
+  return skipTime;
+};
 
 export const useTapSeek = () => {
-  const [resumeTimer, setResumeTimer] = useState<NodeJS.Timeout>(null);
   const onPressMultiplier = useRef(1);
   const lastPressTime = useRef(0);
   const currentOnPressEventType = useRef<SeekType>(null);
@@ -44,41 +46,12 @@ export const useTapSeek = () => {
       }
 
       const seekTime = getSkipTime(onPressMultiplier.current);
-
       player[eventType](seekTime);
 
-      if (resumeTimer) {
-        clearTimeout(resumeTimer);
-
-        const timer = setTimeout(() => {
-          player.exitDelayedSeek();
-          setResumeTimer(null);
-        }, 2000);
-
-        setResumeTimer(timer);
-      }
-
-      const clicksBeforePause = 3;
-
-      // Only pause player if user starts to seek on large increments
-      if (onPressMultiplier.current > clicksBeforePause) {
-        if (!player.isPaused()) {
-          player.enterDelayedSeek();
-
-          const timer = setTimeout(() => {
-            player.exitDelayedSeek();
-            setResumeTimer(null);
-          }, 2000);
-
-          clearTimeout(resumeTimer);
-          setResumeTimer(timer);
-        }
-      }
-
       lastPressTime.current = now;
       currentOnPressEventType.current = eventType;
     },
-    [resetMultiplier, resumeTimer]
+    [resetMultiplier]
   );
 
   return handlePressEvent;

package/appUtils/playerManager/DelayedSeekPlayerWrapper.tsx

@@ -1,180 +0,0 @@
-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/reactHooks/player/TVSeekControlller/ISeekController.ts

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

package/reactHooks/player/TVSeekControlller/LongPressSeekController.ts

@@ -1,124 +0,0 @@
-// LongPressSeekController.ts
-import { ISeekController } from "./ISeekController";
-import { SEEK_TYPE } from "../const";
-import {
-  log_debug,
-  log_error,
-  log_verbose,
-  TVSeekController,
-} from "./TVSeekController";
-import { timer, interval, Subscription } from "rxjs";
-import { switchMap, 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
-  ) {}
-
-  onPressStart(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;
-
-    /**
-     * We wait LONG_PRESS_THRESHOLD ms to confirm it's a long press.
-     * If it still active, we switch to an interval that emits every TIMER_INTERVAL_MS.
-     */
-    const threshold$ = timer(this.config.LONG_PRESS_THRESHOLD).pipe(
-      tap(() =>
-        log_verbose("LongPressSeekController: Crossed long-press threshold")
-      ),
-      switchMap(() => {
-        return 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
-            );
-          })
-        );
-      })
-    );
-
-    this.subscription = threshold$.subscribe({
-      complete: () =>
-        log_verbose(
-          "LongPressSeekController: Long press subscription complete"
-        ),
-      error: (err) =>
-        log_error(
-          "LongPressSeekController: Long press subscription error",
-          err
-        ),
-    });
-  }
-
-  onPressEnd() {
-    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

@@ -1,152 +0,0 @@
-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";
-
-export const { log_warning, log_debug, log_info, log_error, log_verbose } =
-  createLogger({
-    category: "General",
-    subsystem: "TVSeekController",
-  });
-
-export class TVSeekController {
-  private static instance: TVSeekController;
-  public static getInstance() {
-    if (!TVSeekController.instance) {
-      TVSeekController.instance = new TVSeekController();
-    }
-
-    return TVSeekController.instance;
-  }
-
-  // -- SHARED STATE ACROSS STRATEGIES --
-  public currentSeekType: SEEK_TYPE | null = null;
-  public delayedSeekOffset: number | null = null;
-  private delayedSeekProgressSubject = new BehaviorSubject<number | null>(null);
-
-  // -- STRATEGY INSTANCES --
-  private tapSeekController: TapSeekController;
-  private longPressSeekController: LongPressSeekController;
-
-  // 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,
-  };
-
-  private constructor() {
-    this.tapSeekController = new TapSeekController(this);
-
-    this.longPressSeekController = new LongPressSeekController(
-      this,
-      this.config
-    );
-  }
-
-  getDelayedSeekProgressObservable() {
-    return this.delayedSeekProgressSubject;
-  }
-
-  getSeekMethods() {
-    return {
-      onForwardPress: () =>
-        this.tapSeekController.onPressStart(SEEK_TYPE.FORWARD),
-      onRewindPress: () =>
-        this.tapSeekController.onPressStart(SEEK_TYPE.REWIND),
-
-      onForwardLongPress: () => {
-        this.longPressSeekController.onPressStart(SEEK_TYPE.FORWARD);
-        this.tapSeekController.reset();
-      },
-      onRewindLongPress: () => {
-        this.longPressSeekController.onPressStart(SEEK_TYPE.REWIND);
-        this.tapSeekController.reset();
-      },
-      onForwardPressOut: () => this.longPressSeekController.onPressEnd(),
-      onRewindPressOut: () => this.longPressSeekController.onPressEnd(),
-    };
-  }
-
-  // ---------------------------
-  // 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();
-  }
-
-  private getPlayer() {
-    const player = playerManager.getInstanceController();
-
-    if (!player) {
-      log_warning("TVSeekController: No valid player controller found");
-    }
-
-    return player;
-  }
-}

package/reactHooks/player/TVSeekControlller/TapSeekController.ts

@@ -1,73 +0,0 @@
-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: NodeJS.Timeout | null = null;
-  private seekMultiplier = 1;
-  private readonly ON_PRESS_RESET_DURATION = 500; // ms
-
-  constructor(private parent: TVSeekController) {}
-
-  onPressStart(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;
-    }
-
-    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);
-
-    const clicksBeforePause = 3;
-    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++;
-  }
-
-  reset() {
-    log_debug("TapSeekController: Reset states");
-
-    this.seekMultiplier = 1;
-
-    if (this.tapSequenceTimeout) {
-      clearTimeout(this.tapSequenceTimeout);
-      this.tapSequenceTimeout = null;
-    }
-  }
-}