@zezosoft/zezo-ott-react-native-video-player 1.0.4 → 1.0.5

package/src/VideoPlayer/styles/globalStyles.ts

@@ -1,73 +0,0 @@
-import { StyleSheet } from 'react-native';
-
-const globalStyles = StyleSheet.create({
-  centerContainer: {
-    flex: 1,
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  container: {
-    flex: 1,
-  },
-  newContainer: {
-    flex: 1,
-  },
-  flexOneJustifyContentAndAlignItemsCenter: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  flexOneJustifyContentCenterAndAlignItemsCenter: {
-    flex: 1,
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  hundredPercentWidth: {
-    width: '100%',
-  },
-  hundredPercentHeight: {
-    height: '100%',
-  },
-  marginZeroAndPaddingZero: {
-    margin: 0,
-    padding: 0,
-  },
-  overflowHidden: {
-    overflow: 'hidden',
-  },
-  flexOne: {
-    flex: 1,
-  },
-  flexZero: {
-    flex: 0,
-  },
-  positionAbsolute: {
-    position: 'absolute',
-  },
-  twentyPercentWidth: {
-    width: '20%',
-  },
-  alignItemsCenterAndJustifyContentCenter: {
-    alignItems: 'center',
-    justifyContent: 'center',
-  },
-  textAlignCenter: {
-    textAlign: 'center',
-  },
-  flexRow_alignCenter_justifyBetween: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'space-between',
-  },
-  flexOneWithBlackBackground: {
-    flex: 1,
-    backgroundColor: 'black',
-  },
-  absoluteFill: StyleSheet.absoluteFillObject,
-  controlsContainer: {
-    flex: 1,
-    backgroundColor: 'rgba(0, 0, 0, 0.5)',
-  },
-});
-
-export default globalStyles;

package/src/VideoPlayer/utils/display/Display.ts

@@ -1,10 +0,0 @@
-import { Dimensions } from 'react-native';
-
-const { height, width } = Dimensions.get('window');
-
-const setHeight = (h: number) => (height / 100) * h;
-const setWidth = (w: number) => (width / 100) * w;
-const fullWidth = Dimensions.get('window').width;
-const fullHeight = Dimensions.get('window').height;
-
-export default { setHeight, setWidth, fullWidth, fullHeight };

package/src/VideoPlayer/utils/display/index.ts

@@ -1 +0,0 @@
-export { default as Display } from './Display';

package/src/VideoPlayer/utils/format/index.ts

@@ -1 +0,0 @@
-export * from './timeFormatter';

package/src/VideoPlayer/utils/format/timeFormatter.ts

@@ -1,44 +0,0 @@
-export const formatDuration = (
-  totalSeconds: number,
-  hideSeconds = false,
-  addSpaces = false
-): string => {
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-
-  const formatUnit = (value: number, label: string) =>
-    value ? `${value}${addSpaces ? ` ${label} ` : label}` : '';
-
-  const result =
-    formatUnit(hours, 'h') +
-    formatUnit(minutes, 'm') +
-    formatUnit(seconds, 's');
-
-  return hideSeconds
-    ? formatUnit(hours, 'h') + formatUnit(minutes, 'm')
-    : result;
-};
-
-export const formatTime = (seconds: number) => {
-  const h = Math.floor(seconds / 3600);
-  const m = Math.floor((seconds % 3600) / 60);
-  const s = Math.floor(seconds % 60);
-  if (h > 0) {
-    return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
-  }
-  return `${m}:${String(s).padStart(2, '0')}`;
-};
-
-export const formatTimeWithMs = (seconds: number): string => {
-  if (isNaN(seconds) || seconds < 0) return '00:00.000';
-  const totalMs = Math.floor(seconds * 1000);
-  const ms = totalMs % 1000;
-  const totalSec = Math.floor(totalMs / 1000);
-  const min = Math.floor(totalSec / 60);
-  const sec = totalSec % 60;
-  return `${String(min).padStart(2, '0')}:${String(sec).padStart(
-    2,
-    '0'
-  )}.${String(ms).padStart(3, '0')}`;
-};

package/src/VideoPlayer/utils/hooks/index.ts

@@ -1,5 +0,0 @@
-export * from './useVideoPlayerBack';
-export * from './useVideoResolutions';
-export * from './useAdEventHandler';
-export * from './usePauseVideoOnAd';
-export * from './useOrientationLock';

package/src/VideoPlayer/utils/hooks/useAdEventHandler.ts

@@ -1,95 +0,0 @@
-import { useCallback } from 'react';
-import type { VideoAd } from '../../store/videoPlayer.type';
-import type { ExtendedWatchProgress } from '../player/useWatchReporter';
-import type { MediaEpisode } from '../../store/videoPlayer.type';
-
-interface UseAdEventHandlerParams {
-  resumeVideoFromAd: (resumeTime: number | null) => void;
-  resumeTime: number | null;
-  playerEvents: {
-    onEnd: (params: {
-      reportProgress: (event: ExtendedWatchProgress['event']) => void;
-      onPressEpisode: ({
-        episode,
-      }: {
-        episode: MediaEpisode;
-      }) => Promise<boolean>;
-      autoNext: boolean;
-    }) => void;
-  };
-  reportProgress: (event: ExtendedWatchProgress['event']) => void;
-  onPressEpisode?: ({ episode }: { episode: MediaEpisode }) => Promise<boolean>;
-  autoNext: boolean;
-  onAdEnd?: (ad: VideoAd) => void;
-  onAdError?: (error: Error, ad: VideoAd) => void;
-}
-
-/**
- * Reusable hook for handling ad events (end, skip, error)
- * Consolidates duplicate logic from handleAdEnd, handleAdSkip, and handleAdError
- */
-export const useAdEventHandler = ({
-  resumeVideoFromAd,
-  resumeTime,
-  playerEvents,
-  reportProgress,
-  onPressEpisode,
-  autoNext,
-  onAdEnd,
-  onAdError,
-}: UseAdEventHandlerParams) => {
-  const handlePostRollAd = useCallback(() => {
-    playerEvents.onEnd({
-      reportProgress,
-      onPressEpisode: onPressEpisode ?? (async () => true),
-      autoNext,
-    });
-  }, [playerEvents, reportProgress, onPressEpisode, autoNext]);
-
-  const handleNonPostRollAd = useCallback(() => {
-    resumeVideoFromAd(resumeTime);
-  }, [resumeVideoFromAd, resumeTime]);
-
-  const handleAdEnd = useCallback(
-    (endedAd: VideoAd) => {
-      onAdEnd?.(endedAd);
-
-      if (endedAd.position === 'post') {
-        handlePostRollAd();
-      } else {
-        handleNonPostRollAd();
-      }
-    },
-    [onAdEnd, handlePostRollAd, handleNonPostRollAd]
-  );
-
-  const handleAdSkip = useCallback(
-    (skippedAd: VideoAd) => {
-      onAdEnd?.(skippedAd);
-
-      if (skippedAd.position !== 'post') {
-        handleNonPostRollAd();
-      }
-    },
-    [onAdEnd, handleNonPostRollAd]
-  );
-
-  const handleAdError = useCallback(
-    (error: Error, errorAd: VideoAd) => {
-      onAdError?.(error, errorAd);
-
-      if (errorAd.position !== 'post') {
-        handleNonPostRollAd();
-      } else {
-        handlePostRollAd();
-      }
-    },
-    [onAdError, handleNonPostRollAd, handlePostRollAd]
-  );
-
-  return {
-    handleAdEnd,
-    handleAdSkip,
-    handleAdError,
-  };
-};

package/src/VideoPlayer/utils/hooks/useOrientationLock.ts

@@ -1,29 +0,0 @@
-import { useEffect } from 'react';
-import { lockToLandscape, lockToPortrait } from '../platform';
-
-interface UseOrientationLockParams {
-  isFocused: boolean;
-  mode: 'fullscreen' | 'normal';
-}
-
-/**
- * Reusable hook for managing orientation locking
- * Consolidates orientation logic from VideoPlayer
- */
-export const useOrientationLock = ({
-  isFocused,
-  mode,
-}: UseOrientationLockParams) => {
-  useEffect(() => {
-    if (!isFocused) {
-      lockToPortrait();
-      return;
-    }
-
-    if (mode === 'fullscreen') {
-      lockToLandscape();
-    } else {
-      lockToPortrait();
-    }
-  }, [isFocused, mode]);
-};

package/src/VideoPlayer/utils/hooks/usePauseVideoOnAd.ts

@@ -1,46 +0,0 @@
-import { useEffect, useRef } from 'react';
-import { useVideoPlayerStore } from '../../store/videoPlayerStore';
-import { useAdsPlayerStore } from '../../../AdsPlayer/store/adsPlayerStore';
-
-/**
- * Reusable hook to pause main video when ads start playing
- * Saves current time as resume time for pre-roll ads
- */
-export const usePauseVideoOnAd = () => {
-  const { setIsPaused, currentTime, isPaused } = useVideoPlayerStore();
-  const { currentAd, isAdPlaying, resumeTime, setResumeTime } =
-    useAdsPlayerStore();
-
-  const lastResumeTimeRef = useRef<number | null>(null);
-
-  useEffect(() => {
-    if (isAdPlaying && currentAd) {
-      // Only pause if not already paused to prevent unnecessary updates
-      if (!isPaused) {
-        setIsPaused(true);
-      }
-
-      // Save current time as resume time if not already set (for pre-roll ads)
-      // Use ref to prevent setting the same value multiple times
-      if (
-        resumeTime === null &&
-        currentTime > 0 &&
-        lastResumeTimeRef.current !== currentTime
-      ) {
-        lastResumeTimeRef.current = currentTime;
-        setResumeTime(currentTime);
-      }
-    } else if (!isAdPlaying && !currentAd) {
-      // Reset ref when no ad is playing
-      lastResumeTimeRef.current = null;
-    }
-  }, [
-    isAdPlaying,
-    currentAd,
-    isPaused,
-    setIsPaused,
-    currentTime,
-    resumeTime,
-    setResumeTime,
-  ]);
-};

package/src/VideoPlayer/utils/hooks/useVideoPlayerBack.ts

@@ -1,66 +0,0 @@
-import { useEffect, useCallback, useRef } from 'react';
-import {
-  BackHandler,
-  Platform,
-  AppState,
-  type AppStateStatus,
-} from 'react-native';
-import { lockToPortrait } from '../platform/lockOrientation';
-import { useVideoPlayerStore } from '../../store/videoPlayerStore';
-
-type UseVideoPlayerBackProps = {
-  navigation?: any;
-};
-
-export const useVideoPlayerBack = ({
-  navigation,
-}: UseVideoPlayerBackProps = {}) => {
-  const { resetStore } = useVideoPlayerStore();
-  const hasClosed = useRef(false);
-
-  const handleClose = useCallback(() => {
-    if (hasClosed.current) return;
-    hasClosed.current = true;
-
-    resetStore();
-    lockToPortrait();
-
-    if (navigation?.canGoBack()) {
-      navigation.goBack();
-    }
-  }, [resetStore, navigation]);
-
-  useEffect(() => {
-    const backHandler =
-      Platform.OS === 'android'
-        ? BackHandler.addEventListener('hardwareBackPress', () => {
-            handleClose();
-            return true;
-          })
-        : undefined;
-
-    const unsubscribe = navigation?.addListener('beforeRemove', (e: any) => {
-      e.preventDefault();
-      handleClose();
-      navigation.dispatch(e.data.action);
-    });
-
-    const handleAppStateChange = (nextAppState: AppStateStatus) => {
-      if (nextAppState === 'inactive') {
-        handleClose();
-      }
-    };
-    const appStateListener = AppState.addEventListener(
-      'change',
-      handleAppStateChange
-    );
-
-    return () => {
-      backHandler?.remove();
-      unsubscribe?.();
-      appStateListener.remove();
-    };
-  }, [handleClose, navigation]);
-
-  return handleClose;
-};

package/src/VideoPlayer/utils/hooks/useVideoResolutions.ts

@@ -1,125 +0,0 @@
-import { useEffect, useState } from 'react';
-import axios from 'axios';
-import type { MediaTrack } from '../../store/videoPlayer.type';
-
-export interface StreamInfo {
-  bandwidth: number;
-  width: number | string;
-  height: number | string;
-}
-
-async function getHLSBandwidthAndResolutions(
-  m3u8Url: string,
-  headers?: Record<string, string>
-): Promise<StreamInfo[]> {
-  try {
-    if (!m3u8Url?.endsWith('.m3u8')) return [];
-
-    const { data } = await axios.get<string>(m3u8Url, {
-      headers: headers ?? undefined,
-    });
-    if (!data) return [];
-
-    const lines = data.split('\n');
-    const streams: StreamInfo[] = [];
-
-    let bandwidth: number | null = null;
-    let width: number | null = null;
-    let height: number | null = null;
-
-    for (const line of lines) {
-      if (line.startsWith('#EXT-X-STREAM-INF')) {
-        const bandwidthMatch = line.match(/BANDWIDTH=(\d+)/);
-        const resolutionMatch = line.match(/RESOLUTION=(\d+)x(\d+)/);
-
-        bandwidth = bandwidthMatch ? Number(bandwidthMatch[1]) : null;
-        if (resolutionMatch) {
-          width = Number(resolutionMatch[1]);
-          height = Number(resolutionMatch[2]);
-        }
-      }
-
-      if (
-        line.trim().endsWith('.m3u8') &&
-        bandwidth !== null &&
-        width !== null &&
-        height !== null
-      ) {
-        streams.push({ bandwidth, width, height });
-        bandwidth = null;
-        width = null;
-        height = null;
-      }
-    }
-
-    streams.sort((a, b) => (b.height as number) - (a.height as number));
-
-    const autoStream: StreamInfo = {
-      bandwidth: 0,
-      width: 'auto',
-      height: 'auto',
-    };
-
-    return [autoStream, ...streams];
-  } catch {
-    return [];
-  }
-}
-
-export interface Resolution {
-  height: number | 'auto';
-  bandwidth: number | null;
-}
-
-const resolutionCache: Record<string, Resolution[]> = {};
-
-export const useVideoResolutions = (track: MediaTrack | null) => {
-  const [resolutions, setResolutions] = useState<Resolution[]>([
-    { height: 'auto', bandwidth: null },
-  ]);
-
-  useEffect(() => {
-    if (!track) return;
-
-    const source = track.isTrailer ? track.trailerSource : track.sourceLink;
-    if (!source) return;
-
-    if (resolutionCache[source]) {
-      setResolutions(resolutionCache[source]);
-      return;
-    }
-
-    let cancelled = false;
-
-    const fetchResolutions = async () => {
-      try {
-        const data = await getHLSBandwidthAndResolutions(source);
-        if (cancelled) return;
-
-        const filteredData = data.filter(
-          (item): item is StreamInfo & { height: number } =>
-            typeof item.height === 'number'
-        );
-
-        const newResolutions: Resolution[] = [
-          { height: 'auto', bandwidth: null },
-          ...filteredData.map((item) => ({
-            height: item.height,
-            bandwidth: item.bandwidth,
-          })),
-        ];
-
-        resolutionCache[source] = newResolutions;
-        setResolutions(newResolutions);
-      } catch {}
-    };
-
-    fetchResolutions();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [track]);
-
-  return resolutions;
-};

package/src/VideoPlayer/utils/index.ts

@@ -1,6 +0,0 @@
-export * from './video';
-export * from './player';
-export * from './platform';
-export * from './format';
-export * from './display';
-export * from './hooks';

package/src/VideoPlayer/utils/platform/PlatformSelector.ts

@@ -1,13 +0,0 @@
-import { Platform } from 'react-native';
-
-class PlatformSelector {
-  public isAndroid(): boolean {
-    return Platform.OS === 'android';
-  }
-
-  public isIOS(): boolean {
-    return Platform.OS === 'ios';
-  }
-}
-
-export default new PlatformSelector();

package/src/VideoPlayer/utils/platform/index.ts

@@ -1,2 +0,0 @@
-export * from './lockOrientation';
-export { default as PlatformSelector } from './PlatformSelector';

package/src/VideoPlayer/utils/platform/lockOrientation.ts

@@ -1,40 +0,0 @@
-import { StatusBar } from 'react-native';
-import Orientation from 'react-native-orientation-locker';
-import SystemNavigationBar from 'react-native-system-navigation-bar';
-import PlatformSelector from './PlatformSelector';
-
-export const lockToPortrait = () => {
-  try {
-    // Lock orientation immediately for fast response
-    Orientation.lockToPortrait();
-
-    // Update UI instantly without fade animation for smooth, fast rotation
-    StatusBar.setHidden(false, 'none');
-
-    if (PlatformSelector.isAndroid()) {
-      // Execute Android-specific updates synchronously for maximum speed
-      SystemNavigationBar.fullScreen(false);
-      SystemNavigationBar.navigationShow();
-    }
-  } catch (error) {
-    console.warn('Error locking to portrait:', error);
-  }
-};
-
-export const lockToLandscape = () => {
-  try {
-    // Lock orientation immediately for fast response
-    Orientation.lockToLandscape();
-
-    // Update UI instantly without fade animation for smooth, fast rotation
-    StatusBar.setHidden(true, 'none');
-
-    if (PlatformSelector.isAndroid()) {
-      // Execute Android-specific updates synchronously for maximum speed
-      SystemNavigationBar.fullScreen(true);
-      SystemNavigationBar.stickyImmersive();
-    }
-  } catch (error) {
-    console.warn('Error locking to landscape:', error);
-  }
-};

package/src/VideoPlayer/utils/player/index.ts

@@ -1,2 +0,0 @@
-export * from './playerEvents';
-export * from './useWatchReporter';

package/src/VideoPlayer/utils/player/playerEvents.ts

@@ -1,97 +0,0 @@
-import type {
-  OnBufferData,
-  OnLoadData,
-  OnLoadStartData,
-  OnProgressData,
-} from 'react-native-video';
-import { mmkvStorage, useVideoPlayerStore } from '../../store/videoPlayerStore';
-
-import { handleNext } from '../video/videoControl';
-import type { MediaEpisode } from '../../store/videoPlayer.type';
-import type { ExtendedWatchProgress } from './useWatchReporter';
-
-export const createPlayerEvents = () => {
-  const onProgress = ({
-    currentTime = 0,
-    playableDuration = 0,
-  }: OnProgressData) => {
-    const store = useVideoPlayerStore.getState();
-    store.setCurrentTime(currentTime);
-    store.setPlayableDuration(playableDuration);
-
-    try {
-      mmkvStorage.setItem('currentTime', String(currentTime));
-    } catch (e) {
-      console.warn('MMKV save failed', e);
-    }
-
-    if (store.isBuffering) store.setIsBuffering(false);
-  };
-
-  const onLoad = (data: OnLoadData) => {
-    const store = useVideoPlayerStore.getState();
-    store.setDuration(data.duration || 0);
-    store.setOnLoad(data);
-
-    mmkvStorage.setItem('current_watch_time', '0');
-
-    store.setError(null);
-    store.setIsViewCounted(false);
-    store.setStartWatchTime(Date.now());
-    store.setIsNextEpisodeVisible(true);
-    store.setIsSkipIntroVisible(true);
-    store.setIsBuffering(false);
-  };
-
-  const onBuffer = ({ isBuffering }: OnBufferData) => {
-    const store = useVideoPlayerStore.getState();
-    if (isBuffering) store.setIsBuffering(true);
-    else setTimeout(() => store.setIsBuffering(false), 150);
-  };
-
-  const onEnd = ({
-    onPressEpisode,
-    reportProgress,
-    autoNext,
-  }: {
-    reportProgress: (event: ExtendedWatchProgress['event']) => void;
-    onPressEpisode: ({
-      episode,
-    }: {
-      episode: MediaEpisode;
-    }) => Promise<boolean>;
-    autoNext: boolean;
-  }) => {
-    reportProgress('COMPLETED');
-    const store = useVideoPlayerStore.getState();
-    if (!store.activeTrack?.isTrailer && store.activeTrack?.type === 'series') {
-      handleNext({ onPressEpisode, autoNext });
-    } else {
-      store.setIsPaused(true);
-    }
-  };
-
-  const onLoadStart = (_: OnLoadStartData) => {
-    const store = useVideoPlayerStore.getState();
-    store.setIsBuffering(true);
-  };
-
-  const LeaveVideoPlayer = () => {
-    const store = useVideoPlayerStore.getState();
-    store.setDuration(0);
-    store.setCurrentTime(0);
-    store.setPlayableDuration(0);
-    store.setIsPaused(false);
-    store.setSettingsModal({ isVisible: false, action: 'none' });
-    store.setIsBuffering(false);
-  };
-
-  return {
-    onProgress,
-    onLoad,
-    onBuffer,
-    onEnd,
-    onLoadStart,
-    LeaveVideoPlayer,
-  };
-};