@applicaster/quick-brick-player 13.0.0-rc.99 → 14.0.0-rc.2

package/src/Player/AudioLayer/components/SleepTimerModalHeader/SleepTimerModalHeader.tsx

@@ -0,0 +1,66 @@
+import React from "react";
+import { ModalHeader } from "@applicaster/zapp-react-native-ui-components/Components/ModalComponent/Header";
+import { isNil } from "lodash";
+
+const formatTime = (milliseconds: number) => {
+  const totalSeconds = Math.floor(milliseconds / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  if (milliseconds < 3600000) {
+    return `${minutes.toString().padStart(2, "0")}:${seconds
+      .toString()
+      .padStart(2, "0")}`;
+  }
+
+  return `${hours.toString().padStart(2, "0")}:${minutes
+    .toString()
+    .padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+};
+
+export const SleepTimerModalHeader = ({
+  summary,
+  ...props
+}: {
+  summary?: string;
+}) => {
+  const sleepTimerDate = +summary;
+
+  const [timeLeft, setTimeLeft] = React.useState(
+    sleepTimerDate !== 0 ? sleepTimerDate - Date.now() : 0
+  );
+
+  const showCounter = React.useMemo(() => sleepTimerDate > 0, [sleepTimerDate]);
+
+  React.useLayoutEffect(() => {
+    if (showCounter && sleepTimerDate !== 0) {
+      setTimeLeft(sleepTimerDate - Date.now());
+
+      const intervalId = setInterval(() => {
+        setTimeLeft(() => {
+          const newTimeLeft = sleepTimerDate - Date.now();
+
+          if (newTimeLeft <= 0) {
+            clearInterval(intervalId);
+
+            return 0;
+          } else {
+            return newTimeLeft;
+          }
+        });
+      }, 1000);
+
+      return () => clearInterval(intervalId);
+    } else {
+      setTimeLeft(0);
+    }
+  }, [sleepTimerDate, showCounter]);
+
+  return (
+    <ModalHeader
+      summary={!isNil(summary) ? formatTime(timeLeft) : summary}
+      {...(props as any)}
+    />
+  );
+};

package/src/Player/AudioLayer/components/SleepTimerModalHeader/index.ts

@@ -0,0 +1 @@
+export * from "./SleepTimerModalHeader";

package/src/Player/AudioLayer/useSleepTimerModal.ts

@@ -0,0 +1,109 @@
+import { usePlayerState } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayerState";
+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";
+
+export const useSleepTimerModal = (player, configuration) => {
+  const playerState = usePlayerState("audio-player-sleep-timer-modal");
+
+  const title = configuration(selectSleepTitle);
+  const offLabel = configuration(selectSleepOffLabel);
+
+  const [sleepTimerManager, setSleepTimerManager] =
+    useState<SleepTimerController | null>(null);
+
+  const [sleepTimerState, setSleepTimerState] = useState<SleepTimerState>(
+    new SleepTimerState(SLEEP_TIMER_OFF, 0)
+  );
+
+  useEffect(() => {
+    if (player) {
+      setSleepTimerManager(new SleepTimerController(player));
+    } else {
+      setSleepTimerManager(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();
+    }
+  }, [playerState?.isLive]);
+
+  useEffect(() => {
+    if (!playerState.isReadyToPlay) {
+      return;
+    }
+
+    void sleepTimerManager?.loadSleep();
+  }, [playerState.isReadyToPlay, sleepTimerManager]);
+
+  useEffect(() => {
+    const sleepSubscription =
+      sleepTimerManager?.sleepTimerState$.subscribe(setSleepTimerState);
+
+    return () => {
+      sleepSubscription?.unsubscribe();
+    };
+  }, [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]);
+
+  return useMemo(
+    () => ({
+      onSleepButtonPress,
+      sleepTimerState,
+    }),
+    [onSleepButtonPress, sleepTimerState]
+  );
+};

package/src/Player/Const/sleepTimerOptions.ts

@@ -28,12 +28,14 @@ const createTimerOptions = (value) => {
   };
 };
 
-export const getSleepTimerOptions = (configuration) => {
+export const getSleepTimerOptions = (offLabel, sleepTimerValue) => {
   return [
-    {
-      label: configuration["playback_sleep_off_label"],
-      value: 0,
-    },
+    sleepTimerValue
+      ? {
+          label: offLabel,
+          value: 0,
+        }
+      : null,
     ...[5, 10, 15, 30, 45, 60, 120].map(createTimerOptions),
   ];
 };

package/src/Player/Utils/index.tsx

@@ -116,3 +116,9 @@ export const getBottomSheetModalSelectedItemIcon = (theme) =>
 
 export const getBottomSheetModalDefaultItemIcon = (theme) =>
   theme["audio_modal_bottom_sheet_item_default_icon"] || null;
+
+export const selectSleepTitle = (configuration) =>
+  configuration.playback_sleep_title;
+
+export const selectSleepOffLabel = (configuration) =>
+  configuration.playback_sleep_off_label;

package/src/Player/hooks/useIsCasting.tsx

@@ -0,0 +1,57 @@
+import React from "react";
+import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
+import { useAppState } from "@applicaster/zapp-react-native-utils/reactHooks/app";
+import { isApplePlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
+
+const CHROMECAST_IDENTIFIER = "quick-brick-chromecast-action";
+
+const fakeEntry: any = {
+  title: "Chromecast use is casting fake entry",
+  id: "quick-brick-use-is-casting-fake-entry",
+};
+
+/**
+ * Returns the cast action state connection status, does not update when app is in background on Apple platforms
+ * On other platforms, it continues to check the cast action state even when the app is in background
+ */
+export const useIsCasting = () => {
+  const actionContext = useActions(CHROMECAST_IDENTIFIER);
+  const appState = useAppState();
+  const isAppInForeground = appState === "active";
+  const shouldOnlyUpdateInForeground = isApplePlatform();
+
+  const [castActionState, setCastActionState] = React.useState(
+    !actionContext ? null : actionContext.initialEntryState(fakeEntry)
+  );
+
+  React.useEffect(() => {
+    if (!shouldOnlyUpdateInForeground || isAppInForeground) {
+      if (actionContext && castActionState === null) {
+        setCastActionState(actionContext.initialEntryState(fakeEntry));
+      }
+    }
+  }, [
+    actionContext,
+    setCastActionState,
+    isAppInForeground,
+    shouldOnlyUpdateInForeground,
+  ]);
+
+  React.useEffect(() => {
+    if (typeof actionContext?.addListener === "function") {
+      return actionContext?.addListener(String(fakeEntry.id), (state) => {
+        // Only check foreground state on Apple platforms
+        if (!shouldOnlyUpdateInForeground || isAppInForeground) {
+          setCastActionState(state);
+        }
+      });
+    }
+  }, [
+    setCastActionState,
+    actionContext,
+    isAppInForeground,
+    shouldOnlyUpdateInForeground,
+  ]);
+
+  return !!castActionState?.connected;
+};

package/src/Player/index.tsx

@@ -4,6 +4,8 @@
 import React from "react";
 import * as R from "ramda";
 
+import { flatten } from "@applicaster/zapp-react-native-utils/utils";
+
 import { findNodeHandle, StyleSheet, View } from "react-native";
 import TransportControlsMobile from "@applicaster/quick-brick-mobile-transport-controls";
 import TransportControlsTV from "@applicaster/quick-brick-tv-transport-controls";
@@ -40,6 +42,7 @@ import { PlayerAnalyticsManager } from "@applicaster/zapp-react-native-utils/ana
 import { PlayerAnalyticsTrackerI } from "@applicaster/zapp-react-native-utils/analyticsUtils/playerAnalyticsTracker";
 
 import { RNPlayerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/nativePlayerManager";
+import { isAudioItem as isAudioItemUtil } from "@applicaster/zapp-react-native-utils/playerUtils";
 
 const styles = StyleSheet.create({
   container: { flex: 1 },
@@ -50,6 +53,7 @@ const styles = StyleSheet.create({
     position: "absolute",
     zIndex: 1,
   },
+  audioPlayerSize: { width: "100%", height: "100%" },
   playerSize: { width: "100%", height: "100%" },
 });
 
@@ -58,6 +62,10 @@ const logger = createLogger({
   subsystem: Subsystem,
 });
 
+const isTvOS = isTvOSPlatform();
+
+const AUDIO_PLAYER_NATIVE_ID = "audio-player-view";
+
 export default class VideoPlayer extends React.Component<
   QuickBrickPlayer.PlayerProps,
   QuickBrickPlayer.NativePlayerState
@@ -74,6 +82,7 @@ export default class VideoPlayer extends React.Component<
   state: QuickBrickPlayer.NativePlayerState = {
     audioTrackId: null,
     textTrackId: null,
+    isCasting: this.props.isCasting,
 
     // TODO: Can be deleted, on controller logic
     isAd: false,
@@ -92,6 +101,8 @@ export default class VideoPlayer extends React.Component<
     // Player state
     currentTime: 0,
     duration: 0,
+
+    nativePlayerIsReady: false,
   };
 
   private _tracker: PlayerAnalyticsTrackerI;
@@ -487,6 +498,9 @@ export default class VideoPlayer extends React.Component<
 
   onVideoFullscreenPlayerDidPresent = () => {
     this.props.listener?.onVideoFullscreenPlayerDidPresent?.();
+
+    // we have to have a signal that player is ready, in order to show audio_player(for example)
+    this.setState({ nativePlayerIsReady: true });
   };
 
   onVideoFullscreenPlayerWillDismiss = () => {
@@ -672,32 +686,57 @@ export default class VideoPlayer extends React.Component<
     }
   };
 
-  childrenWithPlayNext = () => {
-    if (!isTvOSPlatform() || !this.getPlayNextData()) {
-      return this.props.children;
+  childrenWithExtensions = () => {
+    const { docked, entry, children } = this.props;
+
+    if (!isTvOS) {
+      return children;
     }
 
-    // tvos only
-    const { docked, entry } = this.props;
-
-    const children = R.pathOr([], "children", this.props);
-
-    return [
-      ...children,
-      <PlayNextOverlay
-        key="play-next-overlay"
-        item={entry}
-        playerIsDocked={docked}
-        pluginConfiguration={this.getPluginConfiguration()}
-        playerId={this.props.playerId}
-        playNextData={this.getPlayNextData()}
-        setNextVideoPreloadThresholdPercentage={
-          this.props.setNextVideoPreloadThresholdPercentage
-        }
-      />,
-    ];
+    const output = [];
+
+    // audio-player
+    if (isAudioItemUtil(entry)) {
+      const { nativePlayerIsReady } = this.state;
+
+      // we have to wait ready status of native player view, before showing audio_player
+      if (nativePlayerIsReady) {
+        output.push(
+          <View nativeID={AUDIO_PLAYER_NATIVE_ID} key={AUDIO_PLAYER_NATIVE_ID}>
+            {children}
+          </View>
+        );
+      }
+    } else {
+      output.push(children);
+    }
+    // audio-player
+
+    // play-next
+    if (this.getPlayNextData()) {
+      output.push(
+        <PlayNextOverlay
+          key="play-next-overlay"
+          item={entry}
+          playerIsDocked={docked}
+          pluginConfiguration={this.getPluginConfiguration()}
+          playerId={this.props.playerId}
+          playNextData={this.getPlayNextData()}
+          setNextVideoPreloadThresholdPercentage={
+            this.props.setNextVideoPreloadThresholdPercentage
+          }
+        />
+      );
+    }
+    // play-next
+
+    return flatten(output); // prevent possible case with nested array
   };
 
+  get supportNativeCast() {
+    return this.props.controller.supportNativeCast();
+  }
+
   render() {
     const {
       docked,
@@ -710,18 +749,13 @@ export default class VideoPlayer extends React.Component<
       muted,
       style,
       castAction,
-      controller,
       startComponentsAnimation,
     } = this.props;
 
-    const supportNativeCast = controller.supportNativeCast();
-
     const { audioTrackId, keyEvent, paused, seek, textTrackId, rate } =
       this.state;
 
-    const isAudioItem =
-      entry?.content?.type?.includes?.("audio") ||
-      entry?.type?.value?.includes?.("audio");
+    const isAudioItem = isAudioItemUtil(entry);
 
     const getStyle = (dimensions) => {
       const generalStyles = isAudioItem ? styles.audio : styles.video;
@@ -995,11 +1029,14 @@ export default class VideoPlayer extends React.Component<
     const backgroundImageKey =
       this.getPluginConfiguration()?.player_preview_image_key;
 
+    const shouldRenderNativePlayer =
+      !this.props.isCasting || this.supportNativeCast;
+
     const renderMobilePlayer = () => {
       return isFullScreenAudioPlayer && isAudioItem ? (
         // Ensure the View remains in the native hierarchy for proper rendering and interaction
         <View collapsable={false} style={containerStyle}>
-          {!castAction?.state?.connected || supportNativeCast ? (
+          {shouldRenderNativePlayer ? (
             <this.props.PlayerComponent
               ref={this._assignRoot}
               {...nativeEvents}
@@ -1051,7 +1088,7 @@ export default class VideoPlayer extends React.Component<
                     />
                   ) : null}
 
-                  {!castAction?.state?.connected || supportNativeCast ? (
+                  {shouldRenderNativePlayer ? (
                     <AnimationComponent
                       animationType={ComponentAnimationType.player}
                       additionalData={{
@@ -1073,7 +1110,7 @@ export default class VideoPlayer extends React.Component<
                         pluginConfiguration={this.getPluginConfiguration()}
                         controller={this.props.controller}
                       >
-                        {this.childrenWithPlayNext()}
+                        {this.props.children}
                       </this.props.PlayerComponent>
                     </AnimationComponent>
                   ) : null}
@@ -1102,6 +1139,14 @@ export default class VideoPlayer extends React.Component<
     const renderTVPlayer = () => {
       return (
         <View style={this.takeParentStyle} testID={"player-view"}>
+          {!isTvOS && isAudioItem ? (
+            <AudioPlayer
+              style={getStyle(styles.audioPlayerSize)}
+              audio_item={entry}
+              plugin_configuration={this.getPluginConfiguration()}
+            />
+          ) : null}
+
           <this.props.PlayerComponent
             ref={this._assignRoot}
             {...nativeEvents}
@@ -1111,11 +1156,11 @@ export default class VideoPlayer extends React.Component<
             pluginConfiguration={this.getPluginConfiguration()}
             controller={this.props.controller}
           >
-            {this.childrenWithPlayNext()}
+            {this.childrenWithExtensions()}
           </this.props.PlayerComponent>
 
           {renderTransportControls(this.takeParentStyle)}
-          {!isTvOSPlatform() && (
+          {!isTvOS && (
             <PlayNextOverlay
               item={entry}
               playerIsDocked={docked}

package/src/QuickBrickPlayer.tsx

@@ -5,6 +5,7 @@ import Player from "./Player";
 import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
 import { isWeb } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useIsCasting } from "./Player/hooks/useIsCasting";
 
 const CHROMECAST_IDENTIFIER = "quick-brick-chromecast-action";
 
@@ -24,6 +25,7 @@ const QuickBrickPlayerComponent = (
   }, [props.PlayerComponent]);
 
   const castAction = useActions(CHROMECAST_IDENTIFIER);
+  const isCasting = useIsCasting();
 
   const isModal = Boolean(props?.isModal);
   const isScreenDisabled = !controller?.isFullScreenSupported() || !isModal;
@@ -48,6 +50,7 @@ const QuickBrickPlayerComponent = (
       {...props}
       ref={ref}
       castAction={!props?.disableCastAction && castAction}
+      isCasting={isCasting}
       PlayerComponent={props.PlayerComponent}
       openPiP={openPiP}
       closePiP={closePiP}

package/src/Player/AudioLayer/LinearGradient/LinearGradientProxy.ts

@@ -1,3 +0,0 @@
-import LinearGradient from "react-native-linear-gradient";
-
-export default LinearGradient;

package/src/Player/AudioLayer/LinearGradient/LinearGradientProxy.web.ts

@@ -1,3 +0,0 @@
-const WebLinearGradient = require("react-native-web-linear-gradient").default;
-
-export default WebLinearGradient;

package/src/Player/AudioLayer/LinearGradient/index.ts

@@ -1 +0,0 @@
-export { default } from "./LinearGradientProxy";

package/src/Player/AudioLayer/MagicBG/index.tsx

@@ -1,155 +0,0 @@
-/* eslint-disable react/prop-types */
-import * as React from "react";
-import { Animated, StyleSheet, View } from "react-native";
-import LinearGradient from "../LinearGradient";
-import { getDominantColor, getPalettes } from "../../../utils/utils";
-import { useEffect } from "react";
-
-type MagicBGProps = {
-  children: React.ReactNode;
-  image: string;
-  fallbackUrl?: string;
-  defaultColor: string;
-  colors: string[];
-};
-
-const defaultColors = {
-  overlay: "rgba(0, 0, 0, 0.35)",
-  defaultGradientStart: "rgba(0, 0, 0, 0.25)",
-  defaultGradientEnd: "rgba(0, 0, 0, 0)",
-};
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-  },
-  fullScreenOverlay: {
-    ...StyleSheet.absoluteFillObject,
-    backgroundColor: defaultColors.overlay,
-  },
-  gradientOverlay: {
-    position: "absolute",
-    bottom: 0,
-    left: 0,
-    right: 0,
-    height: "100%",
-  },
-});
-
-const fetchPaletteAndDominantColor = async (imageUrl: string) => {
-  const palette = await getPalettes(imageUrl);
-
-  const colors = palette.map(
-    (color: { r: number; g: number; b: number }) =>
-      `rgb(${color.r}, ${color.g}, ${color.b})`
-  );
-
-  const dominant = await getDominantColor(imageUrl);
-  const dominantColor = `rgb(${dominant.r}, ${dominant.g}, ${dominant.b})`;
-
-  return { gradientColors: colors.slice(0, 2).reverse(), dominantColor };
-};
-
-export const MagicBG: React.FC<MagicBGProps> = ({
-  children,
-  image,
-  fallbackUrl = "",
-  colors = [],
-  defaultColor,
-}) => {
-  const [dominantColor, setDominantColor] =
-    React.useState<string>(defaultColor);
-
-  const [gradientColors, setGradientColors] = React.useState<string[]>([
-    defaultColors.defaultGradientStart,
-    defaultColors.defaultGradientEnd,
-  ]);
-
-  const [backgroundColorAnim] = React.useState(new Animated.Value(0)); // from 0 to 1
-  const [gradientOpacityAnim] = React.useState(new Animated.Value(0)); // from 0 to 1
-
-  useEffect(() => {
-    const animateColors = () => {
-      Animated.timing(backgroundColorAnim, {
-        toValue: 1,
-        duration: 500,
-        useNativeDriver: false,
-      }).start();
-
-      Animated.timing(gradientOpacityAnim, {
-        toValue: 1,
-        duration: 500,
-        useNativeDriver: false,
-      }).start();
-    };
-
-    const fetchColors = async () => {
-      if (colors && colors.length > 0) {
-        setGradientColors(colors.slice(0, 2));
-        setDominantColor(colors[0]);
-        animateColors();
-      } else if (image) {
-        try {
-          const { gradientColors, dominantColor } =
-            await fetchPaletteAndDominantColor(image);
-
-          setGradientColors(gradientColors);
-          setDominantColor(dominantColor);
-          animateColors();
-        } catch (error) {
-          try {
-            const { gradientColors, dominantColor } =
-              await fetchPaletteAndDominantColor(fallbackUrl);
-
-            setGradientColors(gradientColors);
-            setDominantColor(dominantColor);
-            animateColors();
-          } catch {
-            setGradientColors([
-              defaultColors.defaultGradientStart,
-              defaultColors.defaultGradientEnd,
-            ]);
-
-            setDominantColor(defaultColor);
-          }
-        }
-      } else {
-        setGradientColors([
-          defaultColors.defaultGradientStart,
-          defaultColors.defaultGradientEnd,
-        ]);
-
-        setDominantColor(defaultColor);
-      }
-    };
-
-    fetchColors();
-  }, []);
-
-  const interpolatedBackgroundColor = backgroundColorAnim.interpolate({
-    inputRange: [0, 1],
-    outputRange: ["black", dominantColor],
-  });
-
-  return (
-    <Animated.View
-      style={[
-        styles.container,
-        { backgroundColor: interpolatedBackgroundColor },
-      ]}
-    >
-      <View style={styles.fullScreenOverlay} />
-
-      <Animated.View
-        style={[styles.gradientOverlay, { opacity: gradientOpacityAnim }]}
-      >
-        <LinearGradient
-          colors={gradientColors}
-          style={StyleSheet.absoluteFill}
-        />
-      </Animated.View>
-
-      {children}
-    </Animated.View>
-  );
-};