@applicaster/zapp-react-native-ui-components 16.0.0-alpha.1453660071 → 16.0.0-alpha.1454930193

package/Components/OfflineHandler/__tests__/index.test.tsx

@@ -1,26 +1,26 @@
 import React from "react";
+import { Text } from "react-native";
 import { render } from "@testing-library/react-native";
+import { subscriberFor } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
 
 jest.useFakeTimers({ legacyFakeTimers: true });
 
+// `isOnline` (@applicaster/quick-brick-core/App/NetworkStatusProvider/utils)
+// only treats connectionInfo as "ready" when it has NetInfoState-shaped
+// isConnected/isInternetReachable/details fields, so the mock has to mirror
+// that shape for online/offline to actually be distinguishable.
 let mockConnectionStatus = false;
-const mockPreviousValue = null;
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/connection", () => {
   return {
     ...jest.requireActual(
       "@applicaster/zapp-react-native-utils/reactHooks/connection"
     ),
-    useConnectionInfo: jest.fn(() => mockConnectionStatus),
-  };
-});
-
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks/utils", () => {
-  return {
-    ...jest.requireActual(
-      "@applicaster/zapp-react-native-utils/reactHooks/utils"
-    ),
-    usePrevious: jest.fn(() => mockPreviousValue),
+    useConnectionInfo: jest.fn(() => ({
+      details: {},
+      isConnected: mockConnectionStatus,
+      isInternetReachable: mockConnectionStatus,
+    })),
   };
 });
 
@@ -54,21 +54,81 @@ jest.mock("react-native-safe-area-context", () => ({
 }));
 
 describe("OfflineHandler", () => {
-  const { OfflineHandler, NotificationView } = require("../");
+  const { OfflineHandler } = require("../");
+
+  beforeEach(() => {
+    mockConnectionStatus = false;
+  });
+
+  it("renders its children without wrapping them in a notification view", () => {
+    const { toJSON } = render(
+      <OfflineHandler>
+        <Text>child content</Text>
+      </OfflineHandler>
+    );
 
-  it("renders", () => {
-    const { toJSON } = render(<OfflineHandler />);
     expect(toJSON()).toMatchSnapshot();
   });
 
-  it("renders Notification mode if component was rendered while online", () => {
+  it("emits a showToast event on mount when the device starts offline", () => {
+    mockConnectionStatus = false;
+
+    const handleShowToast = jest.fn();
+    const unsubscribe = subscriberFor("showToast", handleShowToast);
+
+    render(<OfflineHandler />);
+
+    expect(handleShowToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "offline-status",
+        message: "No internet connection",
+        timeout: 5000,
+      }),
+      // the shared event bus appends a dispose fn as the last handler arg
+      expect.any(Function)
+    );
+
+    unsubscribe();
+  });
+
+  it("does not emit a showToast event on mount when the device starts online", () => {
     mockConnectionStatus = true;
 
-    const { rerender, UNSAFE_getByType } = render(<OfflineHandler />);
+    const handleShowToast = jest.fn();
+    const unsubscribe = subscriberFor("showToast", handleShowToast);
+
+    render(<OfflineHandler />);
+
+    expect(handleShowToast).not.toHaveBeenCalled();
+
+    unsubscribe();
+  });
+
+  it("emits a showToast event when the device comes back online", () => {
+    mockConnectionStatus = false;
+
+    const handleShowToast = jest.fn();
+    const unsubscribe = subscriberFor("showToast", handleShowToast);
+
+    const { rerender } = render(<OfflineHandler />);
 
+    // ignore the offline toast emitted on mount; we only care about the
+    // offline -> online transition here
+    handleShowToast.mockClear();
+
+    mockConnectionStatus = true;
     rerender(<OfflineHandler />);
 
-    const notificationsView = UNSAFE_getByType(NotificationView);
-    expect(notificationsView).toBeDefined();
+    expect(handleShowToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "offline-status",
+        message: "You are back online",
+        timeout: 2000,
+      }),
+      // the shared event bus appends a dispose fn as the last handler arg
+      expect.any(Function)
+    );
+
+    unsubscribe();
   });
 });

package/Components/OfflineHandler/hooks.ts

@@ -0,0 +1,111 @@
+import React, { useMemo } from "react";
+
+import {
+  isWeb,
+  platformSelect,
+} from "@applicaster/zapp-react-native-utils/reactUtils";
+import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+
+import { usePlugins } from "@applicaster/zapp-react-native-redux";
+import { textTransform } from "@applicaster/zapp-react-native-utils/cellUtils";
+import { findPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
+
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+const OFFLINE_EXPERIENCE = "offline-experience";
+
+const NETWORK_STATUS_LOCALIZATIONS_KEY = "network_status_localizations";
+
+const THEME_STORAGE_NAMESPACE = "quick-brick-theme";
+
+export function useNetworkStatusLocalizations() {
+  const [storedLocalizations, setStoredLocalizations] = React.useState<Record<
+    string,
+    string
+  > | null>(null);
+
+  React.useEffect(() => {
+    async function loadStoredLocalizations() {
+      try {
+        const stored = await sessionStorage.getItem(
+          NETWORK_STATUS_LOCALIZATIONS_KEY,
+          THEME_STORAGE_NAMESPACE
+        );
+
+        if (stored) {
+          setStoredLocalizations(stored);
+        }
+      } catch (error) {
+        console.error("Error loading network status localizations", error);
+      }
+    }
+
+    loadStoredLocalizations();
+  }, []);
+
+  return storedLocalizations;
+}
+
+export function useOfflineHandlerProps(online: boolean) {
+  const theme = useTheme<BaseThemePropertiesTV>();
+  const storedLocalizations = useNetworkStatusLocalizations();
+  const plugins = usePlugins();
+  const offlinePlugin = findPluginByIdentifier(OFFLINE_EXPERIENCE, plugins);
+  const { useOfflineExperienceConfiguration } = offlinePlugin?.module ?? {};
+
+  const {
+    configurationFields,
+    localizations,
+  }: {
+    configurationFields: OfflineExperiencePluginConfiguration;
+    localizations: OfflineExperienceLocalizations;
+  } = useOfflineExperienceConfiguration?.() ?? {};
+
+  let title, subtitle, style;
+
+  if (isWeb()) {
+    title = online
+      ? (theme?.online_notification_title ??
+        storedLocalizations?.online_notification_title)
+      : (theme?.offline_notification_title ??
+        storedLocalizations?.offline_notification_title);
+
+    subtitle = online
+      ? (theme?.online_notification_subtitle ??
+        storedLocalizations?.online_notification_subtitle)
+      : (theme?.offline_notification_subtitle ??
+        storedLocalizations?.offline_notification_subtitle);
+  } else {
+    title = textTransform(
+      configurationFields.offline_toast_message_text_transform,
+      online
+        ? localizations.online_toast_message
+        : localizations.offline_toast_message
+    );
+
+    style = {
+      color: online
+        ? configurationFields.offline_toast_message_online_font_color
+        : configurationFields.offline_toast_message_font_color,
+      backgroundColor: online
+        ? configurationFields.offline_toast_online_background_color
+        : configurationFields.offline_toast_offline_background_color,
+      fontFamily: platformSelect({
+        ios: configurationFields.offline_toast_message_ios_font_family,
+        android: configurationFields.offline_toast_message_android_font_family,
+      }),
+      fontSize: configurationFields.offline_toast_message_font_size,
+      lineHeight: configurationFields.offline_toast_message_line_height,
+      letterSpacing: platformSelect({
+        ios: configurationFields.offline_toast_message_letter_spacing_ios,
+        android:
+          configurationFields.offline_toast_message_letter_spacing_android,
+      }),
+    };
+  }
+
+  return useMemo(
+    () => ({ message: title, extraMessage: subtitle, style }),
+    [title, subtitle, style]
+  );
+}

package/Components/OfflineHandler/index.tsx

@@ -1,105 +1,83 @@
-import React, { useCallback, useEffect, useRef, useState } from "react";
-import { View, StyleSheet } from "react-native";
-import { NotificationView as NotificationViewNative } from "./NotificationView/NotificationView";
-import { NotificationView as NotificationViewSamsung } from "./NotificationView/NotificationView.samsung";
-import { NotificationView as NotificationViewLG } from "./NotificationView/NotificationView.lg";
-
+import React, { useCallback, useEffect } from "react";
 import { useConnectionInfo } from "@applicaster/zapp-react-native-utils/reactHooks/connection";
 import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
-import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { useSubscriberFor } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
 
+import { useOfflineHandlerProps } from "./hooks";
 import { componentsLogger } from "../../Helpers/logger";
 import { parseConnectionInfo } from "./utils";
 
 const logger = componentsLogger.addSubsystem("OfflineHandler");
 
+// mirrors NOTIFICATION_TOAST_EVENTS.SHOW_TOAST in
+// @applicaster/quick-brick-core/App/NotificationToastRenderer/NotificationToastManager
+// (kept as a literal here since this package must not depend on quick-brick-core)
+const SHOW_TOAST_EVENT = "showToast";
+const OFFLINE_STATUS_TOAST_ID = "offline-status";
+
 type Props = {
   children?: React.ReactElement<any>;
 };
 
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    position: "relative",
-  },
-});
-
 const timers = {
   goingOffline: 5000,
   goingOnline: 2000,
 };
 
-export const NotificationView = platformSelect({
-  samsung_tv: NotificationViewSamsung,
-  lg_tv: NotificationViewLG,
-  default: NotificationViewNative,
-});
-
 export const OfflineHandler = ({ children }: Props) => {
   const connectionInfo = useConnectionInfo(false);
-  const { online, deviceOnline } = parseConnectionInfo(connectionInfo);
+  const { online } = parseConnectionInfo(connectionInfo);
+  const prevOnline = usePrevious(online);
 
-  const [hidden, setHidden] = useState<boolean>(true);
-  const previousOnline: boolean = usePrevious(online);
-  const timer = useRef<NodeJS.Timeout | null>(null);
-  const initialRender = useRef(false);
+  const emitShowToast = useSubscriberFor(SHOW_TOAST_EVENT);
 
-  const dismiss = useCallback(() => {
-    setHidden(true);
+  const { message, extraMessage, style } = useOfflineHandlerProps(online);
 
-    if (timer.current) {
-      clearTimeout(timer.current);
-      timer.current = null;
-    }
-  }, []);
+  const showOnlineToast = useCallback(() => {
+    logger.log("Device is back online, emit toast");
 
-  const setTimer = useCallback((cb, duration) => {
-    if (timer.current) {
-      clearTimeout(timer.current);
-    }
+    emitShowToast({
+      id: OFFLINE_STATUS_TOAST_ID,
+      message,
+      extraMessage,
+      style,
+      timeout: timers.goingOnline,
+    });
+  }, [emitShowToast, message, extraMessage, style]);
+
+  const showOfflineToast = useCallback(() => {
+    logger.log("Device went offline, emit toast");
 
-    timer.current = setTimeout(cb, duration);
-  }, []);
+    emitShowToast({
+      id: OFFLINE_STATUS_TOAST_ID,
+      message,
+      extraMessage,
+      style,
+      timeout: timers.goingOffline,
+    });
+  }, [emitShowToast, message, extraMessage, style]);
 
   useEffect(() => {
-    if (initialRender.current) {
-      const wentOffline = previousOnline && online === false;
-      const wentOnline = !previousOnline && online;
-      const renderedOffline = !online && previousOnline === null;
-
-      if (!deviceOnline || wentOffline || renderedOffline) {
-        logger.log("Device went offline");
-        setTimer(() => setHidden(true), timers.goingOffline);
-        setHidden(false);
+    // On mount there is no previous state yet: only surface the offline toast
+    // for a device that starts offline. Don't announce "back online" for a
+    // device that was online to begin with.
+    if (prevOnline === undefined) {
+      if (!online) {
+        showOfflineToast();
       }
 
-      if (wentOnline) {
-        logger.log("Device is back online");
-        setHidden(false);
-        setTimer(() => setHidden(true), timers.goingOnline);
-      }
-    } else {
-      initialRender.current = true;
+      return;
     }
 
-    return () => {
-      if (timer.current) {
-        clearTimeout(timer.current);
-        timer.current = null;
+    // On subsequent renders, only emit a toast when the online/offline state changes.
+    if (prevOnline !== online) {
+      if (!online) {
+        showOfflineToast();
+      } else {
+        showOnlineToast();
       }
-    };
-  }, [connectionInfo]);
-
-  return (
-    <View style={styles.container}>
-      <NotificationView
-        hidden={hidden}
-        online={online}
-        previousOnline={previousOnline}
-        dismiss={dismiss}
-      >
-        {children}
-      </NotificationView>
-    </View>
-  );
+    }
+  }, [online, prevOnline, showOfflineToast, showOnlineToast]);
+
+  return children;
 };

package/Components/OfflineHandler/utils/index.ts

@@ -1,9 +1,8 @@
 import * as R from "ramda";
-
 import { NetInfoState } from "@react-native-community/netinfo";
 import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { isOnline as isOnlineUtils } from "@applicaster/quick-brick-core/App/NetworkStatusProvider/utils";
-import { useSafeAreaInsets } from "react-native-safe-area-context";
+
 import { Platform } from "react-native";
 
 type ConnectionInfo = NetInfoState & { deviceStatus: NetStatus };
@@ -51,14 +50,3 @@ export const parseConnectionInfo: typeof parseConnectionInfoForDefault =
     samsung_tv: parseConnectionInfoForSamsung,
     default: parseConnectionInfoForDefault,
   });
-
-export const useNotificationHeight = () => {
-  const insets = useSafeAreaInsets();
-
-  const navBarHeight = platformSelect({ ios: 44, android: 56 });
-
-  const statusHeight = insets.top;
-  const notificationHeight = statusHeight + navBarHeight;
-
-  return { statusHeight, notificationHeight };
-};

package/Components/PlayerContainer/PlayerContainer.tsx

@@ -9,6 +9,7 @@ import {
   platformSelect,
   isAndroidTVPlatform,
   isTvOSPlatform,
+  isApplePlatform,
 } from "@applicaster/zapp-react-native-utils/reactUtils";
 import {
   isAudioItem,
@@ -60,6 +61,7 @@ import {
   PlayerNativeSendCommand,
 } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/playerNativeCommand";
 import { useAppData } from "@applicaster/zapp-react-native-redux";
+import { PLAYER_EVENTS } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/const";
 
 type Props = {
   Player: React.ComponentType<any>;
@@ -188,12 +190,10 @@ const renderApplePlayer = ({
     return null;
   }
 
-  const { title, summary } = item || {};
-
+  // Title/Subtitle are not resolved here: `ProgramInfo` reads them from the
+  // player manager's content channel via `usePlayerContent`.
   return (
     <ProgramInfo
-      title={title}
-      subtitle={summary}
       plugin_configuration={pluginConfiguration}
       videoStyle={videoStyle}
     />
@@ -282,12 +282,16 @@ const PlayerContainerComponent = (props: Props) => {
     }
 
     log_debug(
-      `onPlayNextPerformNextVideoPlay: delay completed, replaceTop to item: ${playNextOverlayState.entry.title}, id: ${playNextOverlayState.entry.id}`
+      `onPlayNextPerformNextVideoPlay: delay completed, replaceTop to item: ${playNextOverlayState.entry.title}, id: ${playNextOverlayState.entry.id}, outgoing item id: ${item?.id}`
     );
 
+    playNextOverlayState.hidePlayNext();
+
+    playerEvent(PLAYER_EVENTS.PlayNextTriggered, { id: item?.id });
+
     setIsLoadingNextVideo(true);
     playEntry(playNextOverlayState.entry);
-  }, [playNextOverlayState]);
+  }, [playNextOverlayState, item?.id]);
 
   const playNextData: Nullable<PlayNextData> = React.useMemo(() => {
     if (!playNextOverlayState) {
@@ -495,7 +499,7 @@ const PlayerContainerComponent = (props: Props) => {
   const isAudioContent = isAudioItem(item);
 
   useEffect(() => {
-    if (!isAudioContent) {
+    if (!isAudioContent && isApplePlatform()) {
       sendQuickBrickEvent(
         QUICK_BRICK_EVENTS.IDLE_TIMER_DISABLED as QuickBrickEvent,
         {

package/Components/PlayerContainer/ProgramInfo/index.tsx

@@ -7,12 +7,11 @@ import * as React from "react";
 import { Text, TextStyle, View, ViewStyle } from "react-native";
 import { QBImage as Image } from "@applicaster/zapp-react-native-ui-components/Components/Image";
 
+import { usePlayerContent } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayerContent";
 import * as programStyles from "./styles";
 
 type Props = {
   logo?: string;
-  title: string;
-  subtitle: string;
   isAudioContent: boolean;
   styles: {};
   plugin_configuration: {
@@ -28,13 +27,13 @@ const defaultColor = "#EFEFEF";
 
 function ProgramInfoComponent({
   logo,
-  title = "",
-  subtitle = "",
   isAudioContent,
   styles,
   plugin_configuration = {},
   videoStyle = {},
 }: Props) {
+  const { title = "", summary: subtitle = "" } = usePlayerContent();
+
   const platformKey = styleKeys.style_namespace;
 
   const colorTitle =

package/Components/PlayerContainer/__tests__/PlayerContainer.test.tsx

@@ -17,16 +17,37 @@ jest.mock(
 );
 
 jest.mock("@applicaster/zapp-react-native-utils/reactUtils", () => ({
+  // Defaults to `false` for the hardware-back-handling tests below, which
+  // key off `isTV`. The ProgramInfo/content-context describe block below
+  // overrides this per test (`isTV()` is also what PlayerContainer's
+  // `playerContentValue` uses to pick TV vs mobile data keys, decoupled
+  // from `isTvOSPlatform` below).
   isTV: jest.fn(() => false),
   isAndroidTVPlatform: jest.fn(() => false),
-  isTvOSPlatform: jest.fn(() => false),
+  // `isTvOSPlatform` backs a module-level constant in PlayerContainer.tsx that
+  // is read once at import time, so it must already be `true` here in order
+  // to exercise `renderApplePlayer`'s tvOS-only ProgramInfo branch in this
+  // test file. It does not affect the hardware-back-handling tests below,
+  // which key off `isTV` instead.
+  isTvOSPlatform: jest.fn(() => true),
+  isApplePlatform: jest.fn(() => true),
   platformSelect: jest.fn(({ native }) => native),
 }));
 
-jest.mock("@applicaster/zapp-react-native-utils/playerUtils", () => ({
-  isAudioItem: jest.fn(() => false),
-  isInlineTV: jest.fn(() => false),
-}));
+jest.mock("@applicaster/zapp-react-native-utils/playerUtils", () => {
+  // Keep the real data-key resolver (createConfigValueGetter,
+  // resolvePlayerContentText, VIDEO_PLAYER_CONTENT_DATA_KEYS) so the tvOS
+  // ProgramInfo data-key tests exercise actual resolution logic, not a stub.
+  const actual = jest.requireActual(
+    "@applicaster/zapp-react-native-utils/playerUtils"
+  );
+
+  return {
+    ...actual,
+    isAudioItem: jest.fn(() => false),
+    isInlineTV: jest.fn(() => false),
+  };
+});
 
 jest.mock(
   "@applicaster/zapp-react-native-tvos-ui-components/Components/TVEventHandlerComponent",
@@ -75,6 +96,11 @@ jest.mock("@applicaster/zapp-react-native-bridge/QuickBrick", () => ({
   sendQuickBrickEvent: jest.fn(),
 }));
 
+// Stubbed so PlayerContainer can render without ProgramInfo's own
+// redux/style plumbing. It no longer needs to capture Title/Subtitle: those
+// come from the player manager's content channel, and the key-set selection
+// they depend on is covered directly in
+// `playerManager/__tests__/playerContent.test.ts`.
 jest.mock("../ProgramInfo", () => ({
   ProgramInfo: () => null,
 }));
@@ -142,14 +168,33 @@ jest.mock(
 jest.mock("../PlayerContainerContext", () => {
   const ReactActual = require("react");
 
+  const PlayerContainerContext = ReactActual.createContext({
+    isLanguageOverlayVisible: false,
+    bottomFocusableId: "bottom",
+    showComponentsContainer: false,
+    refs: null,
+  });
+
   return {
-    PlayerContainerContext: ReactActual.createContext({
-      isLanguageOverlayVisible: false,
-      bottomFocusableId: "bottom",
-      showComponentsContainer: false,
-      refs: null,
-    }),
-    PlayerContainerContextProvider: ({ children }) => children,
+    PlayerContainerContext,
+    // Mirrors just enough of the real provider for these tests: renders an
+    // actual `PlayerContainerContext.Provider` so the real
+    // `PlayerContainerContext.Consumer` inside PlayerContainer.tsx sees the
+    // container fields a real provider would give it, instead of a bare
+    // `({ children }) => children` passthrough.
+    PlayerContainerContextProvider: ({ children }: any) =>
+      ReactActual.createElement(
+        PlayerContainerContext.Provider,
+        {
+          value: {
+            isLanguageOverlayVisible: false,
+            bottomFocusableId: "bottom",
+            showComponentsContainer: false,
+            refs: null,
+          },
+        },
+        children
+      ),
   };
 });
 
@@ -200,7 +245,14 @@ const { __player: mockPlayer } = jest.requireMock(
   "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer"
 );
 
-const Player = React.forwardRef(() => null);
+const { isTV: mockIsTV } = jest.requireMock(
+  "@applicaster/zapp-react-native-utils/reactUtils"
+);
+
+// Renders children so that `renderApplePlayer`'s returned <ProgramInfo>
+// element (passed as this component's `children` prop) actually mounts —
+// otherwise React never invokes the ProgramInfo function component at all.
+const Player = React.forwardRef((props: any, _ref) => props.children ?? null);
 
 const item = {
   id: "entry-1",
@@ -234,6 +286,7 @@ const pressHardwareBack = () => {
 describe("PlayerContainer hardware back handling", () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    mockIsTV.mockReturnValue(false);
     mockBackHandlerRef.current = null;
     mockPlayer.getPluginConfiguration.mockReturnValue({});
     mockPlayer.isPaused.mockReturnValue(false);

package/Components/PreloaderWrapper/index.tsx

@@ -2,7 +2,7 @@ import React from "react";
 
 type PreloaderWrapperProps = {
   showPreloader?: boolean;
-  children?: React.ReactNode;
+  children: React.ReactElement | null;
 };
 
 export const PreloaderWrapper: React.FC<PreloaderWrapperProps> = ({