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

package/reactHooks/player/TVSeekControlller/TVSeekController.ts

@@ -1,9 +1,15 @@
 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,
+  ISeekControllerDelegate,
+  SeekIncrementalBaseStrategy,
+} from "./ISeekController";
 
 export const { log_warning, log_debug, log_info, log_error, log_verbose } =
   createLogger({
@@ -11,142 +17,244 @@ export const { log_warning, log_debug, log_info, log_error, log_verbose } =
     subsystem: "TVSeekController",
   });
 
-export class TVSeekController {
-  private static instance: TVSeekController;
-  public static getInstance() {
-    if (!TVSeekController.instance) {
-      TVSeekController.instance = new TVSeekController();
-    }
+export enum SEEK_STRATEGY {
+  TAP_SEEK = "TAP_SEEK",
+  AUTO_SEEK = "AUTO_SEEK",
+}
 
-    return TVSeekController.instance;
-  }
+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;
 
-  // -- SHARED STATE ACROSS STRATEGIES --
-  public currentSeekType: SEEK_TYPE | null = null;
-  public delayedSeekOffset: number | null = null;
+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;
 
-  // -- STRATEGY INSTANCES --
-  private tapSeekController: TapSeekController;
-  private longPressSeekController: LongPressSeekController;
+  private currentSeekController: ISeekController;
+  private readonly tapSeekController: TapSeekController;
+  private readonly longPressSeekController: LongPressSeekController;
+  private longPressThresholdTimeout: any | null = null;
+  private seekEndTimeout: 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(playerController: Player) {
+    this.playerController = playerController;
 
-  private constructor() {
-    this.tapSeekController = new TapSeekController(this);
+    this.tapSeekController = new TapSeekController(
+      this,
+      new SeekIncrementalBaseStrategy(),
+      CONFIG_TAP_SEEK
+    );
 
     this.longPressSeekController = new LongPressSeekController(
       this,
-      this.config
+      new SeekIncrementalBaseStrategy(),
+      CONFIG_LONG_PRESS
     );
+
+    this.currentSeekController = this.tapSeekController;
   }
 
-  getDelayedSeekProgressObservable() {
+  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(),
-    };
-  }
+  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();
+    }
 
-  // ---------------------------
-  // SHARED METHODS
-  // ---------------------------
+    this.clearLongPressThresholdTimeout();
+    this.clearSeekCompleteTimeout();
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
+    this.currentSeekController.onStartSeek(seekType);
 
-  /** Called by either strategy to accumulate offset while paused. */
-  handleDelayedSeek(eventType: SEEK_TYPE, skipTime: number) {
-    const player = this.getPlayer();
-    if (!player) return;
+    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);
 
-    // If not previously delayed, we pause the first time
-    if (this.delayedSeekOffset === null) {
-      this.pausePlayer();
+    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;
     }
 
-    const newOffset = (this.delayedSeekOffset || 0) + skipTime;
-    const currentPos = player.getPosition();
+    // 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 (eventType === SEEK_TYPE.FORWARD) {
-      targetPos = Math.min(currentPos + newOffset, player.getDuration());
+    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 {
-      targetPos = Math.max(0, currentPos - newOffset);
+      log_warning(
+        `TVSeekController: handleDelayedSeek - invalid seek type: ${this.currentSeekType}`
+      );
     }
 
-    this.delayedSeekOffset = newOffset;
-
     log_debug(
-      `TVSeekController: handleDelayedSeek - targetPos: ${targetPos}, offset: ${newOffset}, skipTime: ${skipTime}`
+      `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);
-  }
+  };
 
-  seekPlayer(offset: number) {
-    const player = this.getPlayer();
-    if (!player || !this.currentSeekType) return;
-    player[this.currentSeekType](offset);
-    this.playerPlay();
-  }
+  handleSeekTo = (newPosition: number) => {
+    this.playerController.seekTo(newPosition);
+
+    if (!this.isPlayerInitiallyPaused) {
+      this.playerController.play();
+    }
+  };
 
-  playerPlay() {
-    const player = this.getPlayer();
-    if (!player) return;
+  handleSeek = (offset: number) => {
+    this.playerController[this.currentSeekType](offset);
 
-    if (player.isPaused()) {
-      player.play();
+    if (!this.isPlayerInitiallyPaused) {
+      this.playerController.play();
     }
-  }
+  };
 
-  pausePlayer() {
-    const player = this.getPlayer();
-    if (!player) return;
-    player.pause();
-  }
+  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;
+  };
 
-  /**
-   * 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.delayedSeekPosition = null;
+    this.isPlayerInitiallyPaused = null;
 
-  private getPlayer() {
-    const player = playerManager.getInstanceController();
+    this.clearSeekCompleteTimeout();
+    this.clearLongPressThresholdTimeout();
 
-    if (!player) {
-      log_warning("TVSeekController: No valid player controller found");
-    }
+    this.tapSeekController.reset();
+    this.longPressSeekController.reset();
 
-    return player;
+    this.setStrategy(SEEK_STRATEGY.TAP_SEEK);
   }
 }

package/reactHooks/player/TVSeekControlller/TapSeekController.ts

@@ -1,73 +1,53 @@
-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);
+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 {
-  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}.`);
+  readonly title = "TapSeek";
+  constructor(
+    private seekControllerDelegate: ISeekControllerDelegate,
+    private seekIncrementalStrategy: SeekIncrementalBaseStrategy,
+    private config: TapPressConfig
+  ) {}
 
-    const prevSeekType = this.parent.currentSeekType;
+  onStartSeek = (seekType: SEEK_TYPE) => {
+    log_debug(`${this.title}: start tap seek type: ${seekType}.`);
 
-    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);
-      }
+    const skipTime = this.seekIncrementalStrategy.getSkipTime();
+    const seekMultiplier = this.seekIncrementalStrategy.getSkipMultiplier();
 
+    if (seekMultiplier > this.config.CLICKS_BEFORE_PAUSE) {
       log_debug(
-        `TapSeekController: Tap sequence timeout fired, delayedSeekOffset: ${this.parent.delayedSeekOffset}.`
+        `${this.title}: handle delayed seek type:${seekType} - skipTime: ${skipTime}, seekMultiplier: ${seekMultiplier}.`
       );
 
-      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);
+      this.seekControllerDelegate.handleDelayedSeek(skipTime);
     } else {
       log_debug(
-        `TapSeekController: handle seek type:${seekType} - skipTime: ${skipTime}.`
+        `${this.title}: handle seek type:${seekType} - skipTime: ${skipTime}.`
       );
 
-      this.parent.seekPlayer(skipTime);
+      this.seekControllerDelegate.handleSeek(skipTime);
     }
 
-    this.seekMultiplier++;
-  }
+    this.seekIncrementalStrategy.increment();
+  };
 
-  reset() {
-    log_debug("TapSeekController: Reset states");
+  onSeekEnd = () => {
+    this.seekControllerDelegate.handleSeekComplete();
+  };
 
-    this.seekMultiplier = 1;
+  reset = () => {
+    log_debug("{this.title}: Reset states");
 
-    if (this.tapSequenceTimeout) {
-      clearTimeout(this.tapSequenceTimeout);
-      this.tapSequenceTimeout = null;
-    }
-  }
+    this.seekIncrementalStrategy.reset();
+  };
 }

package/reactHooks/player/const.ts

@@ -1,10 +1,6 @@
 export const SKIP_TIME_BASE = 10;
 
-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/index.ts

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

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;
-  }
-}