@applicaster/zapp-react-native-utils 12.0.0-rc.5 → 12.0.0-rc.50

package/actionsExecutor/ActionExecutorContext.tsx

@@ -11,11 +11,9 @@ import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickB
 import { showConfirmationDialog } from "../alertUtils";
 import { createCloudEvent, sendCloudEvent } from "../cloudEventsUtils";
 import { createLogger } from "../logger";
-import {
-  StorageMultiSelectProvider
-} from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
+import { StorageMultiSelectProvider } from "@applicaster/zapp-react-native-bridge/ZappStorage/StorageMultiSelectProvider";
 
-const { log_error, log_debug, log_info } = createLogger({
+const { log_error, log_info } = createLogger({
   subsystem: "ActionExecutorContext",
   category: "General",
 });
@@ -110,11 +108,17 @@ const prepareDefaultActions = (actionExecutor) => {
       const tag = entry?.extensions?.tag;
 
       if (keyNamespace && tag) {
-        const multiSelectProvider = StorageMultiSelectProvider.getProvider(keyNamespace);
+        const multiSelectProvider =
+          StorageMultiSelectProvider.getProvider(keyNamespace);
 
         const selectedItems = await multiSelectProvider.getSelectedAsync();
         const isTagInSelectedItems = selectedItems.includes(tag);
-        log_info(`handleAction: localStorageToggleFlag event will ${isTagInSelectedItems ? "remove" : "add"} tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`);
+
+        log_info(
+          `handleAction: localStorageToggleFlag event will ${
+            isTagInSelectedItems ? "remove" : "add"
+          } tag: ${tag} for keyNamespace: ${keyNamespace}, current selectedItems: ${selectedItems}`
+        );
 
         if (selectedItems.includes(tag)) {
           await multiSelectProvider.removeItem(tag);
@@ -122,13 +126,17 @@ const prepareDefaultActions = (actionExecutor) => {
           await multiSelectProvider.addItem(tag);
         }
       } else {
-        log_error("handleAction: localStorageToggleFlag event missing keyNamespace or tag", { keyNamespace, tag });
+        log_error(
+          "handleAction: localStorageToggleFlag event missing keyNamespace or tag",
+          { keyNamespace, tag }
+        );
 
         return ActionResult.Error;
       }
 
       return ActionResult.Success;
-    });
+    }
+  );
 };
 
 export const ActionExecutorContext =

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/analyticsUtils/helpers/hooks.ts

@@ -26,7 +26,7 @@ export const useHookAnalytics = (props): void => {
     if (screenData?.hookPlugin?.module?.runInBackground) {
       sendScreenEvent({ analyticsScreenData });
     }
-  }, [hookPlugin.screen_id]);
+  }, [sendScreenEvent, screenData, hookPlugin.screen_id]);
 };
 
 export const useScreenAnalytics = (props) => {

package/appUtils/HooksManager/index.js

@@ -270,7 +270,9 @@ export function HooksManager({
         });
 
         const isHookInHomescreen = payload?.home;
-        const isHookFlowBlocker = hookPlugin?.module?.isFlowBlocker();
+
+        const isHookFlowBlocker =
+          hookPlugin?.module?.isFlowBlocker?.() ?? false;
 
         // TODO: We technically need to also support the case where there is more than one hook in the stack,
         // if needed we could add differentiation explicit user cancellation (when we should go to background) and other types of cancellation

package/appUtils/focusManager/treeDataStructure/Utils/index.js

@@ -187,11 +187,20 @@ export function getTargetInDirection(
         return null;
       }
 
+      const orientationDistance = measureDistance(
+        direction,
+        comparisonRect,
+        componentRect
+      );
+
+      const euclidDistance = measureEuclidianDistanceToCenter(
+        comparisonRect,
+        componentRect
+      );
+
       return {
         distance:
-          measureDistance(direction, comparisonRect, componentRect) +
-          measureEuclidianDistanceToCenter(comparisonRect, componentRect) /
-            10000,
+          orientationDistance > 0 ? euclidDistance : orientationDistance,
         target,
       };
     })

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/orientationHelper.ts

@@ -2,6 +2,7 @@
 import * as ReactNative from "react-native";
 import { isTV, platformSelect } from "../reactUtils";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { useIsTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
 
 import {
   QUICK_BRICK_EVENTS,
@@ -9,7 +10,6 @@ import {
   sendQuickBrickEvent,
 } from "@applicaster/zapp-react-native-bridge/QuickBrick";
 import { utilsLogger } from "../logger";
-import { useIsTablet } from "../reactHooks/device/useIsTablet";
 
 const { DeviceEventEmitter, NativeModules, NativeEventEmitter } = ReactNative;
 

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",