@applicaster/zapp-react-native-ui-components 13.0.0-rc.14 → 13.0.0-rc.140

package/Components/VideoLive/PlayerLiveImageComponent.tsx

@@ -1,6 +1,7 @@
 // /// <reference types="@applicaster/applicaster-types" />
 //
 import * as React from "react";
+import { useEffect } from "react";
 
 import { AppState, AppStateStatus, View } from "react-native";
 import { TrackedView } from "../TrackedView";
@@ -25,13 +26,15 @@ import { PlayerRole } from "@applicaster/zapp-react-native-utils/appUtils/player
 import { getAutoplaySettings } from "./utils";
 import { isString } from "@applicaster/zapp-react-native-utils/stringUtils";
 import { BufferAnimation } from "../PlayerContainer/BufferAnimation";
-import { useEffect } from "react";
 
 const { log_error, log_debug } = loggerLiveImageComponent;
 
 const isMeasurement = (item: ZappEntry) =>
   isString(item.id) && item.id.startsWith("pre-measurement-");
 
+// Pixels by which the view can slightly extend outside the viewport and still be considered fully visible.
+const CLIP_THRESHOLD = 10;
+
 type Props = {
   item: ZappEntry;
   style: Record<string, any>;
@@ -44,7 +47,10 @@ type Props = {
 };
 
 const PlayerLiveImageComponent = (props: Props) => {
-  const dimensions = useDimensions("screen", { fullDimensions: true });
+  const dimensions = useDimensions("screen", {
+    fullDimensions: true,
+    updateForInactiveScreens: false,
+  });
 
   const { item, style, playerId } = props;
 
@@ -135,13 +141,16 @@ const PlayerLiveImageComponent = (props: Props) => {
     } else {
       throw new Error("Player factory item is null");
     }
-  }, [playerId, item, playerPluginId, screenConfig]);
+  }, [playerId, item.id, playerPluginId, screenConfig]);
 
   React.useEffect(() => {
     liveImageItem.setMode = setModeDebounced;
   }, [setModeDebounced, liveImageItem]);
 
-  const { start, end } = React.useMemo(() => getAutoplaySettings(item), [item]);
+  const { start, end } = React.useMemo(
+    () => getAutoplaySettings(item),
+    [item.id]
+  );
 
   const controller = liveImageItem.getPlayer();
   const player = usePlayer(playerId);
@@ -174,7 +183,7 @@ const PlayerLiveImageComponent = (props: Props) => {
 
       unregister();
     };
-  }, [item, liveImageItem]);
+  }, [item.id, liveImageItem]);
 
   React.useEffect(() => {
     if (!player) {
@@ -244,25 +253,27 @@ const PlayerLiveImageComponent = (props: Props) => {
   }, [item.id]);
 
   React.useEffect(() => {
-    if (playerManager) {
-      const isPlayerRegistered = playerManager.isPlayerRegistered(playerId);
+    if (isMeasurement(item) || !playerManager) {
+      return;
+    }
 
-      if (isPlayerRegistered) {
-        log_error(
-          `PlayerLiveImageComponent: player ${playerId} already registered`
-        );
-      } else {
-        playerManager.registerPlayer({
-          id: playerId,
-          playerController: controller,
-        });
+    const isPlayerRegistered = playerManager.isPlayerRegistered(playerId);
 
-        return () => {
-          playerManager.unregisterPlayer(playerId);
-        };
-      }
+    if (isPlayerRegistered) {
+      log_error(
+        `PlayerLiveImageComponent: player ${playerId} already registered`
+      );
+    } else {
+      playerManager.registerPlayer({
+        id: playerId,
+        playerController: controller,
+      });
+
+      return () => {
+        playerManager.unregisterPlayer(playerId);
+      };
     }
-  }, [liveImageItem, playerId, controller]);
+  }, [liveImageItem, playerId, controller, item.id]);
 
   const onPositionUpdated = React.useCallback(
     (data) => {
@@ -302,7 +313,7 @@ const PlayerLiveImageComponent = (props: Props) => {
         LiveImageManager.instance.checkPlayerPosition(liveImageItem);
       }
     },
-    [liveImageItem, dimensions]
+    [liveImageItem, dimensions.height, dimensions.width]
   );
 
   const platformSpecificProps = isApplePlatform()
@@ -320,9 +331,10 @@ const PlayerLiveImageComponent = (props: Props) => {
     <TrackedView
       testId={`tracked-view-${playerId}-${item.title}`}
       onPositionUpdated={onPositionUpdated}
+      clipThreshold={CLIP_THRESHOLD}
     >
       <View ref={trackViewRef}>
-        {isVideoMode && (
+        {isVideoMode ? (
           <Player
             autoplay={false}
             ref={_assignRoot}
@@ -334,7 +346,7 @@ const PlayerLiveImageComponent = (props: Props) => {
             resizeMode={"cover"}
             {...platformSpecificProps}
           />
-        )}
+        ) : null}
         {
           <AnimatedInOut
             visible={isBackgroundImageVisible}

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

@@ -2,9 +2,9 @@
 import * as React from "react";
 import { render } from "@testing-library/react-native";
 import * as PlayerFactory from "@applicaster/zapp-react-native-utils/appUtils/playerManager/playerFactory";
-import { Player } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/player";
 import { ThemeContext } from "@applicaster/zapp-react-native-utils/theme";
 import * as navigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils/playerManager";
 
 import { PlayerLiveImage } from "../PlayerLiveImageComponent";
 import * as useNavigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
@@ -12,13 +12,13 @@ import * as useNavigationHooks from "@applicaster/zapp-react-native-utils/reactH
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 
-const seekTo = jest.fn();
+const mock_seekTo = jest.fn();
 
 jest.mock(
   "@applicaster/zapp-react-native-utils/appUtils/playerManager/player",
   () => ({
     Player: {
-      seekTo,
+      seekTo: mock_seekTo,
     },
   })
 );
@@ -33,7 +33,7 @@ const mockStore = configureStore();
 
 const store = mockStore({ appData: {} });
 
-const Wrapper = ({ children }: { children: React.ReactChildren }) => (
+const Wrapper = ({ children }: { children: React.ReactNode }) => (
   /* @ts-ignore */
   <Provider store={store}>
     <ThemeContext.Provider
@@ -60,10 +60,16 @@ describe("PlayerLiveImageComponent", () => {
   };
 
   beforeAll(() => {
-    jest.spyOn(PlayerFactory, "playerFactory").mockImplementation(() => ({
-      controller: new Player({}),
-      Component: () => null,
-    }));
+    jest.spyOn(PlayerFactory, "playerFactory").mockImplementation(() => {
+      const Player = jest.requireActual(
+        "@applicaster/zapp-react-native-utils/appUtils/playerManager/player"
+      ).Player;
+
+      return {
+        controller: new Player({}),
+        Component: () => null,
+      };
+    });
 
     jest.spyOn(navigationHooks, "useIsScreenActive").mockReturnValue(true);
   });
@@ -113,4 +119,53 @@ describe("PlayerLiveImageComponent", () => {
 
     // TODO: implement this test
   });
+
+  it("should register the player for normal item", () => {
+    render(
+      <Wrapper>
+        <PlayerLiveImage {...defaultProps} />
+      </Wrapper>
+    );
+
+    const isPlayerRegistered = playerManager.isPlayerRegistered(
+      defaultProps.playerId
+    );
+
+    expect(isPlayerRegistered).toBe(true);
+  });
+
+  it("should unregister the player for normal item", () => {
+    const component = render(
+      <Wrapper>
+        <PlayerLiveImage {...defaultProps} />
+      </Wrapper>
+    );
+
+    component.unmount();
+
+    const isPlayerRegistered = playerManager.isPlayerRegistered(
+      defaultProps.playerId
+    );
+
+    expect(isPlayerRegistered).toBe(false);
+  });
+
+  it("should not register the player for 'pre-measurement' item", () => {
+    const props = {
+      ...defaultProps,
+      item: {
+        ...defaultProps.item,
+        id: "pre-measurement-1",
+      },
+    };
+
+    render(
+      <Wrapper>
+        <PlayerLiveImage {...props} />
+      </Wrapper>
+    );
+
+    const isPlayerRegistered = playerManager.isPlayerRegistered(props.playerId);
+    expect(isPlayerRegistered).toBe(false);
+  });
 });

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

@@ -2,6 +2,7 @@
 
 exports[`PlayerLiveImageComponent should render correctly with default props 1`] = `
 <TrackedView
+  clipThreshold={10}
   onPositionUpdated={[Function]}
   testId="tracked-view-player1-Test"
 >
@@ -9,7 +10,7 @@ exports[`PlayerLiveImageComponent should render correctly with default props 1`]
     <View
       collapsable={false}
       style={
-        Object {
+        {
           "opacity": 1,
         }
       }
@@ -19,10 +20,10 @@ exports[`PlayerLiveImageComponent should render correctly with default props 1`]
         audioMutedByDefault={false}
         imageKey="image1"
         item={
-          Object {
+          {
             "id": "1",
             "title": "Test",
-            "type": Object {
+            "type": {
               "value": "",
             },
           }
@@ -30,13 +31,8 @@ exports[`PlayerLiveImageComponent should render correctly with default props 1`]
         onError={[Function]}
         playerId="player1"
         resizeMode="cover"
-        screenConfig={Object {}}
-        source={
-          Object {
-            "uri": "",
-          }
-        }
-        style={Object {}}
+        screenConfig={{}}
+        style={{}}
       />
     </View>
   </View>

package/Components/VideoModal/ModalAnimation/AnimatedPlayerModalWrapper.tsx

@@ -46,7 +46,7 @@ export const AnimatedPlayerModalWrapper = (props: Props) => {
 
   React.useEffect(() => {
     (playerAnimationState === PlayerAnimationStateEnum.minimize ||
-      playerAnimationState === PlayerAnimationStateEnum.maximaze) &&
+      playerAnimationState === PlayerAnimationStateEnum.maximize) &&
       setStartComponentsAnimation(true);
   }, [playerAnimationState]);
 

package/Components/VideoModal/ModalAnimation/AnimatedScrollModal.tsx

@@ -1,32 +1,34 @@
 import React from "react";
-import { Animated, StyleSheet, View, Platform } from "react-native";
+import { Animated, Platform, StyleSheet, View } from "react-native";
 
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
 import {
+  GestureHandlerRootView,
   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,
+  useModalAnimationContext,
 } 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,
+  setScrollModalAnimatedValue,
 } from "./utils";
 
+import { DURATION_TO_MINIMIZE } from "./const";
+
 const getAnimatedConfig = (toValue) => {
   return {
     toValue,
-    duration: 200,
+    duration: DURATION_TO_MINIMIZE,
     useNativeDriver: true,
   };
 };
@@ -62,25 +64,34 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
   } = useModalAnimationContext();
 
   const [enableGesture, setIEnableGesture] = React.useState<boolean>(true);
-  const { isLanguageOverlayVisible } = React.useContext(PlayerContainerContext);
+
+  const { isLanguageOverlayVisible, isSeekBarTouch } = React.useContext(
+    PlayerContainerContext
+  );
 
   const { maximiseVideoModal, minimiseVideoModal, videoModalState } =
     useNavigation();
 
-  const { mode: videoModalMode, item: videoModalItem } = videoModalState;
-  const isMaximazedModal = videoModalMode === "MAXIMIZED";
-  const isMinimizedModal = videoModalMode === "MINIMIZED";
+  const {
+    mode: videoModalMode,
+    previousMode: previousVideoModalMode,
+    item: videoModalItem,
+  } = videoModalState;
+
+  const isMaximizedModal: boolean = videoModalMode === "MAXIMIZED";
+  const isMinimizedModal: boolean = videoModalMode === "MINIMIZED";
   const previousItemId = usePrevious(videoModalItem?.id);
 
   const isNotMinimizeMaximazeAnimation =
     playerAnimationState !== PlayerAnimationStateEnum.minimize &&
-    playerAnimationState !== PlayerAnimationStateEnum.maximaze;
+    playerAnimationState !== PlayerAnimationStateEnum.maximize;
 
   const isEnablePanGesture =
     enableGesture &&
     !isLanguageOverlayVisible &&
     isNotMinimizeMaximazeAnimation &&
-    (isMaximazedModal || isMinimizedModal);
+    !isSeekBarTouch &&
+    (isMaximizedModal || isMinimizedModal);
 
   const isAudioItem = React.useMemo(
     () =>
@@ -117,7 +128,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
         const preparedTranslationY =
           Math.abs(translationY) - lastScrollYValue.current;
 
-        if (videoModalMode === "MAXIMIZED") {
+        if (isMaximizedModal) {
           const endOffsetY =
             lastSnap + preparedTranslationY + dragToss * velocityY + 150;
 
@@ -139,8 +150,8 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
             translateYOffset.flattenOffset();
             dragScrollY.setValue(0);
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
-          } else {
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
+          } else if (destSnapPoint !== modalSnapPoints[0] && isMaximizedModal) {
             setPlayerAnimationState(PlayerAnimationStateEnum.minimize);
           }
         } else {
@@ -154,7 +165,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
 
             dragScrollY.setValue(0);
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
           } else {
             resetPlayerAnimationState();
           }
@@ -164,7 +175,13 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
           resetPlayerAnimationState();
       }
     },
-    [lastSnap, modalSnapPoints, playerAnimationState, videoModalMode]
+    [
+      lastSnap,
+      modalSnapPoints,
+      playerAnimationState,
+      isMinimizedModal,
+      isMaximizedModal,
+    ]
   );
 
   const onScroll = React.useCallback(({ nativeEvent }) => {
@@ -215,17 +232,18 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
   }, []);
 
   React.useEffect(() => {
-    const { mode, previousMode, item } = videoModalState;
-
     if (
-      mode === "MAXIMIZED" &&
+      videoModalMode === "MAXIMIZED" &&
       !enableGesture &&
       scrollPosition.current === 0
     ) {
       setIEnableGesture(true);
     }
 
-    if (mode === "MINIMIZED" && previousMode === "MAXIMIZED") {
+    if (
+      videoModalMode === "MINIMIZED" &&
+      previousVideoModalMode === "MAXIMIZED"
+    ) {
       // set animation to the minimize values if moving from the player to another screen
       if (playerAnimationState === null) {
         setScrollModalAnimatedValue(
@@ -243,14 +261,16 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
       }
     } else if (
       playerAnimationState === null &&
-      ((previousItemId === item?.id &&
-        mode === "MAXIMIZED" &&
-        (previousMode === "MINIMIZED" || previousMode === "MAXIMIZED")) ||
-        (previousItemId !== item?.id && mode !== "FULLSCREEN"))
+      ((previousItemId === videoModalItem?.id &&
+        videoModalMode === "MAXIMIZED" &&
+        (previousVideoModalMode === "MINIMIZED" ||
+          previousVideoModalMode === "MAXIMIZED")) ||
+        (previousItemId !== videoModalItem?.id &&
+          videoModalMode !== "FULLSCREEN"))
     ) {
-      setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+      setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
     }
-  }, [videoModalState]);
+  }, [videoModalMode, previousVideoModalMode, videoModalItem]);
 
   React.useEffect(() => {
     if (playerAnimationState === PlayerAnimationStateEnum.minimize) {
@@ -292,7 +312,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
 
         resetPlayerAnimationState();
       });
-    } else if (playerAnimationState === PlayerAnimationStateEnum.maximaze) {
+    } else if (playerAnimationState === PlayerAnimationStateEnum.maximize) {
       Animated.timing(translateYOffset, getAnimatedConfig(0)).start(() => {
         maximiseVideoModal();
         setScrollModalAnimatedValue(translateYOffset, 0, setLastSnap);
@@ -342,6 +362,8 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
     []
   );
 
+  const scrollEnabled = isMaximizedModal && isNotMinimizeMaximazeAnimation;
+
   return (
     <Wrapper style={generalStyles.container}>
       <TapGestureHandler
@@ -355,7 +377,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
             enabled={isEnablePanGesture}
             ref={panHandlerRef}
             simultaneousHandlers={[scrollRef, tapHandlerRef]}
-            shouldCancelWhenOutside={isMaximazedModal}
+            shouldCancelWhenOutside={isMaximizedModal}
             onGestureEvent={onGestureEvent}
             onHandlerStateChange={onHandlerStateChange}
             activeOffsetY={[-5, 5]}
@@ -367,9 +389,7 @@ export const AnimatedScrollModalComponent = ({ children }: Props) => {
                 simultaneousHandlers={panHandlerRef}
               >
                 <Animated.ScrollView
-                  scrollEnabled={
-                    isMaximazedModal && isNotMinimizeMaximazeAnimation
-                  }
+                  scrollEnabled={scrollEnabled}
                   bounces={false}
                   onScrollBeginDrag={onRegisterLastScroll}
                   onScroll={onScroll}

package/Components/VideoModal/ModalAnimation/AnimatedVideoPlayerComponent.tsx

@@ -41,17 +41,21 @@ export const AnimatedVideoPlayer = ({ children }: Props) => {
     videoModalState: { mode: videoModalMode },
   } = useNavigation();
 
-  const { isLanguageOverlayVisible } = React.useContext(PlayerContainerContext);
+  const { isLanguageOverlayVisible, isSeekBarTouch } = React.useContext(
+    PlayerContainerContext
+  );
+
   const isMaximazedModal = videoModalMode === "MAXIMIZED";
   const isMinimizedModal = videoModalMode === "MINIMIZED";
 
   const isNotMinimizeMaximazeAnimation =
     playerAnimationState !== PlayerAnimationStateEnum.minimize &&
-    playerAnimationState !== PlayerAnimationStateEnum.maximaze;
+    playerAnimationState !== PlayerAnimationStateEnum.maximize;
 
   const isEnablePanGesture =
     !isLanguageOverlayVisible &&
     isNotMinimizeMaximazeAnimation &&
+    !isSeekBarTouch &&
     (isMaximazedModal || isMinimizedModal);
 
   const onGestureEvent = Animated.event(
@@ -85,7 +89,7 @@ export const AnimatedVideoPlayer = ({ children }: Props) => {
             setLastSnap(destSnapPoint);
 
             if (destSnapPoint === modalSnapPoints[0]) {
-              setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+              setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
             } else {
               lastScrollY.setValue(0);
               lastScrollYValue.current = 0;
@@ -101,7 +105,7 @@ export const AnimatedVideoPlayer = ({ children }: Props) => {
               modalSnapPoints[1] - preparedTranslationY
             );
 
-            setPlayerAnimationState(PlayerAnimationStateEnum.maximaze);
+            setPlayerAnimationState(PlayerAnimationStateEnum.maximize);
           } else {
             resetPlayerAnimationState();
           }