@applicaster/quick-brick-player 16.0.0-rc.11 → 16.0.0-rc.110

package/src/Player/AudioLayer/playerActions.ts

@@ -0,0 +1,294 @@
+import { map } from "rxjs";
+import {
+  actionExecutor,
+  ActionResult,
+} from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutor";
+import { ActionHandler } from "@applicaster/zapp-react-native-utils/actionsExecutor/types";
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
+import { modalOrchestrator } from "@applicaster/zapp-react-native-utils/modalState/ModalOrchestrator";
+import { toNumber } from "@applicaster/zapp-react-native-utils/numberUtils";
+
+import { speedOptions } from "../Const/speedOptions";
+import { getSleepTimerOptions } from "../Const/sleepTimerOptions";
+import { formatSpeed } from "./utils";
+import { SpeedController } from "./SpeedManager";
+import { SleepTimerController, SleepTimerState } from "./SleepTimerManager";
+
+export const PLAYER_ACTION_IDENTIFIERS = {
+  PLAYBACK_SPEED: "playback-speed",
+  SLEEP_TIMER: "sleep-timer",
+} as const;
+
+export const PLAYER_ACTION_TYPES = {
+  OPEN_PLAYBACK_SPEED: "openPlaybackSpeed",
+  OPEN_SLEEP_TIMER: "openSleepTimer",
+  SET_PLAYBACK_SPEED: "setPlaybackSpeed",
+  SET_SLEEP_TIMER: "setSleepTimer",
+} as const;
+
+function getPlayerConfig(): Record<string, any> {
+  return playerManager.getActivePlayer()?.getConfig?.() || {};
+}
+
+function remainingTimerDate(timerDate: number): number | null {
+  return timerDate !== 0 && +timerDate > Date.now() ? timerDate : null;
+}
+
+function dismissOpenedSheet(action: ActionType) {
+  if (action.options?.dismissSheet) {
+    modalOrchestrator.close();
+  }
+}
+
+function optionToEntry(
+  id: string,
+  title: string,
+  actionType: string,
+  options: Record<string, any>
+): ZappEntry {
+  return {
+    id,
+    title,
+    extensions: {
+      tap_actions: {
+        actions: [
+          { type: actionType, options: { ...options, dismissSheet: true } },
+        ],
+      },
+    },
+  } as ZappEntry;
+}
+
+function sleepTimerEntryState(
+  sleepState: SleepTimerState
+): CellActionEntryState {
+  const config = getPlayerConfig();
+  const isActive = Boolean(remainingTimerDate(sleepState.timerDate));
+
+  return {
+    state: isActive ? 1 : 0,
+    label: config.playback_sleep_title || "Sleep Timer",
+    asset: isActive
+      ? config.sleep_timer_active || config.sleep_timer || ""
+      : config.sleep_timer || "",
+  };
+}
+
+function playbackSpeedEntryState(speed: {
+  asset?: string;
+  value?: number;
+}): CellActionEntryState {
+  const config = getPlayerConfig();
+  const assetKey = speed?.asset || formatSpeed(speed?.value ?? 1);
+
+  return {
+    state: 0,
+    label: config.playback_speed_title || "Playback Speed",
+    // Manifest keys are speed_0_8 / speed_1 / … (same icons as the transport row).
+    // There is no playback_speed uploader.
+    asset: config[assetKey] || config.speed_1 || "",
+  };
+}
+
+export async function openPlaybackSpeedAction(
+  speedController: SpeedController
+): Promise<ActionResult> {
+  const config = getPlayerConfig();
+  const current = speedController.currentSpeed;
+
+  const items = speedOptions.map((option) =>
+    optionToEntry(
+      String(option.value),
+      option.label,
+      PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      { value: option.value }
+    )
+  );
+
+  return actionExecutor.handleAction({
+    type: "openBottomSheet",
+    options: {
+      replace: true,
+      header: {
+        title: config.playback_speed_title || "Playback Speed",
+      },
+      content: {
+        role: "collection_selector",
+        behavior: {
+          selectMode: "single",
+          currentSelection: [String(current.value)],
+        },
+        items,
+      },
+    },
+  } as ActionType);
+}
+
+export async function openSleepTimerAction(
+  sleepController: SleepTimerController
+): Promise<ActionResult> {
+  const config = getPlayerConfig();
+  const sleepState = sleepController.currentState;
+  const timerRemaining = remainingTimerDate(sleepState.timerDate);
+
+  const items = getSleepTimerOptions(
+    config.playback_sleep_off_label || "Off",
+    timerRemaining
+  )
+    .filter(Boolean)
+    .map((option) =>
+      optionToEntry(
+        String(option.value),
+        option.label,
+        PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+        { value: option.value, label: option.label }
+      )
+    );
+
+  return actionExecutor.handleAction({
+    type: "openBottomSheet",
+    options: {
+      replace: true,
+      header: {
+        title: config.playback_sleep_title || "Sleep Timer",
+      },
+      content: {
+        role: "collection_selector",
+        behavior: {
+          selectMode: "single",
+          currentSelection: timerRemaining
+            ? [String(sleepState.timer.value)]
+            : [],
+        },
+        items,
+      },
+    },
+  } as ActionType);
+}
+
+export async function setPlaybackSpeedAction(
+  speedController: SpeedController,
+  action: ActionType
+): Promise<ActionResult> {
+  const value = toNumber(action.options?.value);
+
+  if (!Number.isFinite(value)) {
+    return ActionResult.Error;
+  }
+
+  await speedController.setPlaybackSpeed({
+    asset: formatSpeed(value),
+    value,
+  });
+
+  dismissOpenedSheet(action);
+
+  return ActionResult.Success;
+}
+
+export async function setSleepTimerAction(
+  sleepController: SleepTimerController,
+  action: ActionType
+): Promise<ActionResult> {
+  const value = toNumber(action.options?.value);
+
+  if (!Number.isFinite(value)) {
+    return ActionResult.Error;
+  }
+
+  await sleepController.setSleepTimer({
+    label: action.options?.label || String(value),
+    value,
+  });
+
+  dismissOpenedSheet(action);
+
+  return ActionResult.Success;
+}
+
+export function registerPlayerActions(options: {
+  speedController?: SpeedController;
+  sleepController?: SleepTimerController;
+}): () => void {
+  const unregisters: Array<() => void> = [];
+
+  if (options.speedController) {
+    const speedController = options.speedController;
+
+    const speedHandlers: Array<[string, ActionHandler]> = [
+      [
+        PLAYER_ACTION_TYPES.OPEN_PLAYBACK_SPEED,
+        () => openPlaybackSpeedAction(speedController),
+      ],
+      [
+        PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+        (action) => setPlaybackSpeedAction(speedController, action),
+      ],
+    ];
+
+    speedHandlers.forEach(([type, handler]) => {
+      actionExecutor.unregisterAction(type);
+      unregisters.push(actionExecutor.registerAction(type, handler));
+    });
+
+    unregisters.push(
+      uiActionsRegistry.registerAction(
+        PLAYER_ACTION_IDENTIFIERS.PLAYBACK_SPEED,
+        {
+          initialEntryState: () =>
+            playbackSpeedEntryState(speedController.currentSpeed),
+          observeEntryState: () =>
+            speedController.playbackSpeed$.pipe(
+              map((speed) => playbackSpeedEntryState(speed))
+            ),
+          invokeAction: async () => {
+            await actionExecutor.handleAction({
+              type: PLAYER_ACTION_TYPES.OPEN_PLAYBACK_SPEED,
+            });
+          },
+        }
+      )
+    );
+  }
+
+  if (options.sleepController) {
+    const sleepController = options.sleepController;
+
+    const sleepHandlers: Array<[string, ActionHandler]> = [
+      [
+        PLAYER_ACTION_TYPES.OPEN_SLEEP_TIMER,
+        () => openSleepTimerAction(sleepController),
+      ],
+      [
+        PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+        (action) => setSleepTimerAction(sleepController, action),
+      ],
+    ];
+
+    sleepHandlers.forEach(([type, handler]) => {
+      actionExecutor.unregisterAction(type);
+      unregisters.push(actionExecutor.registerAction(type, handler));
+    });
+
+    unregisters.push(
+      uiActionsRegistry.registerAction(PLAYER_ACTION_IDENTIFIERS.SLEEP_TIMER, {
+        initialEntryState: () =>
+          sleepTimerEntryState(sleepController.currentState),
+        observeEntryState: () =>
+          sleepController.sleepTimerState$.pipe(
+            map((sleepState) => sleepTimerEntryState(sleepState))
+          ),
+        invokeAction: async () => {
+          await actionExecutor.handleAction({
+            type: PLAYER_ACTION_TYPES.OPEN_SLEEP_TIMER,
+          });
+        },
+      })
+    );
+  }
+
+  return () => {
+    unregisters.forEach((unregister) => unregister());
+  };
+}

package/src/Player/AudioLayer/usePlaylistNavigation.ts

@@ -0,0 +1,148 @@
+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 { PlayerNativeCommandTypes } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/playerNativeCommand";
+import { RemoteCommand } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/const";
+import { PlaylistNavigationController } from "./PlaylistNavigationController";
+
+const REMOTE_COMMANDS_LISTENER_ID = "playlist-navigation-remote-commands";
+
+/**
+ * Buttons native should expose on the lock screen / Control Center / CarPlay.
+ * Native enables exactly these and disables the rest. A track button takes its
+ * slot over the skip one, since the system shows only one of them per side.
+ * Without a next item next is left out, so the system shows it disabled.
+ */
+export const getTransportControls = ({
+  hasNext,
+  hasPrevious,
+  isLive,
+}: {
+  hasNext: boolean;
+  hasPrevious: boolean;
+  isLive: boolean;
+}): RemoteCommand[] => {
+  const commands = [
+    RemoteCommand.Play,
+    isLive ? RemoteCommand.Stop : RemoteCommand.Pause,
+  ];
+
+  if (hasPrevious) {
+    commands.push(RemoteCommand.PreviousTrack);
+  } else if (!isLive) {
+    commands.push(RemoteCommand.SkipBackward);
+  }
+
+  if (hasNext) {
+    commands.push(RemoteCommand.NextTrack);
+  }
+
+  return commands;
+};
+
+export type PlaylistNavigation = {
+  hasNext: boolean;
+  hasPrevious: boolean;
+  goNext: () => Promise<void>;
+  goPrevious: () => Promise<void>;
+};
+
+/**
+ * Thin UI binding hook that subscribes to PlaylistNavigationController's
+ * RxJS streams and exposes hasNext, hasPrevious, goNext, and goPrevious.
+ */
+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 [controller] = React.useState(
+    () =>
+      new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState,
+      })
+  );
+
+  const [hasNext, setHasNext] = React.useState(() =>
+    controller.hasNext$.getValue()
+  );
+
+  const [hasPrevious, setHasPrevious] = React.useState(() =>
+    controller.hasPrevious$.getValue()
+  );
+
+  React.useEffect(() => {
+    controller.updateContext({ player, navigator, entry, playerState });
+  }, [controller, player, navigator, entry, playerState]);
+
+  React.useEffect(() => {
+    const subNext = controller.hasNext$.subscribe(setHasNext);
+    const subPrev = controller.hasPrevious$.subscribe(setHasPrevious);
+
+    return () => {
+      subNext.unsubscribe();
+      subPrev.unsubscribe();
+      controller.destroy();
+    };
+  }, [controller]);
+
+  // Lock screen / Control Center / CarPlay next & previous go through the same
+  // controller as the on-screen buttons, so JS stays the single source of truth.
+  React.useEffect(
+    () =>
+      player?.addListener?.({
+        id: REMOTE_COMMANDS_LISTENER_ID,
+        listener: {
+          onRemoteCommand: ({ id }) => {
+            if (id === RemoteCommand.NextTrack) {
+              controller.goNext();
+            } else if (id === RemoteCommand.PreviousTrack) {
+              controller.goPrevious();
+            }
+          },
+        },
+      }),
+    [player, controller]
+  );
+
+  const isLive = Boolean(playerState?.isLive);
+
+  // Full snapshot: native renders exactly this and drops the rest. Each key is
+  // one kind of buttons, so they stay separate lists rather than one flat list.
+  React.useEffect(() => {
+    const controls = {
+      transport: getTransportControls({ hasNext, hasPrevious, isLive }),
+      // TODO: other button kinds go in as their own keys next to `transport`,
+      // e.g. custom / native-drawn buttons ("play next", CarPlay / Android Auto
+      // row buttons). Add a composer on Player once more than this hook fills it.
+      // actions: [],
+    };
+
+    player?.command?.(PlayerNativeCommandTypes.setPlayerControls, controls);
+  }, [player, hasNext, hasPrevious, isLive]);
+
+  const goNext = React.useCallback(
+    async () => controller.goNext(),
+    [controller]
+  );
+
+  const goPrevious = React.useCallback(
+    async () => controller.goPrevious(),
+    [controller]
+  );
+
+  return {
+    hasNext,
+    hasPrevious,
+    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;