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

package/src/VideoPlayer/store/videoPlayer.type.ts

@@ -1,214 +0,0 @@
-import {
-  type EnumValues,
-  type OnLoadData,
-  ResizeMode,
-  SelectedVideoTrackType,
-} from 'react-native-video';
-
-export interface BaseEntity {
-  id: string;
-  title: string;
-  contentId: string;
-}
-
-export interface TimeRange {
-  start: number;
-  end: number;
-}
-
-export interface SubtitleTrack {
-  title?: string;
-  language?: string;
-  type:
-    | 'application/x-subrip'
-    | 'application/ttml+xml'
-    | 'text/vtt'
-    | 'application/octet-stream';
-  url: string;
-}
-
-export interface MediaEpisode extends BaseEntity {
-  description: string;
-  duration: number;
-  sourceLink: string;
-  sourceType: 'HLS' | 'MP4';
-  subtitles: SubtitleTrack[];
-  thumbnail: string;
-  episodeNumber: number;
-  skipIntro?: TimeRange | null;
-  nextEpisodeAt?: number | null;
-  publishDate?: string | null;
-}
-
-export interface MediaSeason extends BaseEntity {
-  order: number;
-  seasonNumber?: number;
-  episodes: MediaEpisode[] | null;
-  isActive: boolean;
-  createdBy: string;
-}
-
-export interface MediaTrack extends BaseEntity {
-  description: string;
-  duration: number;
-  thumbnail: string;
-  type: 'movie' | 'series' | 'live_stream' | 'VERTICAL_STREAM';
-  isTrailer?: boolean;
-  sourceType: 'HLS' | 'MP4';
-  sourceLink: string;
-  trailerSource?: string | null;
-  episodeId?: string | null;
-  episodeName?: string | null;
-  episodeNumber?: number | null;
-  seasonId?: string | null;
-  seasonNumber?: number | null;
-  skipIntro?: TimeRange | null;
-  nextEpisodeAt?: number | null;
-  subtitles?: SubtitleTrack[] | null;
-  publishDate?: string | null;
-}
-
-export interface TrackSelection {
-  index?: number;
-  type: string;
-  value: string | number;
-  isExternal: boolean;
-  title?: string;
-  uri?: string;
-  language?: string;
-}
-
-export interface IosTrackResolution {
-  width: number | string | null;
-  height: number | string | null;
-  bandwidth: number;
-}
-
-export type SettingsAction =
-  | 'playbackRate'
-  | 'audioOrSubtitle'
-  | 'settings'
-  | 'episodes'
-  | 'speed'
-  | 'none';
-
-export type AdPosition = 'pre' | 'mid' | 'post';
-
-export interface AdTracking {
-  impression?: string;
-  start?: string;
-  firstQuartile?: string;
-  midpoint?: string;
-  thirdQuartile?: string;
-  complete?: string;
-  skip?: string;
-  click?: string;
-}
-
-export interface VideoAd {
-  id: string;
-  title: string;
-  description: string;
-  position: AdPosition;
-  source: string;
-  duration: number;
-  time?: number;
-  skippable: boolean;
-  skipAfter: number;
-  clickThroughUrl?: string;
-  tracking?: AdTracking;
-}
-
-type StateSetter<T> = (value: T) => void;
-
-export interface VideoPlayerStore {
-  currentTime: number;
-  setCurrentTime: StateSetter<number>;
-
-  duration: number;
-  setDuration: StateSetter<number>;
-
-  isPaused: boolean;
-  setIsPaused: StateSetter<boolean>;
-
-  isBuffering: boolean;
-  setIsBuffering: StateSetter<boolean>;
-
-  resizeMode: EnumValues<ResizeMode>;
-  setResizeMode: StateSetter<EnumValues<ResizeMode>>;
-
-  playableDuration: number;
-  setPlayableDuration: StateSetter<number>;
-
-  onLoad: OnLoadData | null;
-  setOnLoad: StateSetter<OnLoadData>;
-
-  error: string | null;
-  setError: StateSetter<string | null>;
-
-  playBackRate: number;
-  playBackRateLabel: string | null;
-  setPlayBackRate: (rate: number, label: string) => void;
-
-  controlsVisible: boolean;
-  setControlsVisible: StateSetter<boolean>;
-
-  controlsTimer: number;
-  setControlsTimer: StateSetter<number>;
-
-  selectedAudioTrack: TrackSelection | null;
-  setSelectedAudioTrack: StateSetter<TrackSelection | null>;
-
-  selectedSubtitleTrack: TrackSelection | null;
-  setSelectedSubtitleTrack: StateSetter<TrackSelection | null>;
-
-  selectedVideoTrack: { type: SelectedVideoTrackType; value: number } | null;
-  setSelectedVideoTrack: StateSetter<{
-    type: SelectedVideoTrackType;
-    value: number;
-  } | null>;
-
-  activeSubtitle: SubtitleTrack | null;
-  setActiveSubtitle: StateSetter<SubtitleTrack | null>;
-
-  activeTrack: MediaTrack | null;
-  setActiveTrack: StateSetter<MediaTrack | null>;
-
-  playList: MediaTrack[];
-  setPlayList: StateSetter<MediaTrack[]>;
-
-  currentTrackIndex: number;
-  setCurrentTrackIndex: StateSetter<number>;
-
-  contentSeasons: MediaSeason[] | null;
-  setContentSeasons: StateSetter<MediaSeason[] | null>;
-
-  activeSeason: MediaSeason | null;
-  setActiveSeason: StateSetter<MediaSeason | null>;
-
-  settingsModal: {
-    isVisible: boolean;
-    action: SettingsAction;
-  };
-  setSettingsModal: StateSetter<{
-    isVisible: boolean;
-    action: SettingsAction;
-  }>;
-
-  maxBitRate: number | null;
-  setMaxBitRate: StateSetter<number | null>;
-
-  startWatchTime: number | null;
-  setStartWatchTime: StateSetter<number | null>;
-
-  isViewCounted: boolean;
-  setIsViewCounted: StateSetter<boolean>;
-
-  isSkipIntroVisible: boolean;
-  setIsSkipIntroVisible: StateSetter<boolean>;
-
-  isNextEpisodeVisible: boolean;
-  setIsNextEpisodeVisible: StateSetter<boolean>;
-
-  resetStore: () => void;
-}

package/src/VideoPlayer/store/videoPlayerStore.ts

@@ -1,97 +0,0 @@
-import { create } from 'zustand';
-import { createJSONStorage, persist } from 'zustand/middleware';
-import { MMKV } from 'react-native-mmkv';
-import { ResizeMode, type EnumValues } from 'react-native-video';
-import type { SettingsAction, VideoPlayerStore } from './videoPlayer.type';
-
-export const storage = new MMKV({
-  id: 'videoPlayerStorage',
-  encryptionKey: 'videoPlayerKey',
-});
-
-export const mmkvStorage = {
-  setItem: (key: string, value: string) => storage.set(key, value),
-  getItem: (key: string) => storage.getString(key) ?? null,
-  removeItem: (key: string) => storage.delete(key),
-};
-
-const storeDataDefaults = {
-  currentTime: 0,
-  duration: 0,
-  isPaused: false,
-  isBuffering: false,
-  resizeMode: ResizeMode.CONTAIN,
-  controlsVisible: true,
-  controlsTimer: 6,
-  activeTrack: null,
-  playableDuration: 0,
-  settingsModal: { isVisible: false, action: 'none' as SettingsAction },
-  playBackRate: 1,
-  playBackRateLabel: null,
-  onLoad: null,
-  selectedAudioTrack: null,
-  selectedSubtitleTrack: null,
-  selectedVideoTrack: null,
-  activeSubtitle: null,
-  maxBitRate: null,
-  startWatchTime: null,
-  playList: [],
-  currentTrackIndex: 0,
-  contentSeasons: null,
-  activeSeason: null,
-  error: null,
-  isViewCounted: false,
-  isSkipIntroVisible: false,
-  isNextEpisodeVisible: false,
-};
-
-export const useVideoPlayerStore = create<VideoPlayerStore>()(
-  persist(
-    (set) => ({
-      ...storeDataDefaults,
-
-      setCurrentTime: (currentTime) => set({ currentTime }),
-      setDuration: (duration) => set({ duration }),
-      setIsPaused: (isPaused) => set({ isPaused }),
-      setIsBuffering: (isBuffering) => set({ isBuffering }),
-      setResizeMode: (resizeMode: EnumValues<ResizeMode>) =>
-        set({ resizeMode }),
-      setControlsVisible: (controlsVisible) => set({ controlsVisible }),
-      setControlsTimer: (controlsTimer) => set({ controlsTimer }),
-      setActiveTrack: (activeTrack) => set({ activeTrack }),
-      setPlayableDuration: (playableDuration) => set({ playableDuration }),
-      setSettingsModal: ({ isVisible, action }) =>
-        set({ settingsModal: { isVisible, action } }),
-      setPlayBackRate: (playBackRate, playBackRateLabel) =>
-        set({ playBackRate, playBackRateLabel }),
-      setOnLoad: (onLoad) => set({ onLoad }),
-      setSelectedAudioTrack: (selectedAudioTrack) =>
-        set({ selectedAudioTrack }),
-      setSelectedSubtitleTrack: (selectedSubtitleTrack: any) =>
-        set({ selectedSubtitleTrack }),
-      setSelectedVideoTrack: (selectedVideoTrack) =>
-        set({ selectedVideoTrack }),
-      setActiveSubtitle: (activeSubtitle) => set({ activeSubtitle }),
-      setMaxBitRate: (maxBitRate) => set({ maxBitRate }),
-      setStartWatchTime: (startWatchTime) => set({ startWatchTime }),
-      setPlayList: (playList) => set({ playList }),
-      setCurrentTrackIndex: (currentTrackIndex) => set({ currentTrackIndex }),
-      setContentSeasons: (contentSeasons) => set({ contentSeasons }),
-      setActiveSeason: (activeSeason) => set({ activeSeason }),
-      setError: (error) => set({ error }),
-      setIsViewCounted: (isViewCounted) => set({ isViewCounted }),
-      setIsSkipIntroVisible: (isSkipIntroVisible) =>
-        set({ isSkipIntroVisible }),
-      setIsNextEpisodeVisible: (isNextEpisodeVisible) =>
-        set({ isNextEpisodeVisible }),
-      resetStore: () => {
-        set(storeDataDefaults);
-        storage.clearAll();
-      },
-    }),
-    {
-      name: 'VideoPlayerStorage',
-      storage: createJSONStorage(() => mmkvStorage),
-    }
-  )
-);

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;
-};