@applicaster/quick-brick-player 16.0.0-rc.8 → 16.0.0-rc.80

package/src/Player/AudioLayer/usePlaylistNavigation.ts

@@ -0,0 +1,134 @@
+import * as React from "react";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { usePlayer } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer";
+import {
+  loadFeedEntry,
+  retrieveFeedUrl,
+  retrievePlayPreviousFeedUrl,
+} from "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils";
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_error, log_info } = createLogger({
+  subsystem: "Player",
+  category: "usePlaylistNavigation",
+});
+
+const RESTART_THRESHOLD_SECONDS = 3;
+
+export type PlaylistNavigation = {
+  hasNext: boolean;
+  hasPrevious: boolean;
+  goNext: () => Promise<void>;
+  goPrevious: () => Promise<void>;
+};
+
+/**
+ * Each entry points at the feed holding its neighbour, so the chain walks
+ * itself and needs no client-side queue.
+ */
+export const usePlaylistNavigation = (
+  entry: ZappEntry,
+  playerState: QuickBrickPlayer.PlayerState
+): PlaylistNavigation => {
+  const navigator = useNavigation();
+  // Not playerManager.getActivePlayer(): that is always the local player, so
+  // seeking would miss the receiver while casting.
+  const player = usePlayer();
+
+  const [nextUrl, setNextUrl] = React.useState<string | null>(null);
+
+  React.useEffect(() => {
+    let cancelled = false;
+
+    retrieveFeedUrl(entry)
+      .then((url) => {
+        if (!cancelled) {
+          setNextUrl(url ?? null);
+        }
+      })
+      .catch((error) => {
+        log_error(
+          "usePlaylistNavigation: could not resolve the next feed url",
+          { error }
+        );
+
+        if (!cancelled) {
+          setNextUrl(null);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [entry]);
+
+  const previousUrl = retrievePlayPreviousFeedUrl(entry);
+  const currentTime = playerState?.currentTime ?? 0;
+
+  const canRestart = (playerState?.seekableDuration ?? 0) > 0;
+
+  const isNavigatingRef = React.useRef(false);
+
+  const navigateTo = React.useCallback(
+    async (feedUrl: string) => {
+      // A second tap mid-flight resolves to the same target, since `entry` has
+      // not been replaced yet.
+      if (isNavigatingRef.current) {
+        return;
+      }
+
+      isNavigatingRef.current = true;
+
+      try {
+        const target = await loadFeedEntry(feedUrl, entry);
+
+        log_info(`navigateTo: playing "${target.title}", id: ${target.id}`, {
+          feedUrl,
+          targetId: target.id,
+        });
+
+        navigator.replaceTop(target);
+      } catch (error) {
+        log_error("navigateTo: could not play the neighbouring entry", {
+          error,
+          feedUrl,
+        });
+      } finally {
+        // Released on failure too, so one bad request cannot latch the control.
+        isNavigatingRef.current = false;
+      }
+    },
+    [entry, navigator]
+  );
+
+  const goNext = React.useCallback(async () => {
+    if (!nextUrl) return;
+
+    await navigateTo(nextUrl);
+  }, [nextUrl, navigateTo]);
+
+  const goPrevious = React.useCallback(async () => {
+    // Restarting belongs to the stream, not the chain — so it stays available
+    // at the head, where there is nothing to step back to.
+    const shouldRestart =
+      canRestart && (currentTime > RESTART_THRESHOLD_SECONDS || !previousUrl);
+
+    if (shouldRestart) {
+      player?.seekTo(0);
+
+      return;
+    }
+
+    if (!previousUrl) return;
+
+    await navigateTo(previousUrl);
+  }, [previousUrl, currentTime, canRestart, navigateTo, player]);
+
+  return {
+    hasNext: Boolean(nextUrl),
+    hasPrevious: Boolean(previousUrl) || canRestart,
+    goNext,
+    goPrevious,
+  };
+};

package/src/Player/AudioLayer/useSleepTimerModal.ts

@@ -1,30 +1,19 @@
 import { usePlayerState } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayerState";
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import {
   SLEEP_TIMER_OFF,
   SleepTimerController,
   SleepTimerState,
 } from "./SleepTimerManager";
-
-import { openBottomSheetModal } from "@applicaster/zapp-react-native-utils/modalState";
-
-import { SleepTimerModalHeader } from "./components/SleepTimerModalHeader";
-import { getSleepTimerOptions } from "../Const/sleepTimerOptions";
 import {
-  getBottomSheetModalLabelProps,
-  getBottomSheetModalIconProps,
-  getBottomSheetModalItemProps,
-  getBottomSheetModalSelectedItemIcon,
-  selectSleepTitle,
-  selectSleepOffLabel,
-} from "../Utils";
+  PLAYER_ACTION_IDENTIFIERS,
+  registerPlayerActions,
+} from "./playerActions";
 
-export const useSleepTimerModal = (player, configuration) => {
+export const useSleepTimerModal = (player) => {
   const playerState = usePlayerState("audio-player-sleep-timer-modal");
 
-  const title = configuration(selectSleepTitle);
-  const offLabel = configuration(selectSleepOffLabel);
-
   const [sleepTimerManager, setSleepTimerManager] =
     useState<SleepTimerController | null>(null);
 
@@ -33,19 +22,22 @@ export const useSleepTimerModal = (player, configuration) => {
   );
 
   useEffect(() => {
-    if (player) {
-      setSleepTimerManager(new SleepTimerController(player));
-    } else {
-      setSleepTimerManager(null);
-    }
+    setSleepTimerManager(player ? new SleepTimerController(player) : null);
   }, [player]);
 
   useEffect(() => {
     if (playerState?.isLive) {
-      // Resetting a sleep timer when audio content is live (Timer not supported on live video)
-      sleepTimerManager.setSleepTimer(SLEEP_TIMER_OFF).catch();
+      sleepTimerManager?.setSleepTimer(SLEEP_TIMER_OFF).catch(() => undefined);
+    }
+  }, [playerState?.isLive, sleepTimerManager]);
+
+  useEffect(() => {
+    if (!sleepTimerManager || playerState.isLive) {
+      return;
     }
-  }, [playerState?.isLive]);
+
+    return registerPlayerActions({ sleepController: sleepTimerManager });
+  }, [sleepTimerManager, playerState.isLive]);
 
   useEffect(() => {
     if (!playerState.isReadyToPlay) {
@@ -64,40 +56,11 @@ export const useSleepTimerModal = (player, configuration) => {
     };
   }, [sleepTimerManager]);
 
-  const onSleepSelect = useCallback(
-    async (item) => {
-      await sleepTimerManager?.setSleepTimer(item);
-    },
-    [sleepTimerManager]
-  );
-
   const onSleepButtonPress = useCallback(() => {
-    const timerDate = sleepTimerState.timerDate;
-
-    const timerRemaining =
-      timerDate !== 0 && +timerDate > Date.now() ? timerDate : null;
-
-    openBottomSheetModal({
-      modalBottomSheetContentProps: {
-        headerComponent: SleepTimerModalHeader,
-        items: getSleepTimerOptions(offLabel, timerRemaining),
-        onPress: onSleepSelect,
-        title,
-        summary: timerRemaining,
-        itemProps: getBottomSheetModalItemProps,
-        iconProps: getBottomSheetModalIconProps,
-        labelProps: getBottomSheetModalLabelProps,
-        getSelectedItemIcon: getBottomSheetModalSelectedItemIcon,
-      },
-      options: {
-        supportedOrientations: [
-          "portrait",
-          "landscape",
-          "portrait-upside-down",
-        ],
-      },
-    });
-  }, [sleepTimerState.timerDate, sleepTimerState.timer, title, onSleepSelect]);
+    uiActionsRegistry
+      .getAction(PLAYER_ACTION_IDENTIFIERS.SLEEP_TIMER)
+      ?.invokeAction(player?.entry);
+  }, [player]);
 
   return useMemo(
     () => ({

package/src/Player/PlayerModal/VideoPlayerModal.tsx

@@ -12,6 +12,7 @@ import {
   VIDEO_TRANSITION_THRESHOLD,
 } from "./consts";
 import { useIsTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useIsTabletLandscape } from "@applicaster/zapp-react-native-utils/reactHooks/device/useMemoizedIsTablet";
 import { PROGRESS_BAR_HEIGHT } from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation/utils";
 import {
   SafeAreaView,
@@ -100,7 +101,23 @@ export function VideoPlayerModal({
     fullscreen || pip
   );
 
+  /* Landscape is a tablet's regular orientation, so rotating it says nothing
+     about the modal mode. useOrientationEffect skips its orientation effects
+     for the same reason, via the same predicate. */
+  const skipOrientationEffects = useIsTabletLandscape();
+
+  /* Props are the only reconciliation left once the listener below is skipped,
+     and even where it runs, the mount value goes stale: remounting during
+     native fullscreen would otherwise strand the modal in that layout. Rotating
+     a tablet flips the predicate itself, so reconcile then too — the last
+     orientation event may have left the state behind. */
+  React.useEffect(() => {
+    setFullScreenMode(fullscreen || pip);
+  }, [fullscreen, pip, skipOrientationEffects]);
+
   React.useEffect(() => {
+    if (skipOrientationEffects) return;
+
     const listener = addOrientationChangeListener(({ toOrientation }) => {
       /* ignored in collapsed mode non-PiP player */
       if (collapsed && !pip) return;
@@ -110,7 +127,7 @@ export function VideoPlayerModal({
     return () => {
       listener.remove();
     };
-  }, [collapsed, pip]);
+  }, [collapsed, pip, skipOrientationEffects]);
 
   const isFullScreenOrPIP = isFullScreenMode;
 

package/src/Player/PlayerModal/__tests__/VideoPlayerModal.test.tsx

@@ -0,0 +1,160 @@
+import React from "react";
+import { Text } from "react-native";
+import { act, render, screen } from "@testing-library/react-native";
+
+/**
+ * The modal's fullscreen layout is not directly observable, but the collapsed
+ * bar is: it renders only while the modal is NOT in that layout. Every case
+ * below therefore reads `collapsedBarWrapper` as the proxy for the state under
+ * test.
+ *
+ * Why it matters: while the modal sits in the fullscreen layout, a drag still
+ * drives navigation to MINIMIZED, which docks the player and hides the native
+ * controls (see Player/index.tsx `shouldUseNativeControls`). If the layout
+ * cannot follow the mode back out, the modal is stranded on top of the tab bar
+ * with no controls and no way to restore them.
+ */
+
+let mockIsTabletLandscape = false;
+let orientationListener: ((event: any) => void) | null = null;
+const mockRemove = jest.fn();
+
+const mockAddOrientationChangeListener = jest.fn((cb) => {
+  orientationListener = cb;
+
+  return { remove: mockRemove };
+});
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/orientationHelper",
+  () => ({
+    addOrientationChangeListener: (cb) => mockAddOrientationChangeListener(cb),
+  })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/device/useMemoizedIsTablet",
+  () => ({ useIsTabletLandscape: () => mockIsTabletLandscape })
+);
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
+  useIsTablet: () => mockIsTabletLandscape,
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/VideoModal/utils",
+  () => ({ useConfiguration: () => ({ minimised_height: 60 }) })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation/utils",
+  () => ({ PROGRESS_BAR_HEIGHT: 3 })
+);
+
+jest.mock("react-native-safe-area-context", () => {
+  const { View } = require("react-native");
+
+  return {
+    SafeAreaView: View,
+    useSafeAreaFrame: () => ({ x: 0, y: 0, width: 1024, height: 768 }),
+    useSafeAreaInsets: () => ({ top: 24, bottom: 34, left: 0, right: 0 }),
+  };
+});
+
+jest.mock("../GestureAnimatedScrollView", () => {
+  const { ScrollView } = require("react-native");
+
+  return { GestureAnimatedScrollView: ScrollView };
+});
+
+jest.mock("../styles", () => ({
+  useStyles: () => ({
+    modal: {},
+    modalWrapper: {},
+    collapsedModalBg: {},
+    modalContent: {},
+    modalContentPiP: {},
+    expandedContentContainer: {},
+    extraContentScrollView: {},
+    collapsedBarContainer: {},
+    collapsedBarWrapper: {},
+    flexNone: {},
+  }),
+}));
+
+jest.mock("../hooks", () => ({
+  useVideoModalState: () => ({
+    collapsed: false,
+    offset: { current: 700 },
+    gestureHandlerProps: {},
+    translateY: new (require("react-native").Animated.Value)(0),
+    expand: jest.fn(),
+  }),
+}));
+
+// eslint-disable-next-line import/first
+import { VideoPlayerModal } from "../VideoPlayerModal";
+
+const renderModal = (props = {}) =>
+  render(
+    <VideoPlayerModal
+      modal
+      content={<Text>content</Text>}
+      collapsedContent={<Text>collapsed</Text>}
+      style={{ width: 1024, height: 768, tabletLandscapeWidth: 600 }}
+      {...props}
+    />
+  );
+
+const collapsedBar = () => screen.queryByTestId("collapsedBarWrapper");
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  orientationListener = null;
+  mockIsTabletLandscape = false;
+});
+
+describe("VideoPlayerModal fullscreen layout", () => {
+  describe("on a tablet in landscape", () => {
+    beforeEach(() => {
+      mockIsTabletLandscape = true;
+    });
+
+    it("leaves the orientation listener alone, since landscape is its regular orientation", () => {
+      renderModal();
+
+      expect(mockAddOrientationChangeListener).not.toHaveBeenCalled();
+    });
+
+    it("follows the mode back out of fullscreen", () => {
+      const { rerender } = renderModal({ fullscreen: true });
+
+      expect(collapsedBar()).toBeNull();
+
+      rerender(
+        <VideoPlayerModal
+          modal
+          fullscreen={false}
+          content={<Text>content</Text>}
+          collapsedContent={<Text>collapsed</Text>}
+          style={{ width: 1024, height: 768, tabletLandscapeWidth: 600 }}
+        />
+      );
+
+      expect(collapsedBar()).not.toBeNull();
+    });
+  });
+
+  describe("on a phone", () => {
+    it("still lets orientation drive the layout", () => {
+      renderModal();
+
+      expect(mockAddOrientationChangeListener).toHaveBeenCalled();
+      expect(collapsedBar()).not.toBeNull();
+
+      act(() => orientationListener?.({ toOrientation: 4 }));
+
+      expect(collapsedBar()).toBeNull();
+    });
+  });
+});

package/src/Player/__tests__/getNativeProps.test.ts

@@ -0,0 +1,115 @@
+import VideoPlayer from "../index";
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
+
+/**
+ * Pins where `getNativeProps()`'s `metadata` object comes from: the player
+ * manager's content channel, looked up by `props.playerId`.
+ *
+ * This deliberately does NOT depend on tree position. An earlier version read
+ * the values from `PlayerContainerContext` via `static contextType`, which
+ * made native's props depend on `Player` being rendered inside
+ * `PlayerContainerContextProvider` - safe only as long as an exhaustive
+ * render-site search stayed true. Reading from the manager removes that whole
+ * class of fragility, so the tests below assert the value's source rather than
+ * a render-site invariant.
+ *
+ * Lookup is by id rather than `getActivePlayer()` because these props are
+ * handed to this component's own native view: they must describe that player
+ * even while a cast session is running.
+ *
+ * The instance is constructed directly (bypassing `render()`/mount) so this
+ * exercises the real `getNativeProps()` without paying for a full render of
+ * the ~37KB `VideoPlayer` class tree.
+ */
+
+jest.mock("@applicaster/zapp-react-native-utils/appUtils", () => ({
+  ...jest.requireActual("@applicaster/zapp-react-native-utils/appUtils"),
+  playerManager: {
+    getPlayerWithId: jest.fn(),
+  },
+}));
+
+const entry = {
+  id: "1",
+  title: "Entry Title",
+  summary: "Entry Summary",
+} as unknown as ZappEntry;
+
+const baseProps = {
+  entry,
+  pluginConfiguration: {},
+  docked: false,
+  fullscreen: false,
+  inline: false,
+  isModal: false,
+  isTabletPortrait: false,
+  muted: false,
+  playerId: "player-1",
+  PlayerComponent: "QuickBrickDefaultPlayerView",
+} as unknown as ConstructorParameters<typeof VideoPlayer>[0];
+
+const publishContent = (
+  content: {
+    title: Option<string | number>;
+    summary: Option<string | number>;
+  } | null
+) => {
+  (playerManager.getPlayerWithId as jest.Mock).mockReturnValue(
+    content ? { getContent: () => content } : null
+  );
+};
+
+describe("Player's getNativeProps() reading Title/Subtitle from the manager", () => {
+  it("sends the title/summary the player published", () => {
+    publishContent({
+      title: "Resolved Title",
+      summary: "Resolved Summary",
+    });
+
+    const nativeProps = new VideoPlayer(baseProps).getNativeProps();
+
+    expect(nativeProps.metadata.title).toBe("Resolved Title");
+    expect(nativeProps.metadata.subtitle).toBe("Resolved Summary");
+  });
+
+  it("looks the player up by its own id, not the active player", () => {
+    publishContent({ title: "Resolved Title", summary: "Resolved Summary" });
+
+    new VideoPlayer(baseProps).getNativeProps();
+
+    expect(playerManager.getPlayerWithId).toHaveBeenCalledWith("player-1");
+  });
+
+  it("sends undefined when the player published no text", () => {
+    publishContent({ title: null, summary: null });
+
+    const nativeProps = new VideoPlayer(baseProps).getNativeProps();
+
+    expect(nativeProps.metadata.title).toBeUndefined();
+    expect(nativeProps.metadata.subtitle).toBeUndefined();
+  });
+
+  it("sends undefined rather than crashing when no player is registered", () => {
+    publishContent(null);
+
+    const nativeProps = new VideoPlayer(baseProps).getNativeProps();
+
+    expect(nativeProps.metadata.title).toBeUndefined();
+    expect(nativeProps.metadata.subtitle).toBeUndefined();
+  });
+
+  it("does not fall back to entry.title/entry.summary itself - the resolver owns that fallback", () => {
+    // `entry.title`/`entry.summary` are "Entry Title"/"Entry Summary" (see
+    // `baseProps`); with nothing published, nativeProps must NOT silently pick
+    // those up as a second, redundant fallback layer inside `Player`. The
+    // entry-field fallback lives in `resolvePlayerContentText`, reached
+    // through the player's own `getContent()`.
+    publishContent({ title: null, summary: null });
+
+    const nativeProps = new VideoPlayer(baseProps).getNativeProps();
+
+    expect(nativeProps.metadata.title).not.toBe(entry.title);
+    expect(nativeProps.metadata.subtitle).not.toBe(entry.summary);
+    expect(nativeProps.entry).toBe(entry);
+  });
+});