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

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

@@ -30,3 +30,16 @@ export const useIsInitialRender = (): boolean => {
 
   return isInitialRenderRef.current;
 };
+
+export const checkIsLocalFeed = (feedUrl) => feedUrl?.startsWith("pipesv2://");
+
+export const shouldDispatchData = (
+  url: string,
+  feed: ZappPipesData | null,
+  clearCache: boolean
+) => {
+  const currentFeedHasData = feed?.data;
+  const isLocalFeed = checkIsLocalFeed(url);
+
+  return !currentFeedHasData || clearCache || isLocalFeed;
+};

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