@applicaster/zapp-react-native-utils 12.0.0-alpha.9004455836 → 12.0.0-alpha.9233494544

package/appUtils/focusManager/utils/index.ts

@@ -0,0 +1,77 @@
+import { isNotNil } from "@applicaster/zapp-react-native-utils/reactUtils/helpers";
+import { find, last, startsWith, pathOr } from "ramda";
+
+// run check each 300 ms
+// run this check too often could lead to performance penalty on low-end devices
+const HOW_OFTEN_TO_CHECK_CONDITION = 300; //ms
+
+type Props = {
+  maxTimeout: number;
+  conditionFn: () => boolean;
+};
+
+export const waitUntil = ({ maxTimeout, conditionFn }: Props) => {
+  let interval;
+  let timeout;
+  return new Promise((resolve, reject) => {
+    interval = setInterval(() => {
+      if (conditionFn()) {
+        clearInterval(interval);
+        clearTimeout(timeout);
+
+        resolve(undefined);
+      }
+    }, HOW_OFTEN_TO_CHECK_CONDITION);
+
+    timeout = setTimeout(() => {
+      clearInterval(interval);
+      clearTimeout(timeout);
+
+      reject();
+    }, maxTimeout);
+  });
+};
+
+export const waitForActiveScreen = (currentRoute: string, focusableTree) => {
+  const isActiveScreenAvailableToFocus = (): boolean => {
+    const routes = focusableTree.root.children;
+
+    const route = find((route) => route.id === currentRoute, routes);
+    return isNotNil(route);
+  };
+
+  return waitUntil({
+    maxTimeout: 2500, //ms
+    conditionFn: isActiveScreenAvailableToFocus,
+  });
+};
+
+export const getActiveScreen = (focusableTree) => {
+  return last(focusableTree.root.children);
+};
+
+export const getContentNode = (focusableTree) => {
+  const content = find(
+    (child) => startsWith("content", child.id),
+    getActiveScreen(focusableTree)?.children
+  );
+
+  return content;
+};
+
+export const waitForContent = (focusableTree) => {
+  const contentHasAnyChildren = (): boolean => {
+    const countOfChildren = pathOr(
+      0,
+      ["children", "length"],
+      getContentNode(focusableTree)
+    );
+
+    return countOfChildren > 0;
+  };
+
+  return waitUntil({
+    maxTimeout: 2500, //ms
+    conditionFn: contentHasAnyChildren,
+  });
+};

package/appUtils/keyCodes/__tests__/__snapshots__/keyCodes.test.js.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`keyCode returns an object for a given key event 1`] = `
+exports[`keyCodes keyCode returns an object for a given key event 1`] = `
 Object {
   "direction": [Function],
   "matches": [Function],

package/appUtils/keyCodes/__tests__/keyCodes.test.js

@@ -1,3 +1,7 @@
+const { Platform } = require("react-native");
+
+Platform.OS = "web";
+
 import { directionHelper } from "../../directionHelper";
 
 const globalTizen = {
@@ -6,105 +10,96 @@ const globalTizen = {
   },
 };
 
-jest.mock("react-native", () => {
-  return { Platform: { OS: "web" } };
-});
-
-describe("keyCode", () => {
-  const { keyCode } = require("../index");
-  const { KEYS } = require("../keys.web");
-
-  it("returns an object for a given key event", () => {
-    expect(keyCode(KEYS.Enter)).toMatchSnapshot();
-  });
-
-  it("has a matcher method for a single key", () => {
-    expect(keyCode(KEYS.Enter).matches("Enter")).toBeTruthy();
-    expect(keyCode(KEYS.Enter).matches(KEYS.Enter)).toBeTruthy();
-    expect(keyCode(KEYS.Back).matches("Enter")).toBeFalsy();
-  });
-
-  it("has matcher for multiple keys", () => {
-    expect(
-      keyCode(KEYS.Enter).matchesAny("Enter", "Back", "ArrowUp")
-    ).toBeTruthy();
+describe("keyCodes", () => {
+  describe("keyCode", () => {
+    const { keyCode } = require("..");
+    const { KEYS } = require("../keys.web");
 
-    expect(
-      keyCode(KEYS.Enter).matchesAny("Back", "ArrowUp", "ArrowDown")
-    ).toBeFalsy();
-  });
+    it("returns an object for a given key event", () => {
+      expect(keyCode(KEYS.Enter)).toMatchSnapshot();
+    });
 
-  it("returns the direction if it matches an arrow key", () => {
-    expect(keyCode(KEYS.Enter).direction()).toBe(null);
+    it("has a matcher method for a single key", () => {
+      expect(keyCode(KEYS.Enter).matches("Enter")).toBeTruthy();
+      expect(keyCode(KEYS.Enter).matches(KEYS.Enter)).toBeTruthy();
+      expect(keyCode(KEYS.Back).matches("Enter")).toBeFalsy();
+    });
 
-    expect(keyCode(KEYS.ArrowDown).direction()).toEqual(
-      directionHelper(KEYS.ArrowDown)
-    );
-  });
+    it("has matcher for multiple keys", () => {
+      expect(
+        keyCode(KEYS.Enter).matchesAny("Enter", "Back", "ArrowUp")
+      ).toBeTruthy();
 
-  describe("in web env", () => {
-    it("uses the proper keyCode for the environment", () => {
-      expect(keyCode({ keyCode: 13 }).matches(KEYS.Enter)).toBeTruthy();
+      expect(
+        keyCode(KEYS.Enter).matchesAny("Back", "ArrowUp", "ArrowDown")
+      ).toBeFalsy();
     });
-  });
-});
 
-describe("in Tizen Env", () => {
-  jest.mock("react-native", () => {
-    return { Platform: { OS: "samsung_tv" } };
-  });
+    it("returns the direction if it matches an arrow key", () => {
+      expect(keyCode(KEYS.Enter).direction()).toBe(null);
 
-  beforeEach(() => {
-    global.tizen = globalTizen;
-    jest.resetModules();
-  });
+      expect(keyCode(KEYS.ArrowDown).direction()).toEqual(
+        directionHelper(KEYS.ArrowDown)
+      );
+    });
 
-  afterEach(() => {
-    global.tizen = undefined;
+    describe("in web env", () => {
+      it("uses the proper keyCode for the environment", () => {
+        expect(keyCode({ keyCode: 13 }).matches(KEYS.Enter)).toBeTruthy();
+      });
+    });
   });
 
-  it("uses the proper keyCode for the environment", () => {
-    const { keyCode } = require("../index");
-    const { KEYS } = require("../keys.web");
+  describe("in Tizen Env", () => {
+    beforeEach(() => {
+      jest.resetModules();
+      global.tizen = globalTizen;
+    });
 
-    expect(globalTizen.tvinputdevice.registerKeyBatch).toHaveBeenCalledWith([
-      "Back",
-      "MediaPlay",
-      "MediaPlayPause",
-      "MediaPause",
-      "MediaFastForward",
-      "MediaRewind",
-      "MediaStop",
-      "Exit",
-      "0",
-      "1",
-      "2",
-      "3",
-      "4",
-      "5",
-      "6",
-      "7",
-      "8",
-      "9",
-    ]);
-
-    expect(keyCode({ keyCode: 10009 }).matches(KEYS.Back)).toBeTruthy();
-  });
-});
+    afterEach(() => {
+      global.tizen = undefined;
+    });
 
-describe("in WebOS Env", () => {
-  jest.mock("react-native", () => {
-    return { Platform: { OS: "lg_tv" } };
+    it("uses the proper keyCode for the environment", () => {
+      Platform.OS = "samsung_tv";
+      const { keyCode } = require("../");
+      const { KEYS } = require("../keys.web");
+
+      expect(globalTizen.tvinputdevice.registerKeyBatch).toHaveBeenCalledWith([
+        "MediaPlay",
+        "MediaPlayPause",
+        "MediaPause",
+        "MediaFastForward",
+        "MediaRewind",
+        "MediaStop",
+        "Exit",
+        "0",
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+        "7",
+        "8",
+        "9",
+      ]);
+
+      expect(keyCode({ keyCode: 10009 }).matches(KEYS.Back)).toBeTruthy();
+    });
   });
 
-  beforeEach(() => {
-    jest.resetModules();
-  });
+  describe("in WebOS Env", () => {
+    beforeEach(() => {
+      jest.resetModules();
+    });
 
-  it("uses the proper keyCode for the environment", () => {
-    const { keyCode } = require("../index");
-    const { KEYS } = require("../keys.web");
-    // Back is reserved on LG
-    expect(keyCode({ keyCode: 417 }).matches(KEYS.Forward)).toBeTruthy();
+    it("uses the proper keyCode for the environment", () => {
+      Platform.OS = "lg_tv";
+      const { keyCode } = require("..");
+      const { KEYS } = require("../keys.web");
+      // Back is reserved on LG
+      expect(keyCode({ keyCode: 417 }).matches(KEYS.Forward)).toBeTruthy();
+    });
   });
 });

package/appUtils/keyCodes/keys.web.js

@@ -1,5 +1,6 @@
 /* global tizen */
 const isTizen = typeof tizen !== "undefined";
+
 import * as platformKeys from "./keysByPlatform";
 import { Platform } from "react-native";
 

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -41,6 +41,11 @@ export type ChapterMarkerEvent = {
   actions: ActionChapter[];
 };
 
+export type TitleSummaryEvent = {
+  title: string | number;
+  summary: string | number;
+};
+
 type ChapterMarkersObserverProps = {
   player: Player;
 };
@@ -60,6 +65,11 @@ export type PlayNextState = PlayNextConfig & {
 export class OverlaysObserver {
   readonly chapterSubject: BehaviorSubject<ChapterMarkerEvent>;
   private playNextSubject: BehaviorSubject<PlayNextState>;
+  private titleSummarySubject: BehaviorSubject<TitleSummaryEvent>;
+  private feedUrl: string;
+  private reloadData: () => void;
+  private updateTitleAndDescription: (data: any) => void;
+  private feedDataInterval: any;
   private releasePlayerObserver?: () => void;
   readonly entry: ZappEntry;
   private chapterMarkerEvents: ChapterMarkerEvent[];
@@ -70,14 +80,55 @@ export class OverlaysObserver {
   constructor({ player }: ChapterMarkersObserverProps) {
     this.chapterSubject = new BehaviorSubject(null);
     this.playNextSubject = new BehaviorSubject(null);
+
+    this.titleSummarySubject = new BehaviorSubject<TitleSummaryEvent>({
+      title: player.getEntry()?.title || "",
+      summary: player.getEntry()?.summary || "",
+    });
+
     this.entry = player.getEntry();
     this.player = player;
 
     this.chapterMarkerEvents = this.prepareChapterMarkers();
     this.releasePlayerObserver = this.subscribeToPlayerEvents();
+    this.feedUrl = "";
+    this.reloadData = () => {};
+    this.updateTitleAndDescription = () => {};
+    this.feedDataInterval = null;
     void this.preparePlayNext();
   }
 
+  private setupFeedDataInterval(interval: number) {
+    if (this.feedUrl && this.reloadData && this.updateTitleAndDescription) {
+      this.feedDataInterval = setInterval(() => {
+        this.reloadData();
+      }, interval * 1000);
+    }
+  }
+
+  public clearFeedDataInterval() {
+    if (this.feedDataInterval) {
+      clearInterval(this.feedDataInterval);
+      this.feedDataInterval = null;
+    }
+  }
+
+  public setFeedDataHandlers(
+    feedUrl: string,
+    reloadData: () => void,
+    interval: number,
+    updateTitleAndDescription: (data: any) => void
+  ) {
+    this.feedUrl = feedUrl;
+    this.reloadData = reloadData;
+    this.updateTitleAndDescription = updateTitleAndDescription;
+    this.setupFeedDataInterval(interval);
+  }
+
+  public getTitleSummaryObservable(): Observable<TitleSummaryEvent> {
+    return this.titleSummarySubject.asObservable().pipe(distinctUntilChanged());
+  }
+
   handleUserCancelPlayNext = () => {
     this.isCanceledByUser = true;
     this.playNextSubject.next(null);
@@ -281,7 +332,9 @@ export class OverlaysObserver {
   onPlayerClose = () => {
     this.chapterSubject.complete();
     this.playNextSubject.complete();
+    this.titleSummarySubject.complete();
     this.releasePlayerObserver?.();
+    this.clearFeedDataInterval();
     this.releasePlayerObserver = null;
   };
 

package/appUtils/playerManager/conts.ts

@@ -20,6 +20,11 @@ export enum SharedPlayerCallBacksKeys {
   OnPlayerMute = "onPlayerMute",
   OnPlayerUnmute = "onPlayerUnmute",
 
+  onVideoFullscreenPlayerDidDismiss = "onVideoFullscreenPlayerDidDismiss",
+  onVideoFullscreenPlayerDidPresent = "onVideoFullscreenPlayerDidPresent",
+  onVideoFullscreenPlayerWillDismiss = "onVideoFullscreenPlayerWillDismiss",
+  onVideoFullscreenPlayerWillPresent = "onVideoFullscreenPlayerWillPresent",
+
   OnAdBegin = "onAdBegin",
   OnAdBreakBegin = "onAdBreakBegin",
   OnAdBreakEnd = "onAdBreakEnd",

package/appUtils/playerManager/player.ts

@@ -42,7 +42,7 @@ export class Player {
 
   protected startPosition?: number | null;
   readonly playerRole: PlayerRole = PlayerRole.Unspecified;
-  private chaptersObserver?: OverlaysObserver | null;
+  private overlaysObserver?: OverlaysObserver | null;
   private entryObservable?: BehaviorSubject<ZappEntry> | null;
 
   protected listeners: {
@@ -95,11 +95,11 @@ export class Player {
   }
 
   getOverlayObservable = () => {
-    if (!this.chaptersObserver) {
-      this.chaptersObserver = new OverlaysObserver({ player: this });
+    if (!this.overlaysObserver) {
+      this.overlaysObserver = new OverlaysObserver({ player: this });
     }
 
-    return this.chaptersObserver;
+    return this.overlaysObserver;
   };
 
   getEntryObservable = (): BehaviorSubject<ZappEntry | null> => {
@@ -278,6 +278,10 @@ export class Player {
     return this.playerState.isBuffering;
   };
 
+  isReadyToPlay = (): boolean => {
+    return this.playerState.isReadyToPlay;
+  };
+
   // Methods to call actions on the player
   seekTo = (_position: number) => {};
 
@@ -410,6 +414,32 @@ export class Player {
     });
   };
 
+  onVideoFullscreenPlayerWillDismiss = () => {
+    this.invokeListenersUpdate({
+      callbackName:
+        SharedPlayerCallBacksKeys.onVideoFullscreenPlayerWillDismiss,
+    });
+  };
+
+  onVideoFullscreenPlayerDidDismiss = () => {
+    this.invokeListenersUpdate({
+      callbackName: SharedPlayerCallBacksKeys.onVideoFullscreenPlayerDidDismiss,
+    });
+  };
+
+  onVideoFullscreenPlayerWillPresent = () => {
+    this.invokeListenersUpdate({
+      callbackName:
+        SharedPlayerCallBacksKeys.onVideoFullscreenPlayerWillPresent,
+    });
+  };
+
+  onVideoFullscreenPlayerDidPresent = () => {
+    this.invokeListenersUpdate({
+      callbackName: SharedPlayerCallBacksKeys.onVideoFullscreenPlayerDidPresent,
+    });
+  };
+
   public invokeListenersUpdate = ({
     callbackName,
     event = {},
@@ -630,6 +660,12 @@ export class Player {
     onBufferStart: this.onBufferStart,
     onBufferComplete: this.onBufferComplete,
 
+    onPlayerClose: this.onPlayerClose,
+    onVideoFullscreenPlayerWillPresent: this.onVideoFullscreenPlayerWillPresent,
+    onVideoFullscreenPlayerDidPresent: this.onVideoFullscreenPlayerDidPresent,
+    onVideoFullscreenPlayerWillDismiss: this.onVideoFullscreenPlayerWillDismiss,
+    onVideoFullscreenPlayerDidDismiss: this.onVideoFullscreenPlayerDidDismiss,
+
     // Ads Callbacks:
     onAdBegin: this.onAdBegin,
     onAdBreakBegin: this.onAdBreakBegin,
@@ -652,6 +688,10 @@ export class Player {
     _selected?: QuickBrickPlayer.TextTrack | QuickBrickPlayer.AudioTrack
   ) => {};
 
+  setPlaybackRate = (_rate) => {};
+  startSleepTimer = (_timestamp) => {};
+  cancelSleepTimer = () => {};
+
   getPluginConfiguration = () => null;
   appStateChange = (_appState, _previousAppState) => {};
 
@@ -685,4 +725,7 @@ export class Player {
   isFullScreenSupported(): boolean {
     return true;
   }
+
+  public supportsNativeControls = (): boolean => false;
+  public supportNativeCast = (): boolean => false;
 }

package/appUtils/playerManager/playerFactory.ts

@@ -9,21 +9,23 @@ type PlayerFactoryItem = {
 };
 
 type PlayerFactoryProps = {
-  player: any,
-  playerId: string,
-  autoplay: boolean,
-  entry: ZappEntry,
-  muted: boolean,
-  playerPluginId: string,
-  screenConfig: Record<string, any>,
-  playerRole: PlayerRole,
-}
+  player: any;
+  playerId: string;
+  autoplay: boolean;
+  entry: ZappEntry;
+  muted: boolean;
+  playerPluginId: string;
+  screenConfig: Record<string, any>;
+  playerRole: PlayerRole;
+};
 
 interface PlayerConstructor {
   new (params: any): Player;
 }
 
-export const playerFactory = (config: PlayerFactoryProps): PlayerFactoryItem | null => {
+export const playerFactory = (
+  config: PlayerFactoryProps
+): PlayerFactoryItem | null => {
   const IDENTIFIER = config?.playerPluginId;
 
   if (!IDENTIFIER) {

package/appUtils/playerManager/playerNative.ts

@@ -5,6 +5,7 @@ import { Player } from "./player";
 import { findNodeHandle, NativeModules } from "react-native";
 import { isApplePlatform } from "../../reactUtils";
 import { PlayerRole } from "./conts";
+import { toBooleanWithDefaultFalse } from "../../booleanUtils";
 
 const RNPlayerManager = {
   QuickBrickPlayerPlugin: isApplePlatform()
@@ -41,6 +42,9 @@ const PlayerModuleFuncNames = {
   rewind: "rewind",
   play: "play",
   pause: "pause",
+  startSleepTimer: "startSleepTimer",
+  cancelSleepTimer: "cancelSleepTimer",
+  getSleepTimerEnd: "getSleepTimerEnd",
 };
 
 export class PlayerNative extends Player {
@@ -172,6 +176,25 @@ export class PlayerNative extends Player {
     }
   };
 
+  startSleepTimer = (sleepTimestamp: number) => {
+    if (
+      !this.invokeNativeFunction(
+        PlayerModuleFuncNames.startSleepTimer,
+        sleepTimestamp
+      )
+    ) {
+      this.currentPlayerComponent()?.["startSleepTimer"](sleepTimestamp);
+    }
+  };
+
+  cancelSleepTimer = () => {
+    if (!this.invokeNativeFunction(PlayerModuleFuncNames.cancelSleepTimer)) {
+      this.currentPlayerComponent()?.[
+        PlayerModuleFuncNames.cancelSleepTimer
+      ]?.();
+    }
+  };
+
   disableBufferAnimation = (): boolean => false;
 
   setLanguage = (
@@ -180,6 +203,10 @@ export class PlayerNative extends Player {
     this.currentPlayerComponent()?.["setLanguage"]?.(selected);
   };
 
+  setPlaybackRate = (rate: number) => {
+    this.currentPlayerComponent()?.["setPlaybackRate"]?.(rate);
+  };
+
   getPluginConfiguration = () => {
     return (this.currentPlayerComponent() as any)?.props?.pluginConfiguration;
   };
@@ -265,4 +292,12 @@ export class PlayerNative extends Player {
 
     return !(isFullScreenAudioPlayer && this.isAudioItem());
   };
+
+  supportsNativeControls = (): boolean =>
+    toBooleanWithDefaultFalse(this.getConfig()?.["supports_native_controls"]);
+
+  supportNativeCast = (): boolean =>
+    toBooleanWithDefaultFalse(
+      this.playerPluginId === "quick-brick-player-brightcove"
+    );
 }

package/appUtils/playerManager/usePlayerState.tsx

@@ -9,6 +9,7 @@ type PlayerState = {
   isLive: boolean;
   isPaused: boolean;
   isBuffering: boolean;
+  isReadyToPlay: boolean;
 };
 
 export const usePlayerState = (
@@ -20,12 +21,14 @@ export const usePlayerState = (
   const [seekableDuration, setSeekableDuration] = React.useState<number>(null);
   const [isLive, setIsLive] = React.useState<boolean>(null);
   const [isBuffering, setIsBuffering] = React.useState<boolean>(false);
+  const [isReadyToPlay, setIsReadyToPlay] = React.useState<boolean>(false);
   const [isPaused, setIsPaused] = React.useState<boolean>(false);
 
   const player: Player = usePlayer(playerId);
 
   const onPlayerChangeState = React.useCallback(() => {
     setIsBuffering(player.isBuffering());
+    setIsReadyToPlay(player.isReadyToPlay);
     setCurrentTime(player.getContentPosition());
     setDuration(player.getDuration());
     setSeekableDuration(player.getSeekableDuration());
@@ -60,7 +63,16 @@ export const usePlayerState = (
       isLive,
       isPaused,
       isBuffering,
+      isReadyToPlay,
     }),
-    [currentTime, duration, seekableDuration, isLive, isPaused, isBuffering]
+    [
+      currentTime,
+      duration,
+      seekableDuration,
+      isLive,
+      isPaused,
+      isBuffering,
+      isReadyToPlay,
+    ]
   );
 };

package/appUtils/playerManager/usePlayerTitleSummaryOverlay.tsx

@@ -0,0 +1,50 @@
+import { useEffect, useState } from "react";
+import { OverlaysObserver } from "./OverlayObserver/OverlaysObserver";
+import { useFeedLoader } from "../../reactHooks";
+import { usePlayer } from "./usePlayer";
+
+export const useTitleSummaryOverlay = (
+  feedUrl,
+  entry,
+  isLive = false,
+  interval: number
+) => {
+  const player = usePlayer();
+  const [title, setTitle] = useState<string | number>(entry?.title || "");
+  const [summary, setSummary] = useState<string | number>(entry?.summary || "");
+
+  // Hook to load feed data
+  const { data: feedData, reloadData } = useFeedLoader({ feedUrl });
+
+  useEffect(() => {
+    if (player && feedUrl && isLive) {
+      const observer = new OverlaysObserver({ player });
+
+      observer.setFeedDataHandlers(feedUrl, reloadData, interval, (entry) => {
+        setTitle(entry?.title || "");
+        setSummary(entry?.summary || "");
+      });
+
+      const subscription = observer
+        .getTitleSummaryObservable()
+        .subscribe(({ title, summary }) => {
+          setTitle(title);
+          setSummary(summary);
+        });
+
+      return () => {
+        subscription.unsubscribe();
+        observer.clearFeedDataInterval();
+      };
+    }
+  }, [player, feedUrl, reloadData, isLive]);
+
+  useEffect(() => {
+    if (isLive && feedData?.entry?.[0]) {
+      setTitle(feedData.entry[0].title || "");
+      setSummary(feedData.entry[0].summary || "");
+    }
+  }, [feedData]);
+
+  return { title, summary };
+};