@applicaster/zapp-react-native-ui-components 12.0.0-rc.12 → 12.0.0-rc.121

package/Components/VideoLive/__tests__/__snapshots__/PlayerLiveImageComponent.test.tsx.snap

@@ -5,41 +5,33 @@ exports[`PlayerLiveImageComponent should render correctly with default props 1`]
   onPositionUpdated={[Function]}
   testId="tracked-view-player1-Test"
 >
-  <View
-    collapsable={false}
-    style={
-      Object {
-        "opacity": 1,
-      }
-    }
-  >
+  <View>
     <View
-      accessibilityIgnoresInvertColors={true}
-      style={Object {}}
+      collapsable={false}
+      style={
+        Object {
+          "opacity": 1,
+        }
+      }
     >
       <Image
-        resizeMode="cover"
-        source={
+        applyMaxSize={true}
+        audioMutedByDefault={false}
+        imageKey="image1"
+        item={
           Object {
-            "uri": undefined,
-          }
-        }
-        style={
-          Array [
-            Object {
-              "bottom": 0,
-              "left": 0,
-              "position": "absolute",
-              "right": 0,
-              "top": 0,
-            },
-            Object {
-              "height": undefined,
-              "width": undefined,
+            "id": "1",
+            "title": "Test",
+            "type": Object {
+              "value": "",
             },
-            undefined,
-          ]
+          }
         }
+        onError={[Function]}
+        playerId="player1"
+        resizeMode="cover"
+        screenConfig={Object {}}
+        style={Object {}}
       />
     </View>
   </View>

package/Components/VideoModal/ModalAnimation/AnimatedPlayerModalWrapper.tsx

@@ -0,0 +1,66 @@
+import React from "react";
+import { Animated, ViewStyle } from "react-native";
+
+import {
+  useModalAnimationContext,
+  PlayerAnimationStateEnum,
+} from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
+
+type Props = {
+  style: ViewStyle[];
+  children: React.ReactNode;
+};
+
+export const AnimatedPlayerModalWrapper = (props: Props) => {
+  const {
+    playerAnimationState,
+    animatedValues: { lastScrollY, dragScrollY, translateYOffset },
+    modalSnapPoints,
+    setStartComponentsAnimation,
+  } = useModalAnimationContext();
+
+  const interpolateConfig: Animated.InterpolationConfigType = React.useMemo(
+    () => ({
+      inputRange: modalSnapPoints,
+      outputRange: modalSnapPoints,
+      extrapolate: "clamp",
+    }),
+    [modalSnapPoints]
+  );
+
+  let translateY;
+
+  if (playerAnimationState === PlayerAnimationStateEnum.drag_player) {
+    translateY = translateYOffset.interpolate(interpolateConfig);
+  } else {
+    const reverseLastScrollY = Animated.multiply(
+      new Animated.Value(-1),
+      lastScrollY
+    );
+
+    translateY = Animated.add(
+      translateYOffset,
+      Animated.add(dragScrollY, reverseLastScrollY)
+    ).interpolate(interpolateConfig);
+  }
+
+  React.useEffect(() => {
+    const translateYListener = translateY.addListener(() => {
+      (playerAnimationState === PlayerAnimationStateEnum.minimize ||
+        playerAnimationState === PlayerAnimationStateEnum.maximaze) &&
+        setStartComponentsAnimation(true);
+    });
+
+    return () => {
+      translateYListener && translateY.removeListener(translateYListener);
+    };
+  }, [playerAnimationState]);
+
+  return (
+    <Animated.View
+      style={[props.style, { transform: [{ translateY: translateY }] }]}
+    >
+      {props.children}
+    </Animated.View>
+  );
+};

package/Components/VideoModal/ModalAnimation/AnimatedScrollModal.tsx

@@ -0,0 +1,376 @@
+import React from "react";
+import { Animated, StyleSheet, View, Platform } from "react-native";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import {
+  NativeViewGestureHandler,
+  PanGestureHandler,
+  State,
+  TapGestureHandler,
+  GestureHandlerRootView,
+} from "react-native-gesture-handler";
+
+import { PlayerContainerContext } from "@applicaster/zapp-react-native-ui-components/Components/PlayerContainer/PlayerContainerContext";
+import {
+  useModalAnimationContext,
+  PlayerAnimationStateEnum,
+} from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
+import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { usePrevious } from "@applicaster/zapp-react-native-utils/reactHooks/utils";
+
+import {
+  setScrollModalAnimatedValue,
+  resetScrollAnimatedValues,
+} from "./utils";
+
+const getAnimatedConfig = (toValue) => {
+  return {
+    toValue,
+    duration: 200,
+    useNativeDriver: true,
+  };
+};
+
+const generalStyles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+});
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export const AnimatedScrollModalComponent = ({ children }: Props) => {
+  const {
+    isActiveGesture,
+    playerAnimationState,
+    setPlayerAnimationState,
+    resetPlayerAnimationState,
+    animatedValues: {
+      lastScrollY,
+      dragScrollY,
+      dragVideoPlayerY,
+      translateYOffset,
+    },
+    lastScrollYValue,
+    scrollPosition,
+    modalSnapPoints,
+    lastSnap,
+    setLastSnap,
+    setStartComponentsAnimation,
+  } = useModalAnimationContext();
+
+  const { isLanguageOverlayVisible } = React.useContext(PlayerContainerContext);
+
+  const { maximiseVideoModal, minimiseVideoModal, videoModalState } =
+    useNavigation();
+
+  const isMaximazedModal = videoModalState.mode === "MAXIMIZED";
+  const isMinimizedModal = videoModalState.mode === "MINIMIZED";
+  const previousItemId = usePrevious(videoModalState.item?.id);
+
+  const isNotMinimizeMaximazeAnimation =
+    playerAnimationState !== PlayerAnimationStateEnum.minimize &&
+    playerAnimationState !== PlayerAnimationStateEnum.maximaze;
+
+  const isEnablePanGesture =
+    !isLanguageOverlayVisible &&
+    isNotMinimizeMaximazeAnimation &&
+    (isMaximazedModal || isMinimizedModal);
+
+  const isAudioItem = React.useMemo(
+    () =>
+      videoModalState.item?.content?.type?.includes?.("audio") ||
+      videoModalState.item?.type?.value === "audio",
+    [videoModalState.item]
+  );
+
+  // Refs for components
+  const scrollRef = React.useRef(null);
+  const tapHandlerRef = React.useRef(null);
+  const panHandlerRef = React.useRef(null);
+
+  const onRegisterLastScroll = Animated.event(
+    [{ nativeEvent: { contentOffset: { y: lastScrollY } } }],
+    { useNativeDriver: true }
+  );
+
+  const onGestureEvent = Animated.event(
+    [{ nativeEvent: { translationY: dragScrollY } }],
+    { useNativeDriver: true }
+  );
+
+  const onHandlerStateChange = React.useCallback(
+    ({ nativeEvent }) => {
+      if (
+        nativeEvent.oldState === State.ACTIVE &&
+        scrollPosition.current === 0
+      ) {
+        // eslint-disable-next-line prefer-const
+        const { velocityY, translationY } = nativeEvent;
+        const dragToss = 0.05;
+
+        const preparedTranslationY =
+          Math.abs(translationY) - lastScrollYValue.current;
+
+        if (videoModalState.mode === "MAXIMIZED") {
+          const endOffsetY =
+            lastSnap + preparedTranslationY + dragToss * velocityY + 150;
+
+          let destSnapPoint = modalSnapPoints[0];
+
+          for (const snapPoint of modalSnapPoints) {
+            const distFromSnap = Math.abs(snapPoint - endOffsetY);
+
+            if (distFromSnap < Math.abs(destSnapPoint - endOffsetY)) {
+              destSnapPoint = snapPoint;
+            }
+          }
+
+          setLastSnap(destSnapPoint);
+
+          if (destSnapPoint === modalSnapPoints[0]) {
+            translateYOffset.extractOffset();
+            translateYOffset.setValue(preparedTranslationY);
+            translateYOffset.flattenOffset();
+            dragScrollY.setValue(0);
+
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+          } else {
+            setPlayerAnimationState(PlayerAnimationStateEnum.minimize);
+          }
+        } else {
+          if (translationY < 0) {
+            // from mini to full
+            setLastSnap(modalSnapPoints[0]);
+
+            translateYOffset.setValue(
+              modalSnapPoints[1] - preparedTranslationY
+            );
+
+            dragScrollY.setValue(0);
+
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+          } else {
+            resetPlayerAnimationState();
+          }
+        }
+      } else {
+        playerAnimationState === PlayerAnimationStateEnum.drag_scroll &&
+          resetPlayerAnimationState();
+      }
+    },
+    [lastSnap, modalSnapPoints, playerAnimationState, videoModalState.mode]
+  );
+
+  const onScroll = React.useCallback(({ nativeEvent }) => {
+    scrollPosition.current = nativeEvent.contentOffset.y;
+  }, []);
+
+  const onMomentumScrollEnd = React.useCallback(
+    ({ nativeEvent }) => {
+      if (nativeEvent.contentOffset.y === 0 && !isActiveGesture) {
+        resetScrollAnimatedValues(
+          lastScrollY,
+          lastScrollYValue,
+          dragScrollY,
+          dragVideoPlayerY
+        );
+      }
+    },
+    [isActiveGesture]
+  );
+
+  React.useEffect(() => {
+    return () => {
+      scrollPosition.current = 0;
+
+      resetScrollAnimatedValues(
+        lastScrollY,
+        lastScrollYValue,
+        dragScrollY,
+        dragVideoPlayerY
+      );
+    };
+  }, []);
+
+  React.useEffect(() => {
+    if (
+      videoModalState.mode === "MINIMIZED" &&
+      videoModalState.previousMode === "MAXIMIZED"
+    ) {
+      // set animation to the minimize values if moving from the player to another screen
+      if (playerAnimationState === null) {
+        setScrollModalAnimatedValue(
+          translateYOffset,
+          modalSnapPoints[1],
+          setLastSnap
+        );
+
+        resetScrollAnimatedValues(
+          lastScrollY,
+          lastScrollYValue,
+          dragScrollY,
+          dragVideoPlayerY
+        );
+      } else {
+        resetPlayerAnimationState();
+      }
+    }
+
+    if (
+      (videoModalState.mode === "MAXIMIZED" &&
+        videoModalState.previousMode === "MINIMIZED" &&
+        previousItemId === videoModalState.item?.id) ||
+      previousItemId !== videoModalState.item?.id
+    ) {
+      setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+      setTimeout(() => resetPlayerAnimationState());
+    }
+  }, [videoModalState, previousItemId]);
+
+  React.useEffect(() => {
+    if (playerAnimationState === PlayerAnimationStateEnum.minimize) {
+      if (
+        (scrollPosition.current === 0 &&
+          (lastScrollY as any)._value !== 0 &&
+          (dragScrollY as any)._value === 0 &&
+          (dragVideoPlayerY as any)._value === 0) ||
+        (scrollPosition.current !== 0 &&
+          ((dragScrollY as any)._value !== 0 ||
+            (dragVideoPlayerY as any)._value !== 0))
+      ) {
+        resetScrollAnimatedValues(
+          lastScrollY,
+          lastScrollYValue,
+          dragScrollY,
+          dragVideoPlayerY
+        );
+      }
+
+      Animated.timing(
+        translateYOffset,
+        getAnimatedConfig(modalSnapPoints[1])
+      ).start(() => {
+        setTimeout(() => {
+          minimiseVideoModal();
+
+          setScrollModalAnimatedValue(
+            translateYOffset,
+            modalSnapPoints[1],
+            setLastSnap
+          );
+
+          resetScrollAnimatedValues(
+            lastScrollY,
+            lastScrollYValue,
+            dragScrollY,
+            dragVideoPlayerY
+          );
+        }, 150);
+      });
+    } else if (playerAnimationState === PlayerAnimationStateEnum.maximaze) {
+      Animated.timing(translateYOffset, getAnimatedConfig(0)).start(() => {
+        maximiseVideoModal();
+        setScrollModalAnimatedValue(translateYOffset, 0, setLastSnap);
+
+        resetScrollAnimatedValues(
+          lastScrollY,
+          lastScrollYValue,
+          dragScrollY,
+          dragVideoPlayerY
+        );
+
+        resetPlayerAnimationState();
+      });
+    }
+
+    const lastScrollYListenerId = lastScrollY.addListener(({ value }) => {
+      lastScrollYValue.current = value;
+    });
+
+    const dragListenerId = dragScrollY.addListener(({ value }) => {
+      const preparedValue =
+        isMinimizedModal && value >= 0
+          ? 0
+          : Math.round(isAudioItem ? Math.abs(value) : value);
+
+      if (
+        preparedValue > 0 &&
+        scrollPosition.current === 0 &&
+        playerAnimationState !== PlayerAnimationStateEnum.drag_player &&
+        playerAnimationState !== PlayerAnimationStateEnum.drag_scroll
+      ) {
+        isMinimizedModal && setStartComponentsAnimation(true);
+        setPlayerAnimationState(PlayerAnimationStateEnum.drag_scroll);
+      }
+    });
+
+    return () => {
+      lastScrollY.removeListener(lastScrollYListenerId);
+      dragScrollY.removeListener(dragListenerId);
+    };
+  }, [playerAnimationState, isAudioItem, modalSnapPoints, isMinimizedModal]);
+
+  const Wrapper = React.useMemo(
+    () => (Platform.OS === "android" ? GestureHandlerRootView : View),
+    []
+  );
+
+  return (
+    <Wrapper style={generalStyles.container}>
+      <TapGestureHandler
+        maxDurationMs={100000}
+        ref={tapHandlerRef}
+        maxDeltaY={lastSnap - modalSnapPoints[0]}
+        numberOfTaps={1}
+      >
+        <View pointerEvents="box-none">
+          <PanGestureHandler
+            enabled={isEnablePanGesture}
+            ref={panHandlerRef}
+            simultaneousHandlers={[scrollRef, tapHandlerRef]}
+            shouldCancelWhenOutside={isMaximazedModal}
+            onGestureEvent={onGestureEvent}
+            onHandlerStateChange={onHandlerStateChange}
+            activeOffsetY={[-5, 5]}
+          >
+            <Animated.View>
+              <NativeViewGestureHandler
+                ref={scrollRef}
+                waitFor={tapHandlerRef}
+                simultaneousHandlers={panHandlerRef}
+              >
+                <Animated.ScrollView
+                  scrollEnabled={
+                    isMaximazedModal && isNotMinimizeMaximazeAnimation
+                  }
+                  bounces={false}
+                  onScrollBeginDrag={onRegisterLastScroll}
+                  onScroll={onScroll}
+                  onMomentumScrollEnd={onMomentumScrollEnd}
+                  scrollEventThrottle={1}
+                  showsVerticalScrollIndicator={false}
+                >
+                  {children}
+                </Animated.ScrollView>
+              </NativeViewGestureHandler>
+            </Animated.View>
+          </PanGestureHandler>
+        </View>
+      </TapGestureHandler>
+    </Wrapper>
+  );
+};
+
+export const AnimatedScrollModal = ({ children }: Props) => {
+  const {
+    videoModalState: { visible },
+  } = useNavigation();
+
+  const Component =
+    !isTV() && visible ? AnimatedScrollModalComponent : React.Fragment;
+
+  return <Component>{children}</Component>;
+};

package/Components/VideoModal/ModalAnimation/AnimatedVideoPlayerComponent.tsx

@@ -0,0 +1,165 @@
+import React from "react";
+import { Animated, StyleSheet } from "react-native";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { PanGestureHandler, State } from "react-native-gesture-handler";
+
+import { PlayerContainerContext } from "@applicaster/zapp-react-native-ui-components/Components/PlayerContainer/PlayerContainerContext";
+import {
+  useModalAnimationContext,
+  PlayerAnimationStateEnum,
+} from "@applicaster/zapp-react-native-ui-components/Components/VideoModal/ModalAnimation";
+import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
+
+const generalStyles = StyleSheet.create({
+  container: {
+    flex: 1,
+    width: "100%",
+    position: "absolute",
+    zIndex: 201,
+  },
+});
+
+type Props = {
+  children: React.ReactNode;
+};
+
+export const AnimatedVideoPlayer = ({ children }: Props) => {
+  const {
+    playerAnimationState,
+    setPlayerAnimationState,
+    animatedValues: { translateYOffset, dragVideoPlayerY, lastScrollY },
+    lastScrollYValue,
+    modalSnapPoints,
+    lastSnap,
+    setLastSnap,
+    resetPlayerAnimationState,
+    setStartComponentsAnimation,
+  } = useModalAnimationContext();
+
+  const { videoModalState } = useNavigation();
+  const { isLanguageOverlayVisible } = React.useContext(PlayerContainerContext);
+
+  const isMaximazedModal = videoModalState.mode === "MAXIMIZED";
+  const isMinimizedModal = videoModalState.mode === "MINIMIZED";
+
+  const isEnablePanGesture =
+    !isLanguageOverlayVisible && (isMaximazedModal || isMinimizedModal);
+
+  const onGestureEvent = Animated.event(
+    [{ nativeEvent: { translationY: dragVideoPlayerY } }],
+    { useNativeDriver: true }
+  );
+
+  const onHandlerStateChange = React.useCallback(
+    ({ nativeEvent }) => {
+      if (nativeEvent.oldState === State.ACTIVE) {
+        // eslint-disable-next-line prefer-const
+        const { velocityY, translationY } = nativeEvent;
+        const preparedTranslationY = Math.abs(translationY);
+        const dragToss = 0.05;
+
+        if (videoModalState.mode === "MAXIMIZED") {
+          if (translationY > 0) {
+            const endOffsetY =
+              lastSnap + preparedTranslationY + dragToss * velocityY + 200;
+
+            let destSnapPoint = modalSnapPoints[0];
+
+            for (const snapPoint of modalSnapPoints) {
+              const distFromSnap = Math.abs(snapPoint - endOffsetY);
+
+              if (distFromSnap < Math.abs(destSnapPoint - endOffsetY)) {
+                destSnapPoint = snapPoint;
+              }
+            }
+
+            setLastSnap(destSnapPoint);
+
+            if (destSnapPoint === modalSnapPoints[0]) {
+              setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+            } else {
+              lastScrollY.setValue(0);
+              lastScrollYValue.current = 0;
+              setPlayerAnimationState(PlayerAnimationStateEnum.minimize);
+            }
+          }
+        } else if (videoModalState.mode === "MINIMIZED") {
+          if (translationY < 0) {
+            // from mini to full
+            setLastSnap(modalSnapPoints[0]);
+
+            translateYOffset.setValue(
+              modalSnapPoints[1] - preparedTranslationY
+            );
+
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+          } else {
+            resetPlayerAnimationState();
+          }
+        }
+      }
+    },
+    [lastSnap, modalSnapPoints, videoModalState.mode]
+  );
+
+  React.useEffect(() => {
+    const dragVideoPlayerYListenerId = dragVideoPlayerY.addListener(
+      ({ value }) => {
+        if (
+          (isMinimizedModal && value >= 0) ||
+          (isMaximazedModal && value <= 0)
+        ) {
+          if (playerAnimationState === PlayerAnimationStateEnum.drag_player) {
+            translateYOffset.setValue(
+              modalSnapPoints[isMinimizedModal ? 1 : 0]
+            );
+          }
+        } else {
+          const preparedValue = Math.round(Math.abs(value));
+
+          if (
+            preparedValue > 0 &&
+            playerAnimationState !== PlayerAnimationStateEnum.drag_scroll
+          ) {
+            if (playerAnimationState !== PlayerAnimationStateEnum.drag_player) {
+              isMinimizedModal && setStartComponentsAnimation(true);
+              setPlayerAnimationState(PlayerAnimationStateEnum.drag_player);
+            }
+
+            translateYOffset.setValue(
+              isMaximazedModal
+                ? preparedValue
+                : modalSnapPoints[1] - preparedValue
+            );
+          }
+        }
+      }
+    );
+
+    return () => {
+      dragVideoPlayerY.removeListener(dragVideoPlayerYListenerId);
+    };
+  }, [playerAnimationState, isMinimizedModal, isMaximazedModal]);
+
+  return (
+    <PanGestureHandler
+      enabled={isEnablePanGesture}
+      shouldCancelWhenOutside={isMaximazedModal}
+      onGestureEvent={onGestureEvent}
+      onHandlerStateChange={onHandlerStateChange}
+    >
+      <Animated.View style={generalStyles.container}>{children}</Animated.View>
+    </PanGestureHandler>
+  );
+};
+
+export const AnimatedVideoPlayerComponent = ({ children }: Props) => {
+  const {
+    videoModalState: { visible },
+  } = useNavigation();
+
+  const Component = !isTV() && visible ? AnimatedVideoPlayer : React.Fragment;
+
+  return <Component>{children}</Component>;
+};