@applicaster/zapp-react-native-utils 12.0.0-alpha.5000126055 → 12.0.0-alpha.5001350756

package/reactHooks/feed/useFeedRefresh.tsx

@@ -1,7 +1,8 @@
 import * as React from "react";
-import * as R from "ramda";
+import { path, max } from "ramda";
 import { isTrue } from "@applicaster/zapp-react-native-utils/booleanUtils";
 import { toNumberWithDefault } from "@applicaster/zapp-react-native-utils/numberUtils";
+import { useIsScreenActive } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 
 import { reactHooksLogger } from "../logger";
 import { ReloadDataFunction } from "./useFeedLoader";
@@ -18,9 +19,8 @@ const minimumRefreshingInterval = 5;
 const defaultRefreshInterval = 60;
 
 export const useFeedRefresh = ({ reloadData, component }: Props): void => {
-  const enable_data_refreshing = R.path(
-    ["rules", "enable_data_refreshing"],
-    component
+  const isDataRefreshingEnabled = isTrue(
+    path(["rules", "enable_data_refreshing"], component)
   );
 
   const refreshing_interval = toNumberWithDefault(
@@ -29,10 +29,12 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
   );
 
   const refreshingIntervalInMilliseconds =
-    R.max(refreshing_interval, minimumRefreshingInterval) * 1000;
+    max(refreshing_interval, minimumRefreshingInterval) * 1000;
+
+  const isScreenActive = useIsScreenActive();
 
   React.useEffect(() => {
-    if (isTrue(enable_data_refreshing) && refreshing_interval) {
+    if (isDataRefreshingEnabled && refreshing_interval && isScreenActive) {
       if (refreshing_interval < minimumRefreshingInterval) {
         feedRefreshLogger.warning({
           message: `You set your feed refresh interval to ${refreshing_interval} when minimum value is ${minimumRefreshingInterval}seconds.Your feed will refresh after ${minimumRefreshingInterval}seconds.`,
@@ -59,5 +61,5 @@ export const useFeedRefresh = ({ reloadData, component }: Props): void => {
         clearInterval(refreshInterval);
       };
     }
-  }, [reloadData]);
+  }, [reloadData, isScreenActive]);
 };

package/reactHooks/navigation/index.ts

@@ -4,7 +4,6 @@
 import React, { useContext, useEffect, useMemo } from "react";
 import { BackHandler, InteractionManager, NativeModules } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
-import { isEmpty } from "ramda";
 
 import {
   useContentTypes,
@@ -13,7 +12,11 @@ import {
 import { HooksManager } from "@applicaster/zapp-react-native-utils/appUtils/HooksManager";
 
 import { legacyScreenData } from "@applicaster/quick-brick-core/App/NavigationProvider/utils";
-import { LONG_KEY_PRESS_TIMEOUT } from "@applicaster/quick-brick-core/const";
+import {
+  LONG_KEY_PRESS_TIMEOUT,
+  QUICK_BRICK_NAVBAR,
+  QUICK_BRICK_CONTENT,
+} from "@applicaster/quick-brick-core/const";
 import { useZappHooksModalState } from "@applicaster/zapp-react-dom-ui-components/Components/ZappHooksModal/ZappHooksModal";
 import { ZappHookModalContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import { PathnameContext } from "@applicaster/zapp-react-native-ui-components/Contexts/PathnameContext";
@@ -28,7 +31,7 @@ import { platformSelect } from "../../reactUtils";
 import { useConnectionInfo } from "../connection";
 import { getTargetScreenData } from "../screen/useTargetScreenData";
 
-import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { isTV, isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavbarState } from "../screen";
 import { useNavigation } from "./useNavigation";
 import { useModalStore } from "../../modalState";
@@ -207,10 +210,7 @@ export const useRoute = (): {
     return { screenData: screenDataContext, pathname };
   }
 
-  // Cover cases where screenContext is used before navigation is initialized
-  const screenData = isEmpty(screenDataContext)
-    ? navigator.screenData
-    : screenDataContext;
+  const screenData = screenDataContext;
 
   return { screenData, pathname };
 };
@@ -452,3 +452,36 @@ export const useIsScreenActive = () => {
 
   return pathname === currentRoute;
 };
+
+type Return = (prefix: string) => string;
+
+export const useUniqueRouteSuffix = (): Return => {
+  const pathname = usePathname();
+  const { currentRoute } = useNavigation();
+
+  const suffix = `currentRoute:${currentRoute}_pathname:${pathname}`;
+
+  const withUniqueRouteSuffix = React.useCallback((prefix: string) => {
+    if (isWeb()) {
+      // we should use extended route prefix only on Web, where we have stack-navigator
+      return `${prefix}___${suffix}`;
+    }
+
+    // for other platforms use previous version
+    return prefix;
+  }, []);
+
+  return withUniqueRouteSuffix;
+};
+
+export const useNavbarId = () => {
+  const withUniqueRouteSuffix = useUniqueRouteSuffix();
+
+  return withUniqueRouteSuffix(QUICK_BRICK_NAVBAR);
+};
+
+export const useContentId = () => {
+  const withUniqueRouteSuffix = useUniqueRouteSuffix();
+
+  return withUniqueRouteSuffix(QUICK_BRICK_CONTENT);
+};

package/reactHooks/player/__tests__/useAutoSeek.test.tsx

@@ -9,18 +9,11 @@ jest.useFakeTimers();
 
 const rewind = jest.fn();
 const forward = jest.fn();
-const exitDelayedSeek = jest.fn();
-const enterDelayedSeek = jest.fn();
 
 jest
   .spyOn(playerManager, "getInstanceController")
   // @ts-ignore
-  .mockImplementation(() => ({
-    rewind,
-    forward,
-    exitDelayedSeek,
-    enterDelayedSeek,
-  }));
+  .mockImplementation(() => ({ rewind, forward }));
 
 describe("useAutoSeek", () => {
   beforeEach(() => {

package/reactHooks/player/useAutoSeek.tsx

@@ -14,24 +14,19 @@ 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 setIntervalTimer = (cb) => {
-    if (intervalTimer.current) {
-      return;
-    }
-
-    intervalTimer.current = setInterval(() => {
-      intervalTimer.current = null;
-      cb();
-    }, ON_HOLD_INTERVAL);
+    intervalTimer.current = setInterval(cb, ON_HOLD_INTERVAL);
   };
 
   const clearIntervalTimer = () => {
-    clearInterval(intervalTimer.current);
-    intervalTimer.current = null;
+    try {
+      clearInterval(intervalTimer.current);
+    } catch (err) {
+      intervalTimer.current = null;
+    }
   };
 
   const resetState = () => {
@@ -42,21 +37,6 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
   };
 
   useEffect(() => {
-    const player = playerManager.getInstanceController();
-    if (!player) return;
-
-    if (isRunning) {
-      player?.enterDelayedSeek();
-    } else if (!isRunning) {
-      player.exitDelayedSeek();
-    }
-  }, [isRunning]);
-
-  useEffect(() => {
-    if (!isRunning) {
-      return;
-    }
-
     const player = playerManager.getInstanceController();
 
     if (!player) return;
@@ -65,7 +45,7 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
       player[direction](R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier));
       resetHUDTimer();
     }
-  }, [multiplier, direction, isRunning]);
+  }, [multiplier, direction]);
 
   useEffect(() => {
     if (isRunning && isRunning !== prevRunning) {
@@ -95,7 +75,7 @@ export const useAutoSeek = (resetHUDTimer = noop) => {
       setDirection(eventType);
       setIsRunning(true);
     },
-    [isRunning, autoSeekStop]
+    [isRunning]
   );
 
   return React.useMemo(

package/reactHooks/player/useSeek.tsx

@@ -9,11 +9,11 @@ export const useSeek = (resetHUDTimer = noop) => {
   const { autoSeekStart, autoSeekStop } = useAutoSeek(resetHUDTimer);
 
   const onForwardPress = () => {
-    // handlePressEvent(SEEK_TYPE.FORWARD);
+    handlePressEvent(SEEK_TYPE.FORWARD);
   };
 
   const onRewindPress = () => {
-    // handlePressEvent(SEEK_TYPE.REWIND);
+    handlePressEvent(SEEK_TYPE.REWIND);
   };
 
   const onForwardPressIn = () => {
@@ -21,7 +21,6 @@ export const useSeek = (resetHUDTimer = noop) => {
   };
 
   const onForwardPressOut = () => {
-    handlePressEvent(SEEK_TYPE.FORWARD);
     autoSeekStop();
   };
 
@@ -38,7 +37,6 @@ export const useSeek = (resetHUDTimer = noop) => {
   };
 
   const onRewindPressOut = () => {
-    handlePressEvent(SEEK_TYPE.REWIND);
     autoSeekStop();
   };
 

package/reactHooks/player/useTapSeek.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef } from "react";
 import * as R from "ramda";
 import {
   MAX_SEEK_TIME,
@@ -10,11 +10,13 @@ import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
 
 type SeekType = SEEK_TYPE | null;
 
-const getSkipTime = (multiplier) =>
-  R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
+const getSkipTime = (multiplier) => {
+  const skipTime = R.min(MAX_SEEK_TIME, SKIP_TIME_BASE * multiplier);
+
+  return skipTime;
+};
 
 export const useTapSeek = () => {
-  const [resumeTimer, setResumeTimer] = useState<NodeJS.Timeout>(null);
   const onPressMultiplier = useRef(1);
   const lastPressTime = useRef(0);
   const currentOnPressEventType = useRef<SeekType>(null);
@@ -44,41 +46,12 @@ export const useTapSeek = () => {
       }
 
       const seekTime = getSkipTime(onPressMultiplier.current);
-
       player[eventType](seekTime);
 
-      if (resumeTimer) {
-        clearTimeout(resumeTimer);
-
-        const timer = setTimeout(() => {
-          player.exitDelayedSeek();
-          setResumeTimer(null);
-        }, 2000);
-
-        setResumeTimer(timer);
-      }
-
-      const clicksBeforePause = 3;
-
-      // Only pause player if user starts to seek on large increments
-      if (onPressMultiplier.current > clicksBeforePause) {
-        if (!player.isPaused()) {
-          player.enterDelayedSeek();
-
-          const timer = setTimeout(() => {
-            player.exitDelayedSeek();
-            setResumeTimer(null);
-          }, 2000);
-
-          clearTimeout(resumeTimer);
-          setResumeTimer(timer);
-        }
-      }
-
       lastPressTime.current = now;
       currentOnPressEventType.current = eventType;
     },
-    [resetMultiplier, resumeTimer]
+    [resetMultiplier]
   );
 
   return handlePressEvent;

package/reactHooks/screen/__tests__/useCurrentScreenData.test.tsx

@@ -3,23 +3,28 @@ import { Provider } from "react-redux";
 import { renderHook } from "@testing-library/react-hooks";
 import configureStore from "redux-mock-store";
 import thunk from "redux-thunk";
-import { NavigationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NavigationContext";
 
 const mockStore = configureStore([thunk]);
 
-import { useCurrentScreenData } from "../useCurrentScreenData";
-
-describe("useScreenData", function () {
-  const river_id_2: ZappRiver = {
-    name: "River 2",
-    id: "A1234",
-    home: false,
-    home_offline: false,
-    supports_offline: false,
-    navigations: [],
-    hooks: { preload_plugins: [] },
-  };
-
+const river_id_2: ZappRiver = {
+  name: "River 2",
+  id: "A1234",
+  home: false,
+  home_offline: false,
+  supports_offline: false,
+  navigations: [],
+  hooks: { preload_plugins: [] },
+};
+
+jest.mock("../useScreenContext", () => ({
+  useScreenContext: () => ({
+    screen: river_id_2,
+  }),
+}));
+
+const { useCurrentScreenData } = require("../useCurrentScreenData");
+
+describe("useScreenData", () => {
   const river_id_1 = { id: "B5678" };
 
   const store = mockStore({
@@ -27,17 +32,10 @@ describe("useScreenData", function () {
   });
 
   const wrapper: React.FC<any> = ({ children }) => (
-    <NavigationContext.Provider
-      value={{
-        currentRoute: "/river/river_id_1/river/river_id_2",
-        data: { screen: river_id_2 },
-      }}
-    >
-      <Provider store={store}>{children}</Provider>
-    </NavigationContext.Provider>
+    <Provider store={store}>{children}</Provider>
   );
 
-  it("should return river data for the current screen/route", function () {
+  it("should return river data for the current screen/route", () => {
     const { result } = renderHook(() => useCurrentScreenData(), { wrapper });
 
     expect(result.current).toBe(river_id_2);

package/reactHooks/screen/index.ts

@@ -10,3 +10,5 @@ export {
   useNavbarState,
   useSetNavbarState,
 } from "./useScreenContext";
+
+export { useScreenBackgroundColor } from "./useScreenBackgroundColor";

package/reactHooks/screen/useScreenBackgroundColor.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+import { useScreenConfiguration } from "@applicaster/zapp-react-native-ui-components/Components/River/useScreenConfiguration";
+import { ifEmptyUseFallback } from "@applicaster/zapp-react-native-utils/cellUtils";
+
+export const useScreenBackgroundColor = (screenId: string): string => {
+  const { backgroundColor: screenBackgroundColor } =
+    useScreenConfiguration(screenId);
+
+  const theme = useTheme();
+
+  const themeBackgroundColor = React.useMemo(
+    () => theme.app_background_color,
+    [theme.app_background_color]
+  );
+
+  const backgroundColor = ifEmptyUseFallback(
+    screenBackgroundColor,
+    themeBackgroundColor
+  );
+
+  return backgroundColor;
+};

package/reactHooks/screen/useScreenContext.ts

@@ -45,8 +45,7 @@ export function useSetNavbarState() {
 
 export function useScreenContext(): NavigationScreenData {
   const navigator = useNavigation();
-  // Cover cases where screenContext is used before navigation is initialized
-  const screenData = useContext(ScreenDataContext) || navigator.data;
+  const screenData = useContext(ScreenDataContext);
 
   const modalScreenData = navigator?.modalData;
 

package/reactUtils/index.ts

@@ -108,3 +108,105 @@ export const isAndroidPlatform = () => Platform.OS === "android";
 export const isTvOSPlatform = () => getPlatform() === "tvos";
 
 export const isAndroidTVPlatform = () => getPlatform() === "android_tv";
+
+declare global {
+  interface Window {
+    VIZIO?: {
+      exitApplication: () => void;
+      setClosedCaptionHandler: (
+        callback: (isCCEnabled: boolean) => void
+      ) => void;
+    };
+  }
+}
+
+/**
+ * Platforms found in userAgent string, please note that simulators
+ * might not have the same agents that the devices have
+ */
+export const PLATFORMS = {
+  webos: "Web0S",
+  tizen: "Tizen",
+  samsung: "SMART-TV",
+  mac: "Mac",
+  win: "Win",
+  linux: "Linux",
+  iphone: "iPhone",
+  android: "Android",
+  mobile: "Mobile",
+  vizio: "VIZIO",
+  smartcast: "SmartCast",
+  conjure: "Conjure",
+};
+
+/**
+ * Simple way of identifying if we have access to the tizen APIs
+ */
+export const hasTizen = typeof window?.tizen !== "undefined";
+
+/**
+ * Simple way of identifying if we have access to the webOS APIs
+ */
+export const hasWebOS = typeof window?.webOS !== "undefined";
+
+export const getUserAgent = () =>
+  window?.navigator?.userAgent || global?.navigator?.userAgent;
+
+export const isLgPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  // Note: LG uses the number 0 in their userAgent, possibly because of Palm WebOS
+  return hasWebOS || userAgent.includes(PLATFORMS.webos);
+};
+
+export const isSamsungPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  return (
+    hasTizen ||
+    userAgent.includes(PLATFORMS.samsung) ||
+    userAgent.includes(PLATFORMS.tizen)
+  );
+};
+
+/**
+ * Checks if we are on the Vizio platform by using the userAgent string
+ *
+ * Use this method when you need to identify the platform on runtime
+ * before the VIZIO Companion Library has loaded
+ */
+export const isVizioPlatform = () => {
+  const userAgent = getUserAgent();
+
+  if (!userAgent) {
+    return false;
+  }
+
+  const isVizioAgent =
+    userAgent.includes(PLATFORMS.vizio) ||
+    userAgent.includes(PLATFORMS.smartcast) ||
+    userAgent.includes(PLATFORMS.conjure);
+
+  return isVizioAgent;
+};
+
+/**
+ * Checks if we are on the Vizio platform by checking for the global VIZIO object
+ * and the VIZIO Companion Library. This method does not use the userAgent string,
+ * because it mainly checks whether we have access to apis, which may not be available yet
+ */
+export const hasVizioAPIs = () => {
+  const hasAPIs =
+    typeof window.VIZIO !== "undefined" &&
+    window?.applicaster?.vizioLibraryDidLoad;
+
+  return hasAPIs;
+};

package/analyticsUtils/AnalyticPlayerListener.ts

@@ -1,155 +0,0 @@
-import { PlayerAnalyticsTracker } from "./playerAnalyticsTracker";
-import { Player } from "../appUtils/playerManager/player";
-import { AD_EVENT, GENERAL_EVENT, PLAYBACK_EVENT, QOS_EVENT } from "./events";
-
-type Props = {
-  analyticsTracker: any;
-  player: any;
-};
-
-/* eslint brace-style: 0 */ // --> OFF
-export class AnalyticPlayerListener
-  implements QuickBrickPlayer.SharedPlayerCallBacks
-{
-  static analyticsListenerID = "analytics-listener";
-  private analyticsTracker: PlayerAnalyticsTracker;
-  private player: Player;
-
-  private onVideoLoadCalled; // android only
-
-  constructor(props: Props) {
-    this.analyticsTracker = props.analyticsTracker;
-    this.player = props.player;
-  }
-
-  handleAnalyticEvent = (event, data = {}) => {
-    if (this.analyticsTracker?.handleAnalyticEvent) {
-      this.analyticsTracker?.handleAnalyticEvent?.(event, {
-        ...data,
-        player_type: this.player.playerPluginId,
-      });
-    }
-  };
-
-  onVideoEnd = () => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.complete);
-  };
-
-  onError = (err: Error) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.error, err); // TODO: Check error format
-  };
-
-  // HACK: This is a hack to ignore the next resume event after a delayed seek
-  private ignoreNextResume = false;
-  onLoad = () => {
-    this.ignoreNextResume = false;
-  }
-
-  onPlayerPause = (event) => {
-    if (!this.player.isInDelayedSeek()) {
-      this.handleAnalyticEvent(PLAYBACK_EVENT.pause, event);
-    } else {
-      this.ignoreNextResume = true;
-    }
-  };
-
-  onPlayerResume = (event) => {
-    if (!this.player.isInDelayedSeek() && !this.ignoreNextResume) {
-      this.handleAnalyticEvent(PLAYBACK_EVENT.play, event);
-    } else {
-      this.ignoreNextResume = false;
-    }
-  };
-
-  onPlayerSeekComplete = (event) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.seek_complete, event);
-  };
-
-  onPlayerSeekStart = (event) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.seek_start, event);
-  };
-
-  onBufferStart = (event) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.buffer_start, event);
-  };
-
-  onBufferComplete = (event) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.buffer_complete, event);
-  };
-
-  // Not implemented
-  onPlayerStop = (event) => {
-    this.handleAnalyticEvent(PLAYBACK_EVENT.stop, event);
-  };
-
-  // TODO: Implement method on native
-  onVideoBandwidthUpdate = (event) => {
-    this.handleAnalyticEvent(QOS_EVENT.bitrate_changed, event);
-  };
-
-  onAdBegin = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_start, event);
-  };
-
-  onAdBreakBegin = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_break_start, event);
-  };
-
-  onAdBreakEnd = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_break_completed, event);
-  };
-
-  onAdEnd = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_complete, event);
-  };
-
-  onAdError = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_error, event);
-  };
-
-  onAdRequest = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_request, event);
-  };
-
-  onAdClicked = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_clicked, event);
-  };
-
-  onAdTapped = (event) => {
-    this.handleAnalyticEvent(AD_EVENT.ad_tapped, event);
-  };
-
-  onVideoLoad = () => {
-    // if (!this.state.isAd && !this.onVideoLoadCalled) {
-    if (!this.player.isAd() && !this.onVideoLoadCalled) {
-      this.onVideoLoadCalled = true;
-
-      this.handleAnalyticEvent(PLAYBACK_EVENT.load_video, {
-        player_type: this.player.playerPluginId,
-      });
-    }
-  };
-
-  onPlayerSessionEnd = () => {
-    // TODO: Implement method on native android, ios exists
-    this.handleAnalyticEvent(GENERAL_EVENT.session_end);
-  };
-
-  onPlayerSessionStart = () => {
-    // TODO: Implement method on native android, ios exists
-
-    this.handleAnalyticEvent(GENERAL_EVENT.session_start);
-  };
-
-  onPlayerNext = ({ nativeEvent }) => {
-    // TODO: Implement method on native
-
-    this.handleAnalyticEvent(PLAYBACK_EVENT.next, nativeEvent);
-  };
-
-  onPlayerPrevious = ({ nativeEvent }) => {
-    // TODO: Implement method on native
-
-    this.handleAnalyticEvent(PLAYBACK_EVENT.previous, nativeEvent);
-  };
-}