@applicaster/zapp-react-native-ui-components 15.0.0-alpha.3514407021 → 15.0.0-alpha.4153840309

package/Components/VideoModal/ModalAnimation/ModalAnimationContext.tsx

@@ -1,212 +1,155 @@
-import React, { useEffect, useMemo } from "react";
+import React, { useMemo } from "react";
 import { Animated, Dimensions } from "react-native";
 
-import {
-  useSafeAreaInsets,
-  useSafeAreaFrame,
-} from "react-native-safe-area-context";
-import { useGetBottomTabBarHeight } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useGetBottomTabBarHeight";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
-import { isLive } from "@applicaster/zapp-react-native-utils/playerUtils";
 
-import { PROGRESS_BAR_HEIGHT } from "./utils";
 import { useConfiguration } from "../utils";
-import { useIsTabletLandscape } from "@applicaster/zapp-react-native-utils/reactHooks/device/useMemoizedIsTablet";
-
-export enum PlayerAnimationStateEnum {
-  minimize = "minimize",
-  maximize = "maximize",
-  drag_player = "drag_player",
-  drag_scroll = "drag_scroll",
-  appear_as_docked = "appear_as_docked",
-}
+import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
+import { isMenuVisible } from "../../Screen/navigationHandler";
 
-export type PlayerAnimationStateT = number | PlayerAnimationStateEnum | null;
+import {
+  useSafeAreaFrame,
+  useSafeAreaInsets,
+} from "react-native-safe-area-context";
+import {
+  isAndroidPlatform,
+  isAndroidVersionAtLeast,
+} from "@applicaster/zapp-react-native-utils/reactUtils";
+import { getTabBarHeight } from "@applicaster/zapp-react-native-utils/reactHooks/navigation/getTabBarHeight";
+import { PROGRESS_BAR_HEIGHT } from "./utils";
+import { useIsTablet as getIsTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { useAppSelector } from "@applicaster/zapp-react-native-redux";
 
 export type ModalAnimationContextT = {
-  yTranslate: React.MutableRefObject<Animated.Value | null>;
-  isActiveGesture: boolean;
-  playerAnimationState: PlayerAnimationStateT;
-  setPlayerAnimationState: (value: PlayerAnimationStateT) => void;
-  startComponentsAnimation: boolean;
-  setStartComponentsAnimation: (value: boolean) => void;
-  resetPlayerAnimationState: () => void;
+  yTranslate: React.MutableRefObject<Animated.AnimatedInterpolation<number>>;
+  offsetAnimatedValueRef: React.MutableRefObject<Animated.Value>;
+  offset: React.MutableRefObject<number>;
+  heightAboveMinimised: number;
+  gestureTranslationRef: React.MutableRefObject<Animated.Value>;
   minimisedHeight: number;
-  animatedValues: {
-    lastScrollY: Animated.Value;
-    dragScrollY: Animated.Value;
-    dragVideoPlayerY: Animated.Value;
-    translateYOffset: Animated.Value;
-  };
-  lastScrollYValue: React.MutableRefObject<number>;
-  scrollPosition: React.MutableRefObject<number>;
-  modalSnapPoints: number[];
-  lastSnap: number;
-  setLastSnap: (value: number) => void;
-  tabletLandscapePlayerTopPosition: number;
-  setTabletLandscapePlayerTopPosition: (value: number) => void;
-  startComponentsAnimationDistance: number;
-  progressBarHeight: number;
 };
 
 export const ReactContext = React.createContext<ModalAnimationContextT>({
   yTranslate: React.createRef<Animated.Value | null>(),
-  isActiveGesture: false,
-  playerAnimationState: null,
-  setPlayerAnimationState: () => null,
-  startComponentsAnimation: false,
-  setStartComponentsAnimation: () => null,
-  resetPlayerAnimationState: () => null,
+  offsetAnimatedValueRef: React.createRef<Animated.Value>(),
+  offset: React.createRef<number>(),
+  heightAboveMinimised: 0,
+  gestureTranslationRef: React.createRef<Animated.Value>(),
   minimisedHeight: 60,
-  animatedValues: {
-    lastScrollY: new Animated.Value(0),
-    dragScrollY: new Animated.Value(0),
-    dragVideoPlayerY: new Animated.Value(0),
-    translateYOffset: new Animated.Value(0),
-  },
-  lastScrollYValue: null,
-  scrollPosition: null,
-  modalSnapPoints: [0, 0],
-  lastSnap: 0,
-  setLastSnap: () => null,
-  tabletLandscapePlayerTopPosition: 0,
-  setTabletLandscapePlayerTopPosition: () => null,
-  startComponentsAnimationDistance: 0,
-  progressBarHeight: 0,
 });
 
+const SAFE_AREA_BREAKING_API_VERSION = 35;
+
+export const isOldAndroidDevice =
+  isAndroidPlatform() &&
+  !isAndroidVersionAtLeast(SAFE_AREA_BREAKING_API_VERSION);
+
+const bottomTabBarHeight = getTabBarHeight();
+
 const Provider = ({ children }: { children: React.ReactNode }) => {
+  const { height } = Dimensions.get("window");
+
   const yTranslate = React.useRef(
-    new Animated.Value(Dimensions.get("window").height)
+    new Animated.Value(height).interpolate<number>({
+      inputRange: [0, height],
+      outputRange: [0, height],
+    })
   );
 
-  const [playerAnimationState, setPlayerAnimationState] =
-    React.useState<PlayerAnimationStateT>(null);
-
-  const [
-    tabletLandscapePlayerTopPosition,
-    setTabletLandscapePlayerTopPosition,
-  ] = React.useState<number>(0);
-
-  const [startComponentsAnimation, setStartComponentsAnimation] =
-    React.useState<boolean>(false);
+  const { minimised_height: minimisedHeight } = useConfiguration();
 
   const {
-    videoModalState: { mode, visible, item },
+    videoModalState: { visible, mode },
+    currentRoute,
+    screenData,
   } = useNavigation();
 
-  const isLiveItem = isLive(item);
-  const { minimised_height: minimisedHeight } = useConfiguration();
+  const isTabletPortrait = useAppSelector(
+    (state) => state.appData.isTabletPortrait
+  );
 
-  const resetPlayerAnimationState = React.useCallback(() => {
-    setPlayerAnimationState(null);
-    setStartComponentsAnimation(false);
-  }, []);
-
-  // Animated values
-  const lastScrollY = React.useRef(new Animated.Value(0)).current;
-  const dragScrollY = React.useRef(new Animated.Value(0)).current;
-  const translateYOffset = React.useRef(new Animated.Value(0)).current;
-  const dragVideoPlayerY = React.useRef(new Animated.Value(0)).current;
-
-  const { height: safeAreaFrameHeight } = useSafeAreaFrame();
-  const [height, setHeight] = React.useState<number>(safeAreaFrameHeight);
-  const progressBarHeight = isLiveItem ? 0 : PROGRESS_BAR_HEIGHT;
-  const { bottom: bottomSafeArea } = useSafeAreaInsets();
-  const bottomTabBarHeight = useGetBottomTabBarHeight();
-  const startComponentsAnimationDistance = Math.round((height * 60) / 100);
-  const isTabletLandscape = useIsTabletLandscape();
-  const windowDimensions = Dimensions.get("window");
-
-  useEffect(() => {
-    // Reset player animation state when video modal is closed
-    if (!visible) {
-      resetPlayerAnimationState();
-
-      if (!isTabletLandscape) {
-        // restore to portrait ( in portrait mode height is bigger)
-        if (windowDimensions.height > windowDimensions.width) {
-          yTranslate.current?.setValue(windowDimensions.height);
-        }
-      } else {
-        yTranslate.current?.setValue(windowDimensions.height);
-      }
-    }
-  }, [
-    visible,
-    resetPlayerAnimationState,
-    windowDimensions.height,
-    isTabletLandscape,
-  ]);
+  const plugins = usePlugins();
+
+  const menuVisible = isMenuVisible(currentRoute, screenData, plugins);
+
+  const frame = useSafeAreaFrame();
+  const insets = useSafeAreaInsets();
+
+  const [heightAboveMinimised, setHeightAboveMinimised] = React.useState(0);
+
+  // memoizing heightAboveMinimised value
+  const offset = React.useRef(heightAboveMinimised);
+
+  // Used for memoizing modal y position after start/end of transition
+  const offsetAnimatedValueRef = React.useRef(
+    new Animated.Value(-offset.current)
+  );
+
+  // Used for gesture handling
+  const gestureTranslationRef = React.useRef(new Animated.Value(0));
+
+  const videoModalStateRef = React.useRef({ visible, mode });
 
   React.useEffect(() => {
-    if (visible && mode === "MAXIMIZED" && height !== safeAreaFrameHeight) {
-      setHeight(safeAreaFrameHeight);
-    }
-  }, [height, safeAreaFrameHeight, mode, visible]);
+    videoModalStateRef.current = { visible, mode };
+  }, [visible, mode]);
 
-  /*
-    If bottomTabBarHeight is equal 0 it means an app does not use bottomTabBar.
-    Because of this we need to minus bottom SafeArea offset.
-  */
+  const translateY = useMemo(() => {
+    const maxRange = heightAboveMinimised;
 
-  const minValue =
-    height -
-    (minimisedHeight + bottomTabBarHeight + progressBarHeight + bottomSafeArea);
+    const combined: Animated.AnimatedAddition<number> = Animated.add(
+      offsetAnimatedValueRef.current,
+      gestureTranslationRef.current
+    );
 
-  const modalSnapPoints = React.useMemo(() => [0, minValue], [minValue]);
-  // Last snap state which will helps us to make smooth responder to scrollview animation
-  const [lastSnap, setLastSnap] = React.useState<number>(modalSnapPoints[0]);
-  // Extracted animated values which we will use for calculations
-  const lastScrollYValue = React.useRef<number>(0);
-  const scrollPosition = React.useRef<number>(0);
+    return combined.interpolate({
+      inputRange: [0, maxRange],
+      outputRange: [0, maxRange],
+      extrapolate: "clamp",
+    });
+  }, [visible, heightAboveMinimised]);
+
+  offset.current = heightAboveMinimised;
+  yTranslate.current = translateY;
+
+  React.useEffect(() => {
+    const collapsedHeight =
+      minimisedHeight +
+      (menuVisible ? bottomTabBarHeight : 0) +
+      (isOldAndroidDevice ? 0 : insets.bottom) + // insets.bottom is added to properly display docked modal
+      PROGRESS_BAR_HEIGHT;
+
+    const heightAboveMinimised = frame.height - collapsedHeight;
+
+    const isLandscape = frame.width > frame.height;
+
+    const isTablet = getIsTablet();
+
+    const shouldIgnoreLandscape = isTablet ? isTabletPortrait : true;
+
+    if (
+      heightAboveMinimised !== offset.current &&
+      videoModalStateRef.current.mode !== "PIP" &&
+      videoModalStateRef.current.mode !== "FULLSCREEN"
+    ) {
+      if (isLandscape && shouldIgnoreLandscape) return;
+      setHeightAboveMinimised(heightAboveMinimised);
+      offset.current = heightAboveMinimised;
+    }
+  }, [frame.height, insets.bottom, menuVisible, minimisedHeight]);
 
   return (
     <ReactContext.Provider
       value={useMemo(
         () => ({
           yTranslate,
-          startComponentsAnimation,
-          setStartComponentsAnimation,
-          isActiveGesture: playerAnimationState !== null,
-          playerAnimationState,
-          setPlayerAnimationState,
-          resetPlayerAnimationState,
+          offsetAnimatedValueRef,
+          offset,
+          heightAboveMinimised,
           minimisedHeight,
-          animatedValues: {
-            lastScrollY,
-            dragScrollY,
-            dragVideoPlayerY,
-            translateYOffset,
-          },
-          lastScrollYValue,
-          scrollPosition,
-          modalSnapPoints,
-          lastSnap,
-          setLastSnap,
-          tabletLandscapePlayerTopPosition,
-          setTabletLandscapePlayerTopPosition,
-          startComponentsAnimationDistance,
-          progressBarHeight,
+          gestureTranslationRef,
         }),
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        [
-          startComponentsAnimation,
-          playerAnimationState,
-          minimisedHeight,
-          lastScrollY,
-          dragScrollY,
-          dragVideoPlayerY,
-          translateYOffset,
-          lastSnap,
-          modalSnapPoints,
-          lastScrollYValue,
-          scrollPosition,
-          tabletLandscapePlayerTopPosition,
-          startComponentsAnimationDistance,
-          progressBarHeight,
-          isLiveItem,
-        ]
+        [minimisedHeight, heightAboveMinimised]
       )}
     >
       {children}

package/Components/VideoModal/ModalAnimation/index.ts

@@ -1,18 +1,7 @@
-export { AnimatedPlayerModalWrapper } from "./AnimatedPlayerModalWrapper";
-
-export { AnimatedScrollModal } from "./AnimatedScrollModal";
-
-export { AnimatedVideoPlayerComponent } from "./AnimatedVideoPlayerComponent";
-
-export {
-  withModalAnimationProvider,
-  PlayerAnimationStateEnum,
-} from "./ModalAnimationContext";
+export { withModalAnimationProvider } from "./ModalAnimationContext";
 
 export { useModalAnimationContext } from "./useModalAnimationContext";
 
-export { AnimationComponent } from "./AnimationComponent";
-
-export { ComponentAnimationType, defaultAspectRatioWidth } from "./utils";
+export { defaultAspectRatioWidth } from "./utils";
 
 export { DURATION_TO_MINIMIZE, DURATION_TO_MAXIMIZE } from "./const";

package/Components/VideoModal/ModalAnimation/utils.ts

@@ -1,332 +1,6 @@
-/* eslint-disable padding-line-between-statements */
-
-import { PlayerAnimationStateEnum } from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
-import { toNumberWithDefaultZero } from "@applicaster/zapp-react-native-utils/numberUtils";
-
-export enum ComponentAnimationType {
-  bottomBar = "bottomBar",
-  player = "player",
-  componentFade = "componentFade",
-  componentAppears = "componentAppears",
-  moveUpComponent = "moveUpComponent",
-  moveComponentHorizontal = "moveComponentHorizontal",
-  audioPlayerPaddingHorizontal = "audioPlayerPaddingHorizontal",
-}
-
 export const AUDIO_PLAYER_HORIZONTAL_PADDING = 15;
+
 export const PROGRESS_BAR_HEIGHT = 3;
 
 export const defaultAspectRatioWidth = (height: number): number =>
   (height / 9) * 16;
-
-export const getAnimationStyle = (component, animatedValue) => {
-  switch (component) {
-    case ComponentAnimationType.bottomBar: {
-      return { zIndex: 99, transform: [{ translateY: animatedValue }] };
-    }
-
-    case ComponentAnimationType.player: {
-      return { width: animatedValue.x, height: animatedValue.y };
-    }
-
-    case ComponentAnimationType.componentFade:
-    case ComponentAnimationType.componentAppears: {
-      return { opacity: animatedValue };
-    }
-
-    case ComponentAnimationType.moveUpComponent: {
-      return { transform: [{ translateY: animatedValue }] };
-    }
-
-    case ComponentAnimationType.audioPlayerPaddingHorizontal:
-    case ComponentAnimationType.moveComponentHorizontal: {
-      return { transform: [{ translateX: animatedValue }] };
-    }
-
-    default:
-      return null;
-  }
-};
-
-export const getAnimationDefaultValue = (component, bottomTabBarHeight) => {
-  switch (component) {
-    case ComponentAnimationType.bottomBar: {
-      return bottomTabBarHeight;
-    }
-
-    case ComponentAnimationType.player: {
-      return { x: 0, y: 0 };
-    }
-
-    case ComponentAnimationType.componentFade: {
-      return 1;
-    }
-
-    case ComponentAnimationType.audioPlayerPaddingHorizontal:
-    case ComponentAnimationType.moveComponentHorizontal:
-    case ComponentAnimationType.componentAppears:
-    case ComponentAnimationType.moveUpComponent: {
-      return 0;
-    }
-  }
-};
-
-export const calculateAnimationValue = (animationType, dragPosition, data) => {
-  const {
-    isAudioItem,
-    bottomTabBarHeight,
-    minimisedHeight,
-    minimisedWidth,
-    defaultValue,
-    moveUpValue,
-    moveComponentHorizontalValue,
-    isTablet,
-    isTabletLandscape,
-    isRTL,
-    fromMiniPlayer,
-    inlineAudioPlayer,
-  } = data;
-
-  switch (animationType) {
-    case ComponentAnimationType.bottomBar: {
-      if (fromMiniPlayer) {
-        return dragPosition < bottomTabBarHeight
-          ? dragPosition
-          : bottomTabBarHeight;
-      }
-
-      return dragPosition < bottomTabBarHeight
-        ? bottomTabBarHeight - dragPosition
-        : 0;
-    }
-
-    case ComponentAnimationType.player: {
-      const value =
-        isAudioItem && !inlineAudioPlayer
-          ? isTabletLandscape
-            ? fromMiniPlayer
-              ? { forWidth: 4, forHeight: 4.5 }
-              : { forWidth: 3, forHeight: 3 }
-            : { forWidth: 2, forHeight: 2 }
-          : isTabletLandscape
-            ? { forWidth: 8, forHeight: 6.5 }
-            : { forWidth: 3.5, forHeight: 2 };
-
-      const minWidth =
-        isAudioItem && !inlineAudioPlayer ? minimisedHeight : minimisedWidth;
-
-      if (fromMiniPlayer) {
-        const calculationWidth =
-          dragPosition * value.forWidth < minWidth
-            ? minWidth
-            : dragPosition * value.forWidth;
-        const calculationHeight =
-          dragPosition * value.forHeight < minimisedHeight
-            ? minimisedHeight
-            : dragPosition * value.forHeight;
-
-        return {
-          x:
-            calculationWidth < defaultValue.x
-              ? calculationWidth
-              : defaultValue.x,
-          y:
-            calculationHeight < defaultValue.y
-              ? calculationHeight
-              : defaultValue.y,
-        };
-      }
-
-      const calculationWidth = defaultValue.x - dragPosition * value.forWidth;
-
-      const calculationHeight = defaultValue.y - dragPosition * value.forHeight;
-
-      return {
-        x: calculationWidth > minWidth ? calculationWidth : minWidth,
-        y:
-          calculationHeight > minimisedHeight
-            ? calculationHeight
-            : minimisedHeight,
-      };
-    }
-
-    case ComponentAnimationType.componentFade: {
-      if (fromMiniPlayer) {
-        const calculation = dragPosition / (isTablet ? 200 : 150);
-
-        return calculation < 1 ? calculation : 1;
-      }
-
-      const calculation = 1 - dragPosition / (isTablet ? 200 : 150);
-
-      return calculation > 0 ? calculation : 0;
-    }
-
-    case ComponentAnimationType.componentAppears: {
-      if (fromMiniPlayer) {
-        const calculation = 1 - dragPosition / (isTablet ? 200 : 150);
-
-        return calculation > 0 ? calculation : 0;
-      }
-
-      const calculation = dragPosition / (isTablet ? 200 : 150);
-
-      return calculation < 1 ? calculation : 1;
-    }
-
-    case ComponentAnimationType.moveUpComponent: {
-      if (fromMiniPlayer) {
-        const calculation =
-          moveUpValue + dragPosition / (isTabletLandscape ? 1 : 4);
-
-        return calculation < 0 ? calculation : 0;
-      }
-
-      const calculation = 0 - dragPosition / (isTabletLandscape ? 1 : 2);
-
-      return calculation > moveUpValue ? calculation : moveUpValue;
-    }
-
-    case ComponentAnimationType.moveComponentHorizontal: {
-      if (fromMiniPlayer) {
-        const calculation = isRTL
-          ? moveComponentHorizontalValue - dragPosition * 2
-          : moveComponentHorizontalValue + dragPosition * 2;
-        const condition = isRTL ? calculation > 0 : calculation < 0;
-
-        return condition ? calculation : 0;
-      }
-
-      const calculation = isRTL ? dragPosition * 2 : -(dragPosition * 2);
-      const condition = isRTL
-        ? calculation < moveComponentHorizontalValue
-        : calculation > moveComponentHorizontalValue;
-
-      return condition ? calculation : moveComponentHorizontalValue;
-    }
-
-    case ComponentAnimationType.audioPlayerPaddingHorizontal: {
-      const padding = isRTL
-        ? AUDIO_PLAYER_HORIZONTAL_PADDING
-        : -AUDIO_PLAYER_HORIZONTAL_PADDING;
-
-      if (fromMiniPlayer) {
-        const calculation = isRTL
-          ? padding - dragPosition / 5
-          : padding + dragPosition / 5;
-        const condition = isRTL ? calculation > 0 : calculation < 0;
-
-        return condition ? calculation : 0;
-      }
-
-      const calculation = isRTL ? dragPosition / 5 : -(dragPosition / 5);
-      const condition = isRTL ? calculation < padding : calculation > padding;
-
-      return condition ? calculation : padding;
-    }
-  }
-};
-
-export const gestureListenerHelper = (data) => {
-  const {
-    listenerValue,
-    preparedValue,
-    animationType,
-    animatedValue,
-    calculationData,
-    modalSnapPoint,
-    startComponentsAnimationDistance,
-    startComponentsAnimation,
-    setStartComponentsAnimation,
-    getAnimationValue,
-  } = data;
-
-  if (calculationData.fromMiniPlayer) {
-    if (listenerValue <= 0) {
-      if (
-        preparedValue >= 0 &&
-        preparedValue <= modalSnapPoint - startComponentsAnimationDistance
-      ) {
-        !startComponentsAnimation && setStartComponentsAnimation(true);
-
-        animatedValue.setValue(
-          calculateAnimationValue(animationType, preparedValue, calculationData)
-        );
-      } else {
-        animatedValue.setValue(calculationData.defaultValue);
-        startComponentsAnimation && setStartComponentsAnimation(false);
-      }
-    } else {
-      const value = getAnimationValue(
-        animationType,
-        PlayerAnimationStateEnum.minimize
-      ).toValue;
-
-      animatedValue.setValue(value);
-    }
-  } else {
-    if (preparedValue >= startComponentsAnimationDistance) {
-      !startComponentsAnimation && setStartComponentsAnimation(true);
-      const value = Math.round(
-        preparedValue - startComponentsAnimationDistance
-      );
-
-      animatedValue.setValue(
-        calculateAnimationValue(animationType, value, calculationData)
-      );
-    } else {
-      animatedValue.setValue(calculationData.defaultValue);
-      startComponentsAnimation && setStartComponentsAnimation(false);
-    }
-  }
-};
-
-export const setScrollModalAnimatedValue = (
-  animatedValue,
-  value,
-  setLastSnap
-) => {
-  setLastSnap(value);
-  animatedValue.setValue(value);
-};
-
-export const resetScrollAnimatedValues = (
-  lastScrollY,
-  lastScrollYValue,
-  dragScrollY,
-  dragVideoPlayerY
-) => {
-  lastScrollY.setValue(0);
-  lastScrollYValue.current = 0;
-  dragScrollY.setValue(0);
-  dragVideoPlayerY.setValue(0);
-};
-
-export const getMoveUpValue = ({
-  additionalData,
-  insets,
-  isAudioItem,
-  progressBarHeight,
-  isTablet,
-  isTabletLandscape,
-  tabletLandscapePlayerTopPosition,
-}) => {
-  if (additionalData.saveArea) {
-    return -insets.top + (isAudioItem ? 0 : progressBarHeight);
-  }
-
-  if (isAudioItem) {
-    // for any layouts in audioPlayer
-    return -1 * toNumberWithDefaultZero(additionalData?.marginTop);
-  }
-
-  if (isTablet) {
-    if (isTabletLandscape) {
-      return -tabletLandscapePlayerTopPosition + progressBarHeight;
-    } else {
-      return -130;
-    }
-  }
-
-  return -50 + progressBarHeight;
-};