@applicaster/zapp-react-native-utils 12.0.0-rc.25 → 12.0.0-rc.28

package/analyticsUtils/__tests__/analyticsManager.test.js

@@ -1,18 +1,18 @@
+import * as ReactNative from "react-native";
+
 const mock_postEvent = jest.fn();
 const mock_setPlugins = jest.fn();
 const mock_postTimedEvent = jest.fn();
 const mock_endTimedEvent = jest.fn();
 
-jest.mock("react-native", () => ({
-  NativeModules: {
-    AnalyticsBridge: {
-      postEvent: mock_postEvent,
-      setPlugins: mock_setPlugins,
-      postTimedEvent: mock_postTimedEvent,
-      endTimedEvent: mock_endTimedEvent,
-    },
-  },
-}));
+const AnalyticsBridge = {
+  postEvent: mock_postEvent,
+  setPlugins: mock_setPlugins,
+  postTimedEvent: mock_postTimedEvent,
+  endTimedEvent: mock_endTimedEvent,
+};
+
+ReactNative.NativeModules.AnalyticsBridge = AnalyticsBridge;
 
 const eventName = "event";
 const payload = {};
@@ -26,90 +26,92 @@ function clearAllMocks() {
   mock_endTimedEvent.mockClear();
 }
 
-describe("isValidAnalyticsData", () => {
-  beforeEach(clearAllMocks);
+describe("AnalyticsManager", () => {
+  describe("isValidAnalyticsData", () => {
+    beforeEach(clearAllMocks);
 
-  it("returns false if eventName is not a string", () => {
-    expect(analyticsManager.isValidAnalyticsData(42)).toBe(false);
-    expect(analyticsManager.isValidAnalyticsData({})).toBe(false);
-    expect(analyticsManager.isValidAnalyticsData([])).toBe(false);
-    expect(analyticsManager.isValidAnalyticsData(() => ({}))).toBe(false);
-  });
+    it("returns false if eventName is not a string", () => {
+      expect(analyticsManager.isValidAnalyticsData(42)).toBe(false);
+      expect(analyticsManager.isValidAnalyticsData({})).toBe(false);
+      expect(analyticsManager.isValidAnalyticsData([])).toBe(false);
+      expect(analyticsManager.isValidAnalyticsData(() => ({}))).toBe(false);
+    });
 
-  it("returns false if payload is not an object", () => {
-    expect(analyticsManager.isValidAnalyticsData(eventName, "string")).toBe(
-      false
-    );
+    it("returns false if payload is not an object", () => {
+      expect(analyticsManager.isValidAnalyticsData(eventName, "string")).toBe(
+        false
+      );
 
-    expect(analyticsManager.isValidAnalyticsData(eventName, 42)).toBe(false);
+      expect(analyticsManager.isValidAnalyticsData(eventName, 42)).toBe(false);
 
-    expect(analyticsManager.isValidAnalyticsData(eventName, () => ({}))).toBe(
-      false
-    );
-  });
+      expect(analyticsManager.isValidAnalyticsData(eventName, () => ({}))).toBe(
+        false
+      );
+    });
 
-  it("returns true if eventName is a string and payload is null or an object", () => {
-    expect(analyticsManager.isValidAnalyticsData(eventName)).toBe(true);
+    it("returns true if eventName is a string and payload is null or an object", () => {
+      expect(analyticsManager.isValidAnalyticsData(eventName)).toBe(true);
 
-    expect(analyticsManager.isValidAnalyticsData(eventName, payload)).toBe(
-      true
-    );
+      expect(analyticsManager.isValidAnalyticsData(eventName, payload)).toBe(
+        true
+      );
+    });
   });
-});
 
-describe("postAnalyticEvent", () => {
-  beforeEach(clearAllMocks);
+  describe("postAnalyticEvent", () => {
+    beforeEach(clearAllMocks);
 
-  it("calls the postEvent method of the analytic bridge", () => {
-    analyticsManager.postAnalyticEvent(eventName, payload);
-    expect(mock_postEvent).toHaveBeenCalledWith(eventName, payload);
-  });
+    it("calls the postEvent method of the analytic bridge", () => {
+      analyticsManager.postAnalyticEvent(eventName, payload);
+      expect(mock_postEvent).toHaveBeenCalledWith(eventName, payload);
+    });
 
-  it("skips the event if it is not valid", () => {
-    analyticsManager.postAnalyticEvent(42);
-    expect(mock_postTimedEvent).not.toHaveBeenCalled();
+    it("skips the event if it is not valid", () => {
+      analyticsManager.postAnalyticEvent(42);
+      expect(mock_postTimedEvent).not.toHaveBeenCalled();
+    });
   });
-});
 
-describe("providePlugins", () => {
-  beforeEach(clearAllMocks);
+  describe("providePlugins", () => {
+    beforeEach(clearAllMocks);
 
-  it("calls the setPlugins method of the analytic bridge", () => {
-    const plugins = [];
-    const plugin_configurations = {};
-    const callback = jest.fn();
+    it("calls the setPlugins method of the analytic bridge", () => {
+      const plugins = [];
+      const plugin_configurations = {};
+      const callback = jest.fn();
 
-    analyticsManager.providePlugins(plugins, plugin_configurations, callback);
+      analyticsManager.providePlugins(plugins, plugin_configurations, callback);
 
-    expect(mock_setPlugins).toHaveBeenCalledWith(
-      plugins,
-      plugin_configurations,
-      callback
-    );
+      expect(mock_setPlugins).toHaveBeenCalledWith(
+        plugins,
+        plugin_configurations,
+        callback
+      );
+    });
   });
-});
 
-describe("startAnalyticsTimedEvent", () => {
-  beforeEach(clearAllMocks);
+  describe("startAnalyticsTimedEvent", () => {
+    beforeEach(clearAllMocks);
 
-  it("skips the event if it is not valid", () => {
-    analyticsManager.startAnalyticsTimedEvent(42);
-    expect(mock_postTimedEvent).not.toHaveBeenCalled();
+    it("skips the event if it is not valid", () => {
+      analyticsManager.startAnalyticsTimedEvent(42);
+      expect(mock_postTimedEvent).not.toHaveBeenCalled();
+    });
   });
-});
 
-describe("endAnalyticsTimedEvent", () => {
-  beforeEach(clearAllMocks);
+  describe("endAnalyticsTimedEvent", () => {
+    beforeEach(clearAllMocks);
 
-  it("emits a time_on_screen event and adds duration to payload", () => {
-    analyticsManager.endAnalyticsTimedEvent(eventName, payload);
-    const newEventName = "time_on_screen";
-    payload.duration = "N/A";
-    expect(mock_postEvent).toHaveBeenCalledWith(newEventName, payload);
-  });
+    it("emits a time_on_screen event and adds duration to payload", () => {
+      analyticsManager.endAnalyticsTimedEvent(eventName, payload);
+      const newEventName = "time_on_screen";
+      payload.duration = "N/A";
+      expect(mock_postEvent).toHaveBeenCalledWith(newEventName, payload);
+    });
 
-  it("skips the event if it is not valid", () => {
-    analyticsManager.endAnalyticsTimedEvent(42);
-    expect(mock_postEvent).not.toHaveBeenCalled();
+    it("skips the event if it is not valid", () => {
+      analyticsManager.endAnalyticsTimedEvent(42);
+      expect(mock_postEvent).not.toHaveBeenCalled();
+    });
   });
 });

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/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) => {};
 
@@ -652,6 +656,10 @@ export class Player {
     _selected?: QuickBrickPlayer.TextTrack | QuickBrickPlayer.AudioTrack
   ) => {};
 
+  setPlaybackRate = (_rate) => {};
+  startSleepTimer = (_timestamp) => {};
+  cancelSleepTimer = () => {};
+
   getPluginConfiguration = () => null;
   appStateChange = (_appState, _previousAppState) => {};
 

package/appUtils/playerManager/playerNative.ts

@@ -41,6 +41,9 @@ const PlayerModuleFuncNames = {
   rewind: "rewind",
   play: "play",
   pause: "pause",
+  startSleepTimer: "startSleepTimer",
+  cancelSleepTimer: "cancelSleepTimer",
+  getSleepTimerEnd: "getSleepTimerEnd",
 };
 
 export class PlayerNative extends Player {
@@ -172,6 +175,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 +202,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;
   };

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