@applicaster/zapp-react-native-utils 13.0.0-alpha.3244448100 → 13.0.0-alpha.3251251233

package/appUtils/keyCodes/keysByPlatform.js

@@ -77,10 +77,6 @@ const web = {
   Exit: { code: "Exit", keyCode: null },
   Escape: { code: "Escape", keyCode: 27 },
   EscapeDevice: { code: "Escape", keyCode: 27 },
-  // For Debugging
-  Z: { code: "KeyZ", keyCode: 90 }, // Hardware Backward Button
-  X: { code: "KeyX", keyCode: 88 }, // Hardware Enter Button
-  C: { code: "KeyC", keyCode: 67 }, // Hardware Forward Button
 };
 
 const android_tv = {

package/appUtils/playerManager/player.ts

@@ -5,7 +5,6 @@ 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",
@@ -50,8 +49,6 @@ export class Player {
     [key: string]: QuickBrickPlayer.SharedPlayerCallBacks;
   } = {};
 
-  public seekController?: TVSeekController | null;
-
   get entry(): ZappEntry | null {
     return this._entry;
   }
@@ -62,8 +59,6 @@ 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,
@@ -96,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;
   }
 
@@ -328,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 });
@@ -343,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) {
@@ -628,18 +620,14 @@ export class Player {
   selectTrack = (_track) => {};
 
   protected notifyPlayHeadPositionUpdate = () => {
-    const currentTime = this.getPosition();
-
     const event = {
-      currentTime,
+      currentTime: this.getPosition(),
       duration: this.getDuration(),
       item: this.getEntry(),
       seekableDuration: this.playerState.seekableDuration,
       isLive: this.isLive(),
     };
 
-    this.seekController?.onVideoProgress(currentTime);
-
     this.invokeListenersUpdate({
       callbackName: SharedPlayerCallBacksKeys.OnVideoProgress,
       event,
@@ -665,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,

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

@@ -39,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,
@@ -47,9 +47,9 @@ export const usePlayerControllerSetup = ({
       entry,
       playerPluginId: pluginId,
       playerRole: PlayerRole.Primary,
-    };
+    });
 
-    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.3244448100",
+  "version": "13.0.0-alpha.3251251233",
   "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.3244448100",
+    "@applicaster/applicaster-types": "13.0.0-alpha.3251251233",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "create-react-context": "^0.2.3",

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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,94 @@
+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/const.ts

@@ -1,5 +1,9 @@
 export const SKIP_TIME_BASE = 10;
 
+export const ON_PRESS_RESET_DURATION = 2000;
+
+export const ON_HOLD_INTERVAL = 500;
+
 export const MAX_SEEK_TIME = 600;
 
 export enum SEEK_TYPE {

package/reactHooks/player/index.ts

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

package/reactHooks/player/useAutoSeek.tsx

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,58 @@
+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;
+};

package/appUtils/keyInputHandler/KeyInputHandler.ts

@@ -1,68 +0,0 @@
-export type SeekKeyHandlerListener = {
-  onRewindPress: () => boolean;
-  onForwardPress: () => 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;
-      }
-    }
-  };
-
-  onForwardPress = () => {
-    for (const element of this.listeners) {
-      if (element.onForwardPress()) {
-        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,
-      onForwardPressOut: this.onForwardPressOut,
-      onRewindPressOut: this.onRewindPressOut,
-    };
-  };
-}

package/reactHooks/player/TVSeekControlller/ISeekController.ts

@@ -1,32 +0,0 @@
-import { MAX_SEEK_TIME, SEEK_TYPE, SKIP_TIME_BASE } from "../const";
-
-export interface ISeekControllerDelegate {
-  handleDelayedSeek(offset: number): void;
-  handleSeek(offset: number): void;
-  handleSeekComplete(): void;
-  handlePlayerPause(): void;
-}
-
-export interface ISeekController {
-  title: string;
-  onStartSeek(seekType: SEEK_TYPE): void;
-  onSeekEnd(): void;
-  reset(): void;
-}
-
-export class SeekIncrementalBaseStrategy {
-  private skipMultiplier = 1;
-
-  getSkipTime = () =>
-    Math.min(MAX_SEEK_TIME, SKIP_TIME_BASE * this.skipMultiplier);
-
-  increment = () => {
-    this.skipMultiplier++;
-  };
-
-  getSkipMultiplier = () => this.skipMultiplier;
-
-  reset = () => {
-    this.skipMultiplier = 1;
-  };
-}

package/reactHooks/player/TVSeekControlller/LongPressSeekController.ts

@@ -1,75 +0,0 @@
-import {
-  ISeekController,
-  ISeekControllerDelegate,
-  SeekIncrementalBaseStrategy,
-} from "./ISeekController";
-import { SEEK_TYPE } from "../const";
-import { log_debug, log_error, log_verbose } from "./TVSeekController";
-import { interval, Subscription } from "rxjs";
-import { tap } from "rxjs/operators";
-
-interface LongPressConfig {
-  TIMER_INTERVAL_MS: number;
-}
-
-export class LongPressSeekController implements ISeekController {
-  isLongPressActive = false;
-  private subscription: Subscription | null = null;
-  readonly title = "LongPressSeek";
-  constructor(
-    private seekControllerDelegate: ISeekControllerDelegate,
-    private seekIncrementalStrategy: SeekIncrementalBaseStrategy,
-    private config: LongPressConfig
-  ) {}
-
-  onStartSeek(seekType: SEEK_TYPE) {
-    this.cleanUpSubscription();
-
-    log_debug(`${this.title}: start long press seek type: ${seekType}.`);
-
-    this.seekControllerDelegate.handlePlayerPause();
-
-    this.isLongPressActive = true;
-
-    this.subscription = interval(this.config.TIMER_INTERVAL_MS)
-      .pipe(
-        tap(() => {
-          this.seekControllerDelegate.handleDelayedSeek(
-            this.seekIncrementalStrategy.getSkipTime()
-          );
-
-          log_debug(
-            `${
-              this.title
-            }: handle delayed seek type: ${seekType} - multiplier: ${this.seekIncrementalStrategy.getSkipMultiplier()}, currentSkipAmount: ${this.seekIncrementalStrategy.getSkipTime()}.`
-          );
-
-          this.seekIncrementalStrategy.increment();
-        })
-      )
-      .subscribe({
-        complete: () =>
-          log_verbose(`${this.title}: Long press subscription complete`),
-        error: (err) =>
-          log_error(`${this.title}: Long press subscription error`, err),
-      });
-  }
-
-  onSeekEnd() {
-    this.cleanUpSubscription();
-    this.seekControllerDelegate.handleSeekComplete();
-  }
-
-  reset() {
-    this.isLongPressActive = false;
-    this.seekIncrementalStrategy.reset();
-    this.cleanUpSubscription();
-  }
-
-  private cleanUpSubscription() {
-    if (this.subscription) {
-      this.subscription.unsubscribe();
-      this.subscription = null;
-    }
-  }
-}

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -1,260 +0,0 @@
-import { BehaviorSubject } from "rxjs";
-import { TapSeekController } from "./TapSeekController";
-import { LongPressSeekController } from "./LongPressSeekController";
-import { SEEK_TYPE } from "../const";
-import { createLogger } from "../../../logger";
-import { Player } from "../../../appUtils/playerManager/player";
-import { SeekKeyHandlerListener } from "../../../appUtils/keyInputHandler/KeyInputHandler";
-import {
-  ISeekController,
-  ISeekControllerDelegate,
-  SeekIncrementalBaseStrategy,
-} 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",
-}
-
-const CONFIG_TAP_SEEK = {
-  CLICKS_BEFORE_PAUSE: 0,
-};
-
-const CONFIG_LONG_PRESS = {
-  TIMER_INTERVAL_MS: 200,
-};
-
-const LONG_PRESS_THRESHOLD = 500;
-const SEEK_END_TIMEOUT_DURATION = 700;
-
-export class TVSeekController
-  implements SeekKeyHandlerListener, ISeekControllerDelegate
-{
-  public delayedSeekPosition: number | null = null;
-  private readonly playerController: Player;
-  private delayedSeekProgressSubject = new BehaviorSubject<number | null>(null);
-  isPlayerInitiallyPaused: null | boolean = null;
-  currentSeekType: SEEK_TYPE | null = null;
-
-  private currentSeekController: ISeekController;
-  private readonly tapSeekController: TapSeekController;
-  private readonly longPressSeekController: LongPressSeekController;
-  private longPressThresholdTimeout: any | null = null;
-  private seekEndTimeout: any | null = null;
-
-  constructor(playerController: Player) {
-    this.playerController = playerController;
-
-    this.tapSeekController = new TapSeekController(
-      this,
-      new SeekIncrementalBaseStrategy(),
-      CONFIG_TAP_SEEK
-    );
-
-    this.longPressSeekController = new LongPressSeekController(
-      this,
-      new SeekIncrementalBaseStrategy(),
-      CONFIG_LONG_PRESS
-    );
-
-    this.currentSeekController = this.tapSeekController;
-  }
-
-  getDelayedSeekProgressObservable = () => {
-    return this.delayedSeekProgressSubject;
-  };
-
-  setStrategy = (seekStrategy: SEEK_STRATEGY) => {
-    switch (seekStrategy) {
-      case SEEK_STRATEGY.TAP_SEEK:
-        this.currentSeekController = this.tapSeekController;
-        log_debug("TVSeekController: setStrategy - TAP_SEEK");
-
-        break;
-      case SEEK_STRATEGY.AUTO_SEEK:
-        this.currentSeekController = this.longPressSeekController;
-        log_debug("TVSeekController: setStrategy - AUTO_SEEK");
-
-        break;
-      default:
-    }
-  };
-
-  handleStartSeek = (seekType: SEEK_TYPE) => {
-    this.currentSeekType = seekType;
-
-    if (this.isPlayerInitiallyPaused === null) {
-      this.isPlayerInitiallyPaused = this.playerController.isPaused();
-    }
-
-    this.clearLongPressThresholdTimeout();
-    this.clearSeekCompleteTimeout();
-    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
-    this.currentSeekController.onStartSeek(seekType);
-
-    this.longPressThresholdTimeout = setTimeout(() => {
-      this.setStrategy(SEEK_STRATEGY.AUTO_SEEK);
-      this.currentSeekController.onStartSeek(seekType);
-    }, 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 = () => {
-    this.onSeekEnd();
-  };
-
-  onForwardPressOut = () => {
-    this.onSeekEnd();
-  };
-
-  public onVideoProgress = (position: number) => {
-    if (this.delayedSeekPosition !== null) {
-      return;
-    }
-
-    // TODO: If 1 second after seek, send
-
-    this.delayedSeekProgressSubject.next(position);
-  };
-
-  handleDelayedSeek = (offset: number = 0) => {
-    this.handlePlayerPause();
-
-    const currentPos =
-      this.delayedSeekPosition === null
-        ? this.playerController.getPosition()
-        : this.delayedSeekPosition;
-
-    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);
-    } else {
-      log_warning(
-        `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
-      );
-    }
-
-    log_debug(
-      `TVSeekController: handleDelayedSeek - targetPos: ${targetPos}, skipTime: ${offset}`
-    );
-
-    const prevValue = this.delayedSeekProgressSubject.getValue();
-
-    if (prevValue !== null) {
-      const delta = Math.abs(prevValue - targetPos);
-
-      if (delta < 1) {
-        return;
-      }
-    }
-
-    this.delayedSeekPosition = targetPos;
-    this.delayedSeekProgressSubject.next(targetPos);
-  };
-
-  handleSeekTo = (newPosition: number) => {
-    this.playerController.seekTo(newPosition);
-
-    if (!this.isPlayerInitiallyPaused) {
-      this.playerController.play();
-    }
-  };
-
-  handleSeek = (offset: number) => {
-    this.playerController[this.currentSeekType](offset);
-
-    if (!this.isPlayerInitiallyPaused) {
-      this.playerController.play();
-    }
-  };
-
-  handleSeekComplete = () => {
-    this.clearSeekCompleteTimeout();
-
-    this.seekEndTimeout = setTimeout(() => {
-      if (this.delayedSeekPosition !== null) {
-        this.handleSeekTo(this.delayedSeekPosition);
-      }
-
-      log_debug(
-        `handleSeekComplete: Seek finished, type: ${this.currentSeekController.title}, seekPosition: ${this.delayedSeekPosition}. Reset all states and seek position.`
-      );
-
-      this.resetAll();
-    }, SEEK_END_TIMEOUT_DURATION);
-  };
-
-  isAutoSeeking = (): boolean => {
-    return this.longPressSeekController.isLongPressActive;
-  };
-
-  handlePlayerPause = () => {
-    if (this.playerController.isPaused()) {
-      return;
-    }
-
-    this.playerController.pause();
-  };
-
-  clearSeekCompleteTimeout = () => {
-    if (this.seekEndTimeout === null) {
-      return;
-    }
-
-    clearTimeout(this.seekEndTimeout);
-    this.seekEndTimeout = null;
-  };
-
-  clearLongPressThresholdTimeout = () => {
-    if (this.longPressThresholdTimeout === null) {
-      return;
-    }
-
-    clearTimeout(this.longPressThresholdTimeout);
-    this.longPressThresholdTimeout = null;
-  };
-
-  resetAll() {
-    log_debug("TVSeekController: Reset all states");
-    this.currentSeekType = null;
-
-    this.delayedSeekPosition = null;
-    this.isPlayerInitiallyPaused = null;
-
-    this.clearSeekCompleteTimeout();
-    this.clearLongPressThresholdTimeout();
-
-    this.tapSeekController.reset();
-    this.longPressSeekController.reset();
-
-    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
-  }
-}

package/reactHooks/player/TVSeekControlller/TapSeekController.ts

@@ -1,53 +0,0 @@
-import {
-  ISeekController,
-  ISeekControllerDelegate,
-  SeekIncrementalBaseStrategy,
-} from "./ISeekController";
-import { SEEK_TYPE } from "../const";
-import { log_debug } from "./TVSeekController";
-
-interface TapPressConfig {
-  CLICKS_BEFORE_PAUSE: number;
-}
-
-export class TapSeekController implements ISeekController {
-  readonly title = "TapSeek";
-  constructor(
-    private seekControllerDelegate: ISeekControllerDelegate,
-    private seekIncrementalStrategy: SeekIncrementalBaseStrategy,
-    private config: TapPressConfig
-  ) {}
-
-  onStartSeek = (seekType: SEEK_TYPE) => {
-    log_debug(`${this.title}: start tap seek type: ${seekType}.`);
-
-    const skipTime = this.seekIncrementalStrategy.getSkipTime();
-    const seekMultiplier = this.seekIncrementalStrategy.getSkipMultiplier();
-
-    if (seekMultiplier > this.config.CLICKS_BEFORE_PAUSE) {
-      log_debug(
-        `${this.title}: handle delayed seek type:${seekType} - skipTime: ${skipTime}, seekMultiplier: ${seekMultiplier}.`
-      );
-
-      this.seekControllerDelegate.handleDelayedSeek(skipTime);
-    } else {
-      log_debug(
-        `${this.title}: handle seek type:${seekType} - skipTime: ${skipTime}.`
-      );
-
-      this.seekControllerDelegate.handleSeek(skipTime);
-    }
-
-    this.seekIncrementalStrategy.increment();
-  };
-
-  onSeekEnd = () => {
-    this.seekControllerDelegate.handleSeekComplete();
-  };
-
-  reset = () => {
-    log_debug("{this.title}: Reset states");
-
-    this.seekIncrementalStrategy.reset();
-  };
-}