diff --git a/components/AndroidVideoPlayer.tsx b/components/AndroidVideoPlayer.tsx
new file mode 100644
index 000000000..8865071ae
--- /dev/null
+++ b/components/AndroidVideoPlayer.tsx
@@ -0,0 +1,119 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { Platform } from 'react-native';
+import Video, { VideoRef, SelectedTrack, BufferingStrategyType } from 'react-native-video';
+
+interface VideoPlayerProps {
+  src: string;
+  paused: boolean;
+  volume: number;
+  currentTime: number;
+  selectedAudioTrack?: SelectedTrack;
+  selectedTextTrack?: SelectedTrack;
+  onProgress?: (data: { currentTime: number; playableDuration: number }) => void;
+  onLoad?: (data: { duration: number }) => void;
+  onError?: (error: any) => void;
+  onBuffer?: (data: { isBuffering: boolean }) => void;
+  onSeek?: (data: { currentTime: number; seekTime: number }) => void;
+  onEnd?: () => void;
+}
+
+export const AndroidVideoPlayer: React.FC<VideoPlayerProps> = ({
+  src,
+  paused,
+  volume,
+  currentTime,
+  selectedAudioTrack,
+  selectedTextTrack,
+  onProgress,
+  onLoad,
+  onError,
+  onBuffer,
+  onSeek,
+  onEnd,
+}) => {
+  const videoRef = useRef<VideoRef>(null);
+  const [isLoaded, setIsLoaded] = useState(false);
+  const [isSeeking, setIsSeeking] = useState(false);
+  const [lastSeekTime, setLastSeekTime] = useState<number>(0);
+
+  // Only render on Android
+  if (Platform.OS !== 'android') {
+    return null;
+  }
+
+  useEffect(() => {
+    if (isLoaded && !isSeeking && Math.abs(currentTime - lastSeekTime) > 1) {
+      setIsSeeking(true);
+      videoRef.current?.seek(currentTime);
+      setLastSeekTime(currentTime);
+    }
+  }, [currentTime, isLoaded, isSeeking, lastSeekTime]);
+
+  const handleLoad = (data: any) => {
+    setIsLoaded(true);
+    onLoad?.(data);
+  };
+
+  const handleProgress = (data: any) => {
+    if (!isSeeking) {
+      onProgress?.(data);
+    }
+  };
+
+  const handleSeek = (data: any) => {
+    setIsSeeking(false);
+    onSeek?.(data);
+  };
+
+  const handleBuffer = (data: any) => {
+    onBuffer?.(data);
+  };
+
+  const handleError = (error: any) => {
+    console.error('Video playback error:', error);
+    onError?.(error);
+  };
+
+  const handleEnd = () => {
+    onEnd?.();
+  };
+
+  return (
+    <Video
+      ref={videoRef}
+      source={{ uri: src }}
+      style={{ flex: 1 }}
+      paused={paused}
+      volume={volume}
+      selectedAudioTrack={selectedAudioTrack}
+      selectedTextTrack={selectedTextTrack}
+      onLoad={handleLoad}
+      onProgress={handleProgress}
+      onSeek={handleSeek}
+      onBuffer={handleBuffer}
+      onError={handleError}
+      onEnd={handleEnd}
+      resizeMode="contain"
+      controls={false}
+      playInBackground={false}
+      playWhenInactive={false}
+      progressUpdateInterval={250}
+      allowsExternalPlayback={false}
+      bufferingStrategy={BufferingStrategyType.DEFAULT}
+      ignoreSilentSwitch="ignore"
+      mixWithOthers="inherit"
+      rate={1.0}
+      repeat={false}
+      reportBandwidth={true}
+      textTracks={[]}
+      useTextureView={false}
+      disableFocus={false}
+      minLoadRetryCount={3}
+      automaticallyWaitsToMinimizeStalling={true}
+      hideShutterView={false}
+      shutterColor="#000000"
+    />
+  );
+};
+
+export default AndroidVideoPlayer; 
\ No newline at end of file
diff --git a/package.json b/package.json
index 2fef212a2..6aae894c8 100644
--- a/package.json
+++ b/package.json
@@ -27,6 +27,8 @@
     "@types/react-native-video": "^5.0.20",
     "axios": "^1.10.0",
     "base64-js": "^1.5.1",
+    "cheerio": "^1.1.0",
+    "cors": "^2.8.5",
     "date-fns": "^4.1.0",
     "eventemitter3": "^5.0.1",
     "expo": "~52.0.43",
@@ -44,8 +46,10 @@
     "expo-status-bar": "~2.0.1",
     "expo-system-ui": "^4.0.9",
     "expo-web-browser": "~14.0.2",
+    "express": "^5.1.0",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
+    "puppeteer": "^24.10.1",
     "react": "18.3.1",
     "react-native": "0.76.9",
     "react-native-awesome-slider": "^2.9.0",
diff --git a/src/components/player/AndroidVideoPlayer.tsx b/src/components/player/AndroidVideoPlayer.tsx
new file mode 100644
index 000000000..b1d89e56f
--- /dev/null
+++ b/src/components/player/AndroidVideoPlayer.tsx
@@ -0,0 +1,1067 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { View, TouchableOpacity, Dimensions, Animated, ActivityIndicator, Platform, NativeModules, StatusBar, Text } from 'react-native';
+import Video, { VideoRef, SelectedTrack, SelectedTrackType, BufferingStrategyType } from 'react-native-video';
+import { useNavigation, useRoute, RouteProp } from '@react-navigation/native';
+import { RootStackParamList } from '../../navigation/AppNavigator';
+import { PinchGestureHandler, State, PinchGestureHandlerGestureEvent } from 'react-native-gesture-handler';
+import RNImmersiveMode from 'react-native-immersive-mode';
+import * as ScreenOrientation from 'expo-screen-orientation';
+import { storageService } from '../../services/storageService';
+import { logger } from '../../utils/logger';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { MaterialIcons } from '@expo/vector-icons';
+
+import { 
+  DEFAULT_SUBTITLE_SIZE, 
+  AudioTrack,
+  TextTrack,
+  ResizeModeType, 
+  WyzieSubtitle, 
+  SubtitleCue,
+  RESUME_PREF_KEY,
+  RESUME_PREF,
+  SUBTITLE_SIZE_KEY
+} from './utils/playerTypes';
+import { safeDebugLog, parseSRT, DEBUG_MODE, formatTime } from './utils/playerUtils';
+import { styles } from './utils/playerStyles';
+import SubtitleModals from './modals/SubtitleModals';
+import AudioTrackModal from './modals/AudioTrackModal';
+import ResumeOverlay from './modals/ResumeOverlay';
+import PlayerControls from './controls/PlayerControls';
+import CustomSubtitles from './subtitles/CustomSubtitles';
+import SourcesModal from './modals/SourcesModal';
+
+// Map VLC resize modes to react-native-video resize modes
+const getVideoResizeMode = (resizeMode: ResizeModeType) => {
+  switch (resizeMode) {
+    case 'contain': return 'contain';
+    case 'cover': return 'cover';
+    case 'stretch': return 'stretch';
+    case 'none': return 'contain';
+    default: return 'contain';
+  }
+};
+
+const AndroidVideoPlayer: React.FC = () => {
+  const navigation = useNavigation();
+  const route = useRoute<RouteProp<RootStackParamList, 'Player'>>();
+  
+  const {
+    uri,
+    title = 'Episode Name',
+    season,
+    episode,
+    episodeTitle,
+    quality,
+    year,
+    streamProvider,
+    streamName,
+    id,
+    type,
+    episodeId,
+    imdbId,
+    availableStreams: passedAvailableStreams
+  } = route.params;
+
+  safeDebugLog("Android Component mounted with props", {
+    uri, title, season, episode, episodeTitle, quality, year,
+    streamProvider, id, type, episodeId, imdbId
+  });
+
+  const screenData = Dimensions.get('screen');
+  const [screenDimensions, setScreenDimensions] = useState(screenData);
+
+  const [paused, setPaused] = useState(false);
+  const [currentTime, setCurrentTime] = useState(0);
+  const [duration, setDuration] = useState(0);
+  const [showControls, setShowControls] = useState(true);
+  const [audioTracks, setAudioTracks] = useState<AudioTrack[]>([]);
+  const [selectedAudioTrack, setSelectedAudioTrack] = useState<number | null>(null);
+  const [textTracks, setTextTracks] = useState<TextTrack[]>([]);
+  const [selectedTextTrack, setSelectedTextTrack] = useState<number>(-1);
+  const [resizeMode, setResizeMode] = useState<ResizeModeType>('stretch');
+  const [buffered, setBuffered] = useState(0);
+  const [seekTime, setSeekTime] = useState<number | null>(null);
+  const videoRef = useRef<VideoRef>(null);
+  const [showAudioModal, setShowAudioModal] = useState(false);
+  const [showSubtitleModal, setShowSubtitleModal] = useState(false);
+  const [initialPosition, setInitialPosition] = useState<number | null>(null);
+  const [progressSaveInterval, setProgressSaveInterval] = useState<NodeJS.Timeout | null>(null);
+  const [isInitialSeekComplete, setIsInitialSeekComplete] = useState(false);
+  const [showResumeOverlay, setShowResumeOverlay] = useState(false);
+  const [resumePosition, setResumePosition] = useState<number | null>(null);
+  const [rememberChoice, setRememberChoice] = useState(false);
+  const [resumePreference, setResumePreference] = useState<string | null>(null);
+  const fadeAnim = useRef(new Animated.Value(1)).current;
+  const [isOpeningAnimationComplete, setIsOpeningAnimationComplete] = useState(false);
+  const openingFadeAnim = useRef(new Animated.Value(0)).current;
+  const openingScaleAnim = useRef(new Animated.Value(0.8)).current;
+  const backgroundFadeAnim = useRef(new Animated.Value(1)).current;
+  const [isBuffering, setIsBuffering] = useState(false);
+  const [rnVideoAudioTracks, setRnVideoAudioTracks] = useState<Array<{id: number, name: string, language?: string}>>([]);
+  const [rnVideoTextTracks, setRnVideoTextTracks] = useState<Array<{id: number, name: string, language?: string}>>([]);
+  const [isPlayerReady, setIsPlayerReady] = useState(false);
+  const progressAnim = useRef(new Animated.Value(0)).current;
+  const progressBarRef = useRef<View>(null);
+  const [isDragging, setIsDragging] = useState(false);
+  const isSeeking = useRef(false);
+  const seekDebounceTimer = useRef<NodeJS.Timeout | null>(null);
+  const pendingSeekValue = useRef<number | null>(null);
+  const lastSeekTime = useRef<number>(0);
+  const [isVideoLoaded, setIsVideoLoaded] = useState(false);
+  const [videoAspectRatio, setVideoAspectRatio] = useState<number | null>(null);
+  const [is16by9Content, setIs16by9Content] = useState(false);
+  const [customVideoStyles, setCustomVideoStyles] = useState<any>({});
+  const [zoomScale, setZoomScale] = useState(1);
+  const [zoomTranslateX, setZoomTranslateX] = useState(0);
+  const [zoomTranslateY, setZoomTranslateY] = useState(0);
+  const [lastZoomScale, setLastZoomScale] = useState(1);
+  const [lastTranslateX, setLastTranslateX] = useState(0);
+  const [lastTranslateY, setLastTranslateY] = useState(0);
+  const pinchRef = useRef<PinchGestureHandler>(null);
+  const [customSubtitles, setCustomSubtitles] = useState<SubtitleCue[]>([]);
+  const [currentSubtitle, setCurrentSubtitle] = useState<string>('');
+  const [subtitleSize, setSubtitleSize] = useState<number>(DEFAULT_SUBTITLE_SIZE);
+  const [useCustomSubtitles, setUseCustomSubtitles] = useState<boolean>(false);
+  const [isLoadingSubtitles, setIsLoadingSubtitles] = useState<boolean>(false);
+  const [availableSubtitles, setAvailableSubtitles] = useState<WyzieSubtitle[]>([]);
+  const [showSubtitleLanguageModal, setShowSubtitleLanguageModal] = useState<boolean>(false);
+  const [isLoadingSubtitleList, setIsLoadingSubtitleList] = useState<boolean>(false);
+  const [showSourcesModal, setShowSourcesModal] = useState<boolean>(false);
+  const [availableStreams, setAvailableStreams] = useState<{ [providerId: string]: { streams: any[]; addonName: string } }>(passedAvailableStreams || {});
+  const [currentStreamUrl, setCurrentStreamUrl] = useState<string>(uri);
+  const [isChangingSource, setIsChangingSource] = useState<boolean>(false);
+  const [pendingSeek, setPendingSeek] = useState<{ position: number; shouldPlay: boolean } | null>(null);
+  const [currentQuality, setCurrentQuality] = useState<string | undefined>(quality);
+  const [currentStreamProvider, setCurrentStreamProvider] = useState<string | undefined>(streamProvider);
+  const [currentStreamName, setCurrentStreamName] = useState<string | undefined>(streamName);
+  const isMounted = useRef(true);
+
+  const calculateVideoStyles = (videoWidth: number, videoHeight: number, screenWidth: number, screenHeight: number) => {
+    return {
+      position: 'absolute',
+      top: 0,
+      left: 0,
+      width: screenWidth,
+      height: screenHeight,
+    };
+  };
+
+  const onPinchGestureEvent = (event: PinchGestureHandlerGestureEvent) => {
+    const { scale } = event.nativeEvent;
+    const newScale = Math.max(1, Math.min(lastZoomScale * scale, 1.1));
+    setZoomScale(newScale);
+    if (DEBUG_MODE) {
+      logger.log(`[AndroidVideoPlayer] Center Zoom: ${newScale.toFixed(2)}x`);
+    }
+  };
+
+  const onPinchHandlerStateChange = (event: PinchGestureHandlerGestureEvent) => {
+    if (event.nativeEvent.state === State.END) {
+      setLastZoomScale(zoomScale);
+      if (DEBUG_MODE) {
+        logger.log(`[AndroidVideoPlayer] Pinch ended - saved scale: ${zoomScale.toFixed(2)}x`);
+      }
+    }
+  };
+
+  const resetZoom = () => {
+    const targetZoom = is16by9Content ? 1.1 : 1;
+    setZoomScale(targetZoom);
+    setLastZoomScale(targetZoom);
+    if (DEBUG_MODE) {
+      logger.log(`[AndroidVideoPlayer] Zoom reset to ${targetZoom}x (16:9: ${is16by9Content})`);
+    }
+  };
+
+  useEffect(() => {
+    if (videoAspectRatio && screenDimensions.width > 0 && screenDimensions.height > 0) {
+      const styles = calculateVideoStyles(
+        videoAspectRatio * 1000,
+        1000,
+        screenDimensions.width,
+        screenDimensions.height
+      );
+      setCustomVideoStyles(styles);
+      if (DEBUG_MODE) {
+        logger.log(`[AndroidVideoPlayer] Screen dimensions changed, recalculated styles:`, styles);
+      }
+    }
+  }, [screenDimensions, videoAspectRatio]);
+
+  useEffect(() => {
+    const subscription = Dimensions.addEventListener('change', ({ screen }) => {
+      setScreenDimensions(screen);
+    });
+    const initializePlayer = () => {
+      StatusBar.setHidden(true, 'none');
+      enableImmersiveMode();
+      startOpeningAnimation();
+    };
+    initializePlayer();
+    return () => {
+      subscription?.remove();
+      const unlockOrientation = async () => {
+        await ScreenOrientation.unlockAsync();
+      };
+      unlockOrientation();
+      disableImmersiveMode();
+    };
+  }, []);
+
+  const startOpeningAnimation = () => {
+    // Animation logic here
+  };
+
+  const completeOpeningAnimation = () => {
+    Animated.parallel([
+      Animated.timing(openingFadeAnim, {
+        toValue: 1,
+        duration: 600,
+        useNativeDriver: true,
+      }),
+      Animated.timing(openingScaleAnim, {
+        toValue: 1,
+        duration: 700,
+        useNativeDriver: true,
+      }),
+      Animated.timing(backgroundFadeAnim, {
+        toValue: 0,
+        duration: 800,
+        useNativeDriver: true,
+      }),
+    ]).start(() => {
+      openingScaleAnim.setValue(1);
+      openingFadeAnim.setValue(1);
+      setIsOpeningAnimationComplete(true);
+      setTimeout(() => {
+        backgroundFadeAnim.setValue(0);
+      }, 100);
+    });
+  };
+
+  useEffect(() => {
+    const loadWatchProgress = async () => {
+      if (id && type) {
+        try {
+          const savedProgress = await storageService.getWatchProgress(id, type, episodeId);
+          if (savedProgress) {
+            const progressPercent = (savedProgress.currentTime / savedProgress.duration) * 100;
+            if (progressPercent < 95) {
+              setResumePosition(savedProgress.currentTime);
+              const pref = await AsyncStorage.getItem(RESUME_PREF_KEY);
+              if (pref === RESUME_PREF.ALWAYS_RESUME) {
+                setInitialPosition(savedProgress.currentTime);
+              } else if (pref === RESUME_PREF.ALWAYS_START_OVER) {
+                setInitialPosition(0);
+              } else {
+                setShowResumeOverlay(true);
+              }
+            }
+          }
+        } catch (error) {
+          logger.error('[AndroidVideoPlayer] Error loading watch progress:', error);
+        }
+      }
+    };
+    loadWatchProgress();
+  }, [id, type, episodeId]);
+
+  const saveWatchProgress = async () => {
+    if (id && type && currentTime > 0 && duration > 0) {
+      const progress = {
+        currentTime,
+        duration,
+        lastUpdated: Date.now()
+      };
+      try {
+        await storageService.setWatchProgress(id, type, progress, episodeId);
+      } catch (error) {
+        logger.error('[AndroidVideoPlayer] Error saving watch progress:', error);
+      }
+    }
+  };
+    
+  useEffect(() => {
+    if (id && type && !paused && duration > 0) {
+      if (progressSaveInterval) {
+        clearInterval(progressSaveInterval);
+      }
+      const interval = setInterval(() => {
+        saveWatchProgress();
+      }, 5000);
+      setProgressSaveInterval(interval);
+      return () => {
+        clearInterval(interval);
+        setProgressSaveInterval(null);
+      };
+    }
+  }, [id, type, paused, currentTime, duration]);
+
+  useEffect(() => {
+    return () => {
+      if (id && type && duration > 0) {
+        saveWatchProgress();
+      }
+    };
+  }, [id, type, currentTime, duration]);
+
+  const seekToTime = (timeInSeconds: number) => {
+    if (videoRef.current && duration > 0 && !isSeeking.current) {
+      if (DEBUG_MODE) {
+        logger.log(`[AndroidVideoPlayer] Seeking to ${timeInSeconds.toFixed(2)}s`);
+      }
+      
+      isSeeking.current = true;
+      setSeekTime(timeInSeconds);
+      
+      // Clear seek state after seek
+      setTimeout(() => {
+        if (isMounted.current) {
+          setSeekTime(null);
+          isSeeking.current = false;
+        }
+      }, 100);
+    } else {
+      if (DEBUG_MODE) {
+        logger.error('[AndroidVideoPlayer] Seek failed: Player not ready, duration is zero, or already seeking.');
+      }
+    }
+  };
+
+  // Handle seeking when seekTime changes
+  useEffect(() => {
+    if (seekTime !== null && videoRef.current && duration > 0) {
+      videoRef.current.seek(seekTime);
+    }
+  }, [seekTime, duration]);
+
+  const handleProgressBarTouch = (event: any) => {
+    if (duration > 0) {
+      const { locationX } = event.nativeEvent;
+      processProgressTouch(locationX);
+    }
+  };
+  
+  const handleProgressBarDragStart = () => {
+    setIsDragging(true);
+  };
+  
+  const handleProgressBarDragMove = (event: any) => {
+    if (!isDragging || !duration || duration <= 0) return;
+    const { locationX } = event.nativeEvent;
+    processProgressTouch(locationX, true);
+  };
+  
+  const handleProgressBarDragEnd = () => {
+    setIsDragging(false);
+    if (pendingSeekValue.current !== null) {
+      seekToTime(pendingSeekValue.current);
+      pendingSeekValue.current = null;
+    }
+  };
+  
+  const processProgressTouch = (locationX: number, isDragging = false) => {
+    progressBarRef.current?.measure((x, y, width, height, pageX, pageY) => {
+      const percentage = Math.max(0, Math.min(locationX / width, 1));
+      const seekTime = percentage * duration;
+      progressAnim.setValue(percentage);
+      if (isDragging) {
+        pendingSeekValue.current = seekTime;
+        setCurrentTime(seekTime);
+      } else {
+        seekToTime(seekTime);
+      }
+    });
+  };
+
+  const handleProgress = (data: any) => {
+    if (isDragging || isSeeking.current) return;
+    
+    const currentTimeInSeconds = data.currentTime;
+    
+    // Only update if there's a significant change to avoid unnecessary updates
+    if (Math.abs(currentTimeInSeconds - currentTime) > 0.5) {
+      safeSetState(() => setCurrentTime(currentTimeInSeconds));
+      const progressPercent = duration > 0 ? currentTimeInSeconds / duration : 0;
+      Animated.timing(progressAnim, {
+        toValue: progressPercent,
+        duration: 250,
+        useNativeDriver: false,
+      }).start();
+      const bufferedTime = data.playableDuration || currentTimeInSeconds;
+      safeSetState(() => setBuffered(bufferedTime));
+    }
+  };
+
+  const onLoad = (data: any) => {
+    if (DEBUG_MODE) {
+      logger.log('[AndroidVideoPlayer] Video loaded:', data);
+    }
+    if (isMounted.current) {
+      if (data.duration > 0) {
+        setDuration(data.duration);
+      }
+      
+      // Set aspect ratio from video dimensions
+      if (data.naturalSize && data.naturalSize.width && data.naturalSize.height) {
+        setVideoAspectRatio(data.naturalSize.width / data.naturalSize.height);
+      }
+
+      // Handle audio tracks
+      if (data.audioTracks && data.audioTracks.length > 0) {
+        const formattedAudioTracks = data.audioTracks.map((track: any, index: number) => ({
+          id: track.index || index,
+          name: track.title || track.language || `Audio ${index + 1}`,
+          language: track.language,
+        }));
+        setRnVideoAudioTracks(formattedAudioTracks);
+      }
+
+      // Handle text tracks
+      if (data.textTracks && data.textTracks.length > 0) {
+        const formattedTextTracks = data.textTracks.map((track: any, index: number) => ({
+          id: track.index || index,
+          name: track.title || track.language || `Subtitle ${index + 1}`,
+          language: track.language,
+        }));
+        setRnVideoTextTracks(formattedTextTracks);
+      }
+
+      setIsVideoLoaded(true);
+      setIsPlayerReady(true);
+      
+      if (initialPosition && !isInitialSeekComplete) {
+        setTimeout(() => {
+          if (videoRef.current && duration > 0 && isMounted.current) {
+            seekToTime(initialPosition);
+            setIsInitialSeekComplete(true);
+          }
+        }, 1000);
+      }
+      completeOpeningAnimation();
+    }
+  };
+
+  const skip = (seconds: number) => {
+    if (videoRef.current) {
+      const newTime = Math.max(0, Math.min(currentTime + seconds, duration));
+      seekToTime(newTime);
+    }
+  };
+
+  const cycleAspectRatio = () => {
+    const newZoom = zoomScale === 1.1 ? 1 : 1.1;
+    setZoomScale(newZoom);
+    setZoomTranslateX(0);
+    setZoomTranslateY(0);
+    setLastZoomScale(newZoom);
+    setLastTranslateX(0);
+    setLastTranslateY(0);
+  };
+
+  const enableImmersiveMode = () => {
+    StatusBar.setHidden(true, 'none');
+    if (Platform.OS === 'android') {
+      try {
+        RNImmersiveMode.setBarMode('FullSticky');
+        RNImmersiveMode.fullLayout(true);
+        if (NativeModules.StatusBarManager) {
+          NativeModules.StatusBarManager.setHidden(true);
+        }
+      } catch (error) {
+        console.log('Immersive mode error:', error);
+      }
+    }
+  };
+
+  const disableImmersiveMode = () => {
+    StatusBar.setHidden(false);
+    if (Platform.OS === 'android') {
+      RNImmersiveMode.setBarMode('Normal');
+      RNImmersiveMode.fullLayout(false);
+    }
+  };
+
+  const handleClose = () => {
+    // Start exit animation
+    Animated.parallel([
+      Animated.timing(fadeAnim, {
+        toValue: 0,
+        duration: 150,
+        useNativeDriver: true,
+      }),
+      Animated.timing(openingFadeAnim, {
+        toValue: 0,
+        duration: 150,
+        useNativeDriver: true,
+      }),
+    ]).start();
+
+    // Small delay to allow animation to start, then unlock orientation and navigate
+    setTimeout(() => {
+      ScreenOrientation.unlockAsync().then(() => {
+        disableImmersiveMode();
+        navigation.goBack();
+      }).catch(() => {
+        // Fallback: navigate even if orientation unlock fails
+        disableImmersiveMode();
+        navigation.goBack();
+      });
+    }, 100);
+  };
+    
+  useEffect(() => {
+    const loadResumePreference = async () => {
+      try {
+        const pref = await AsyncStorage.getItem(RESUME_PREF_KEY);
+        if (pref) {
+          setResumePreference(pref);
+          if (pref === RESUME_PREF.ALWAYS_RESUME && resumePosition !== null) {
+            setShowResumeOverlay(false);
+            setInitialPosition(resumePosition);
+          } else if (pref === RESUME_PREF.ALWAYS_START_OVER) {
+            setShowResumeOverlay(false);
+            setInitialPosition(0);
+          }
+        }
+      } catch (error) {
+        logger.error('[AndroidVideoPlayer] Error loading resume preference:', error);
+      }
+    };
+    loadResumePreference();
+  }, [resumePosition]);
+
+  const resetResumePreference = async () => {
+    try {
+      await AsyncStorage.removeItem(RESUME_PREF_KEY);
+      setResumePreference(null);
+    } catch (error) {
+      logger.error('[AndroidVideoPlayer] Error resetting resume preference:', error);
+    }
+  };
+
+  const handleResume = async () => {
+    if (resumePosition !== null && videoRef.current) {
+      if (rememberChoice) {
+        try {
+          await AsyncStorage.setItem(RESUME_PREF_KEY, RESUME_PREF.ALWAYS_RESUME);
+        } catch (error) {
+          logger.error('[AndroidVideoPlayer] Error saving resume preference:', error);
+        }
+      }
+      setInitialPosition(resumePosition);
+      setShowResumeOverlay(false);
+      setTimeout(() => {
+        if (videoRef.current) {
+          seekToTime(resumePosition);
+        }
+      }, 500);
+    }
+  };
+
+  const handleStartFromBeginning = async () => {
+    if (rememberChoice) {
+      try {
+        await AsyncStorage.setItem(RESUME_PREF_KEY, RESUME_PREF.ALWAYS_START_OVER);
+      } catch (error) {
+        logger.error('[AndroidVideoPlayer] Error saving resume preference:', error);
+      }
+    }
+    setShowResumeOverlay(false);
+    setInitialPosition(0);
+    if (videoRef.current) {
+      seekToTime(0);
+      setCurrentTime(0);
+    }
+  };
+
+  const toggleControls = () => {
+    setShowControls(previousState => !previousState);
+  };
+
+  useEffect(() => {
+    Animated.timing(fadeAnim, {
+      toValue: showControls ? 1 : 0,
+      duration: 300,
+      useNativeDriver: true,
+    }).start();
+  }, [showControls]);
+
+  const handleError = (error: any) => {
+    logger.error('[AndroidVideoPlayer] Playback Error:', error);
+  };
+
+  const onBuffer = (data: any) => {
+    setIsBuffering(data.isBuffering);
+  };
+
+  const onEnd = () => {
+    // End logic here
+  };
+
+  const selectAudioTrack = (trackId: number) => {
+    setSelectedAudioTrack(trackId);
+  };
+
+  const selectTextTrack = (trackId: number) => {
+    if (trackId === -999) {
+      setUseCustomSubtitles(true);
+      setSelectedTextTrack(-1);
+    } else {
+      setUseCustomSubtitles(false);
+      setSelectedTextTrack(trackId);
+    }
+  };
+  
+  const loadSubtitleSize = async () => {
+    try {
+      const savedSize = await AsyncStorage.getItem(SUBTITLE_SIZE_KEY);
+      if (savedSize) {
+        setSubtitleSize(parseInt(savedSize, 10));
+      }
+    } catch (error) {
+      logger.error('[AndroidVideoPlayer] Error loading subtitle size:', error);
+    }
+  };
+
+  const saveSubtitleSize = async (size: number) => {
+    try {
+      await AsyncStorage.setItem(SUBTITLE_SIZE_KEY, size.toString());
+      setSubtitleSize(size);
+    } catch (error) {
+      logger.error('[AndroidVideoPlayer] Error saving subtitle size:', error);
+    }
+  };
+
+  const fetchAvailableSubtitles = async (imdbIdParam?: string, autoSelectEnglish = false) => {
+    const targetImdbId = imdbIdParam || imdbId;
+    if (!targetImdbId) {
+      logger.error('[AndroidVideoPlayer] No IMDb ID available for subtitle search');
+      return;
+    }
+    setIsLoadingSubtitleList(true);
+    try {
+      let searchUrl = `https://sub.wyzie.ru/search?id=${targetImdbId}&encoding=utf-8&source=all`;
+      if (season && episode) {
+        searchUrl += `&season=${season}&episode=${episode}`;
+      }
+      const response = await fetch(searchUrl);
+      const subtitles: WyzieSubtitle[] = await response.json();
+      const uniqueSubtitles = subtitles.reduce((acc, current) => {
+        const exists = acc.find(item => item.language === current.language);
+        if (!exists) {
+          acc.push(current);
+        }
+        return acc;
+      }, [] as WyzieSubtitle[]);
+      uniqueSubtitles.sort((a, b) => a.display.localeCompare(b.display));
+      setAvailableSubtitles(uniqueSubtitles);
+      if (autoSelectEnglish) {
+        const englishSubtitle = uniqueSubtitles.find(sub => 
+          sub.language.toLowerCase() === 'eng' || 
+          sub.language.toLowerCase() === 'en' ||
+          sub.display.toLowerCase().includes('english')
+        );
+        if (englishSubtitle) {
+          loadWyzieSubtitle(englishSubtitle);
+          return;
+        }
+      }
+      if (!autoSelectEnglish) {
+        setShowSubtitleLanguageModal(true);
+      }
+    } catch (error) {
+      logger.error('[AndroidVideoPlayer] Error fetching subtitles from Wyzie API:', error);
+    } finally {
+      setIsLoadingSubtitleList(false);
+    }
+  };
+
+  const loadWyzieSubtitle = async (subtitle: WyzieSubtitle) => {
+    setShowSubtitleLanguageModal(false);
+    setIsLoadingSubtitles(true);
+    try {
+      const response = await fetch(subtitle.url);
+      const srtContent = await response.text();
+      const parsedCues = parseSRT(srtContent);
+      setCustomSubtitles(parsedCues);
+      setUseCustomSubtitles(true);
+      setSelectedTextTrack(-1);
+    } catch (error) {
+      logger.error('[AndroidVideoPlayer] Error loading Wyzie subtitle:', error);
+    } finally {
+      setIsLoadingSubtitles(false);
+    }
+  };
+    
+  const togglePlayback = () => {
+    if (videoRef.current) {
+        setPaused(!paused);
+    }
+  };
+
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+      if (seekDebounceTimer.current) {
+        clearTimeout(seekDebounceTimer.current);
+      }
+    };
+  }, []);
+  
+  const safeSetState = (setter: any) => {
+    if (isMounted.current) {
+      setter();
+    }
+  };
+
+  useEffect(() => {
+    if (!useCustomSubtitles || customSubtitles.length === 0) {
+      if (currentSubtitle !== '') {
+        setCurrentSubtitle('');
+      }
+      return;
+    }
+    const currentCue = customSubtitles.find(cue => 
+      currentTime >= cue.start && currentTime <= cue.end
+    );
+    const newSubtitle = currentCue ? currentCue.text : '';
+    setCurrentSubtitle(newSubtitle);
+  }, [currentTime, customSubtitles, useCustomSubtitles]);
+
+  useEffect(() => {
+    loadSubtitleSize();
+  }, []);
+
+  const increaseSubtitleSize = () => {
+    const newSize = Math.min(subtitleSize + 2, 32);
+    saveSubtitleSize(newSize);
+  };
+
+  const decreaseSubtitleSize = () => {
+    const newSize = Math.max(subtitleSize - 2, 8);
+    saveSubtitleSize(newSize);
+  };
+
+  useEffect(() => {
+    if (pendingSeek && isPlayerReady && isVideoLoaded && duration > 0) {
+      logger.log(`[AndroidVideoPlayer] Player ready after source change, seeking to position: ${pendingSeek.position}s out of ${duration}s total`);
+      
+      if (pendingSeek.position > 0 && videoRef.current) {
+        const delayTime = 800; // Shorter delay for react-native-video
+        
+        setTimeout(() => {
+          if (videoRef.current && duration > 0 && pendingSeek) {
+            logger.log(`[AndroidVideoPlayer] Executing seek to ${pendingSeek.position}s`);
+            
+            seekToTime(pendingSeek.position);
+            
+            if (pendingSeek.shouldPlay) {
+              setTimeout(() => {
+                logger.log('[AndroidVideoPlayer] Resuming playback after source change seek');
+                setPaused(false);
+              }, 300);
+            }
+            
+            setTimeout(() => {
+              setPendingSeek(null);
+              setIsChangingSource(false);
+            }, 400);
+          }
+        }, delayTime);
+      } else {
+        // No seeking needed, just resume playback if it was playing
+        if (pendingSeek.shouldPlay) {
+          setTimeout(() => {
+            logger.log('[AndroidVideoPlayer] No seek needed, just resuming playback');
+            setPaused(false);
+          }, 300);
+        }
+        
+        setTimeout(() => {
+          setPendingSeek(null);
+          setIsChangingSource(false);
+        }, 400);
+      }
+    }
+  }, [pendingSeek, isPlayerReady, isVideoLoaded, duration]);
+
+  const handleSelectStream = async (newStream: any) => {
+    if (newStream.url === currentStreamUrl) {
+      setShowSourcesModal(false);
+      return;
+    }
+
+    setIsChangingSource(true);
+    setShowSourcesModal(false);
+    
+    try {
+      // Save current state
+      const savedPosition = currentTime;
+      const wasPlaying = !paused;
+      
+      logger.log(`[AndroidVideoPlayer] Changing source from ${currentStreamUrl} to ${newStream.url}`);
+      logger.log(`[AndroidVideoPlayer] Saved position: ${savedPosition}, was playing: ${wasPlaying}`);
+      
+      // Extract quality and provider information from the new stream
+      let newQuality = newStream.quality;
+      if (!newQuality && newStream.title) {
+        // Try to extract quality from title (e.g., "1080p", "720p")
+        const qualityMatch = newStream.title.match(/(\d+)p/);
+        newQuality = qualityMatch ? qualityMatch[0] : undefined;
+      }
+      
+      // For provider, try multiple fields
+      const newProvider = newStream.addonName || newStream.name || newStream.addon || 'Unknown';
+      
+      // For stream name, prioritize the stream name over title
+      const newStreamName = newStream.name || newStream.title || 'Unknown Stream';
+      
+      logger.log(`[AndroidVideoPlayer] Stream object:`, newStream);
+      logger.log(`[AndroidVideoPlayer] Extracted - Quality: ${newQuality}, Provider: ${newProvider}, Stream Name: ${newStreamName}`);
+      
+      // Stop current playback
+      setPaused(true);
+      
+      // Set pending seek state
+      setPendingSeek({ position: savedPosition, shouldPlay: wasPlaying });
+      
+      // Update the stream URL and details immediately
+      setCurrentStreamUrl(newStream.url);
+      setCurrentQuality(newQuality);
+      setCurrentStreamProvider(newProvider);
+      setCurrentStreamName(newStreamName);
+      
+      // Reset player state for new source
+      setCurrentTime(0);
+      setDuration(0);
+      setIsPlayerReady(false);
+      setIsVideoLoaded(false);
+      
+    } catch (error) {
+      logger.error('[AndroidVideoPlayer] Error changing source:', error);
+      setPendingSeek(null);
+      setIsChangingSource(false);
+    }
+  };
+
+  return (
+    <View style={[styles.container, {
+      width: screenDimensions.width,
+      height: screenDimensions.height,
+      position: 'absolute',
+      top: 0,
+      left: 0,
+    }]}> 
+      <Animated.View 
+        style={[
+          styles.openingOverlay,
+          {
+            opacity: backgroundFadeAnim,
+            zIndex: isOpeningAnimationComplete ? -1 : 3000,
+            width: screenDimensions.width,
+            height: screenDimensions.height,
+          }
+        ]}
+        pointerEvents={isOpeningAnimationComplete ? 'none' : 'auto'}
+      >
+        <TouchableOpacity 
+          style={styles.loadingCloseButton}
+          onPress={handleClose}
+          activeOpacity={0.7}
+        >
+          <MaterialIcons name="close" size={24} color="#ffffff" />
+        </TouchableOpacity>
+        
+        <View style={styles.openingContent}>
+          <ActivityIndicator size="large" color="#E50914" />
+          <Text style={styles.openingText}>Loading video...</Text>
+        </View>
+      </Animated.View>
+
+      {/* Source Change Loading Overlay */}
+      {isChangingSource && (
+        <Animated.View 
+          style={[
+            styles.sourceChangeOverlay,
+            {
+              width: screenDimensions.width,
+              height: screenDimensions.height,
+              opacity: fadeAnim,
+            }
+          ]}
+          pointerEvents="auto"
+        >
+          <View style={styles.sourceChangeContent}>
+            <ActivityIndicator size="large" color="#E50914" />
+            <Text style={styles.sourceChangeText}>Changing source...</Text>
+            <Text style={styles.sourceChangeSubtext}>Please wait while we load the new stream</Text>
+          </View>
+        </Animated.View>
+      )}
+
+      <Animated.View 
+        style={[
+          styles.videoPlayerContainer,
+          {
+            opacity: openingFadeAnim,
+            transform: isOpeningAnimationComplete ? [] : [{ scale: openingScaleAnim }],
+            width: screenDimensions.width,
+            height: screenDimensions.height,
+          }
+        ]}
+      >
+        <TouchableOpacity
+          style={[styles.videoContainer, {
+            width: screenDimensions.width,
+            height: screenDimensions.height,
+          }]}
+          onPress={toggleControls}
+          activeOpacity={1}
+        >
+          <PinchGestureHandler
+            ref={pinchRef}
+            onGestureEvent={onPinchGestureEvent}
+            onHandlerStateChange={onPinchHandlerStateChange}
+          >
+            <View style={{
+              position: 'absolute',
+              top: 0,
+              left: 0,
+              width: screenDimensions.width,
+              height: screenDimensions.height,
+            }}>
+              <TouchableOpacity
+                style={{ flex: 1 }}
+                activeOpacity={1}
+                onPress={toggleControls}
+                onLongPress={resetZoom}
+                delayLongPress={300}
+              >
+                <Video
+                  ref={videoRef}
+                  style={[styles.video, customVideoStyles, { transform: [{ scale: zoomScale }] }]}
+                  source={{ uri: currentStreamUrl }}
+                  paused={paused}
+                  onProgress={handleProgress}
+                  onLoad={onLoad}
+                  onEnd={onEnd}
+                  onError={handleError}
+                  onBuffer={onBuffer}
+                  resizeMode={getVideoResizeMode(resizeMode)}
+                  selectedAudioTrack={selectedAudioTrack !== null ? { type: SelectedTrackType.INDEX, value: selectedAudioTrack } : undefined}
+                  selectedTextTrack={useCustomSubtitles ? { type: SelectedTrackType.DISABLED } : (selectedTextTrack >= 0 ? { type: SelectedTrackType.INDEX, value: selectedTextTrack } : undefined)}
+                  rate={1.0}
+                  volume={1.0}
+                  muted={false}
+                  repeat={false}
+                  playInBackground={false}
+                  playWhenInactive={false}
+                  ignoreSilentSwitch="ignore"
+                  mixWithOthers="inherit"
+                  progressUpdateInterval={1000}
+                />
+              </TouchableOpacity>
+            </View>
+          </PinchGestureHandler>
+
+          <PlayerControls
+            showControls={showControls}
+            fadeAnim={fadeAnim}
+            paused={paused}
+            title={title}
+            episodeTitle={episodeTitle}
+            season={season}
+            episode={episode}
+            quality={currentQuality || quality}
+            year={year}
+            streamProvider={currentStreamProvider || streamProvider}
+            streamName={currentStreamName}
+            currentTime={currentTime}
+            duration={duration}
+            zoomScale={zoomScale}
+            vlcAudioTracks={rnVideoAudioTracks}
+            selectedAudioTrack={selectedAudioTrack}
+            availableStreams={availableStreams}
+            togglePlayback={togglePlayback}
+            skip={skip}
+            handleClose={handleClose}
+            cycleAspectRatio={cycleAspectRatio}
+            setShowAudioModal={setShowAudioModal}
+            setShowSubtitleModal={setShowSubtitleModal}
+            setShowSourcesModal={setShowSourcesModal}
+            progressBarRef={progressBarRef}
+            progressAnim={progressAnim}
+            handleProgressBarTouch={handleProgressBarTouch}
+            handleProgressBarDragStart={handleProgressBarDragStart}
+            handleProgressBarDragMove={handleProgressBarDragMove}
+            handleProgressBarDragEnd={handleProgressBarDragEnd}
+            buffered={buffered}
+            formatTime={formatTime}
+          />
+          
+          <CustomSubtitles
+            useCustomSubtitles={useCustomSubtitles}
+            currentSubtitle={currentSubtitle}
+            subtitleSize={subtitleSize}
+          />
+
+          <ResumeOverlay
+            showResumeOverlay={showResumeOverlay}
+            resumePosition={resumePosition}
+            duration={duration}
+            title={title}
+            season={season}
+            episode={episode}
+            rememberChoice={rememberChoice}
+            setRememberChoice={setRememberChoice}
+            resumePreference={resumePreference}
+            resetResumePreference={resetResumePreference}
+            handleResume={handleResume}
+            handleStartFromBeginning={handleStartFromBeginning}
+          />
+        </TouchableOpacity> 
+      </Animated.View>
+
+      <AudioTrackModal
+        showAudioModal={showAudioModal}
+        setShowAudioModal={setShowAudioModal}
+        vlcAudioTracks={rnVideoAudioTracks}
+        selectedAudioTrack={selectedAudioTrack}
+        selectAudioTrack={selectAudioTrack}
+      />
+      <SubtitleModals
+        showSubtitleModal={showSubtitleModal}
+        setShowSubtitleModal={setShowSubtitleModal}
+        showSubtitleLanguageModal={showSubtitleLanguageModal}
+        setShowSubtitleLanguageModal={setShowSubtitleLanguageModal}
+        isLoadingSubtitleList={isLoadingSubtitleList}
+        isLoadingSubtitles={isLoadingSubtitles}
+        customSubtitles={customSubtitles}
+        availableSubtitles={availableSubtitles}
+        vlcTextTracks={rnVideoTextTracks}
+        selectedTextTrack={selectedTextTrack}
+        useCustomSubtitles={useCustomSubtitles}
+        subtitleSize={subtitleSize}
+        fetchAvailableSubtitles={fetchAvailableSubtitles}
+        loadWyzieSubtitle={loadWyzieSubtitle}
+        selectTextTrack={selectTextTrack}
+        increaseSubtitleSize={increaseSubtitleSize}
+        decreaseSubtitleSize={decreaseSubtitleSize}
+      />
+      
+      <SourcesModal
+        showSourcesModal={showSourcesModal}
+        setShowSourcesModal={setShowSourcesModal}
+        availableStreams={availableStreams}
+        currentStreamUrl={currentStreamUrl}
+        onSelectStream={handleSelectStream}
+        isChangingSource={isChangingSource}
+      />
+    </View> 
+  );
+};
+
+export default AndroidVideoPlayer; 
\ No newline at end of file
diff --git a/src/components/player/VideoPlayer.tsx b/src/components/player/VideoPlayer.tsx
index 2655caae0..f4d29ebf1 100644
--- a/src/components/player/VideoPlayer.tsx
+++ b/src/components/player/VideoPlayer.tsx
@@ -10,6 +10,7 @@ import { storageService } from '../../services/storageService';
 import { logger } from '../../utils/logger';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { MaterialIcons } from '@expo/vector-icons';
+import AndroidVideoPlayer from './AndroidVideoPlayer';
 
 import { 
   DEFAULT_SUBTITLE_SIZE, 
@@ -32,6 +33,11 @@ import CustomSubtitles from './subtitles/CustomSubtitles';
 import SourcesModal from './modals/SourcesModal';
 
 const VideoPlayer: React.FC = () => {
+  // If on Android, use the AndroidVideoPlayer component
+  if (Platform.OS === 'android') {
+    return <AndroidVideoPlayer />;
+  }
+
   const navigation = useNavigation();
   const route = useRoute<RouteProp<RootStackParamList, 'Player'>>();
   
@@ -70,6 +76,7 @@ const VideoPlayer: React.FC = () => {
   const [selectedTextTrack, setSelectedTextTrack] = useState<number>(-1);
   const [resizeMode, setResizeMode] = useState<ResizeModeType>('stretch');
   const [buffered, setBuffered] = useState(0);
+  const [seekPosition, setSeekPosition] = useState<number | null>(null);
   const vlcRef = useRef<any>(null);
   const [showAudioModal, setShowAudioModal] = useState(false);
   const [showSubtitleModal, setShowSubtitleModal] = useState(false);
@@ -92,6 +99,7 @@ const VideoPlayer: React.FC = () => {
   const progressAnim = useRef(new Animated.Value(0)).current;
   const progressBarRef = useRef<View>(null);
   const [isDragging, setIsDragging] = useState(false);
+  const isSeeking = useRef(false);
   const seekDebounceTimer = useRef<NodeJS.Timeout | null>(null);
   const pendingSeekValue = useRef<number | null>(null);
   const lastSeekTime = useRef<number>(0);
@@ -131,7 +139,6 @@ const VideoPlayer: React.FC = () => {
       left: 0,
       width: screenWidth,
       height: screenHeight,
-      backgroundColor: '#000',
     };
   };
 
@@ -294,66 +301,62 @@ const VideoPlayer: React.FC = () => {
     };
   }, [id, type, currentTime, duration]);
     
+  const onPlaying = () => {
+    if (isMounted.current && !isSeeking.current) {
+      setPaused(false);
+    }
+  };
+
+  const onPaused = () => {
+    if (isMounted.current) {
+      setPaused(true);
+    }
+  };
+
   const seekToTime = (timeInSeconds: number) => {
-    if (!isPlayerReady || duration <= 0 || !vlcRef.current) return;
-    const normalizedPosition = Math.max(0, Math.min(timeInSeconds / duration, 1));
-    
-    try {
-      if (Platform.OS === 'android') {
-        // On Android, we need to handle seeking differently to prevent black screens
-        setIsBuffering(true);
-        
-        // Set a small timeout to prevent overwhelming the player
-        const now = Date.now();
-        if (now - lastSeekTime.current < 300) {
-          // Throttle seeks that are too close together
-          if (seekDebounceTimer.current) {
-            clearTimeout(seekDebounceTimer.current);
-          }
-          
-          seekDebounceTimer.current = setTimeout(() => {
-            if (vlcRef.current) {
-              // Set position instead of using seek on Android
-              vlcRef.current.setPosition(normalizedPosition);
-              lastSeekTime.current = Date.now();
-              
-              // Give the player some time to recover
-              setTimeout(() => {
-                setIsBuffering(false);
-              }, 500);
-            }
-          }, 300);
-          return;
-        }
-        
-        // Directly set position
-        vlcRef.current.setPosition(normalizedPosition);
-        lastSeekTime.current = now;
-        
-        // Reset buffering state after a delay
-        setTimeout(() => {
-          setIsBuffering(false);
-        }, 500);
-      } else {
-        // For iOS, keep the original behavior
-        if (typeof vlcRef.current.setPosition === 'function') {
-          vlcRef.current.setPosition(normalizedPosition);
-        } else if (typeof vlcRef.current.seek === 'function') {
-          vlcRef.current.seek(normalizedPosition);
-        } else {
-          logger.error('[VideoPlayer] No seek method available on VLC player');
-        }
+    if (vlcRef.current && duration > 0 && !isSeeking.current) {
+      if (DEBUG_MODE) {
+        logger.log(`[VideoPlayer] Seeking to ${timeInSeconds.toFixed(2)}s`);
+      }
+      
+      isSeeking.current = true;
+      
+      // For Android, use direct seeking on VLC player ref instead of seek prop
+      if (Platform.OS === 'android' && vlcRef.current.seek) {
+        // Calculate position as fraction
+        const position = timeInSeconds / duration;
+        vlcRef.current.seek(position);
+        
+        // Clear seek state after Android seek
+        setTimeout(() => {
+          if (isMounted.current) {
+            isSeeking.current = false;
+          }
+        }, 300);
+      } else {
+        // iOS fallback - use seek prop
+        const position = timeInSeconds / duration;
+        setSeekPosition(position);
+        
+        setTimeout(() => {
+          if (isMounted.current) {
+            setSeekPosition(null);
+            isSeeking.current = false;
+          }
+        }, 500);
+      }
+    } else {
+      if (DEBUG_MODE) {
+        logger.error('[VideoPlayer] Seek failed: Player not ready, duration is zero, or already seeking.');
       }
-    } catch (error) {
-      logger.error('[VideoPlayer] Error during seek operation:', error);
-      setIsBuffering(false);
     }
   };
 
   const handleProgressBarTouch = (event: any) => {
-    if (!duration || duration <= 0) return;
-    const { locationX } = event.nativeEvent;
-    processProgressTouch(locationX);
+    if (duration > 0) {
+      const { locationX } = event.nativeEvent;
+      processProgressTouch(locationX);
+    }
   };
   
   const handleProgressBarDragStart = () => {
@@ -369,18 +372,8 @@ const VideoPlayer: React.FC = () => {
   const handleProgressBarDragEnd = () => {
     setIsDragging(false);
     if (pendingSeekValue.current !== null) {
-      // For Android, add a small delay to ensure UI updates before the seek happens
-      if (Platform.OS === 'android') {
-        setTimeout(() => {
-          if (pendingSeekValue.current !== null) {
-            seekToTime(pendingSeekValue.current);
-            pendingSeekValue.current = null;
-          }
-        }, 150);
-      } else {
-        seekToTime(pendingSeekValue.current);
-        pendingSeekValue.current = null;
-      }
+      seekToTime(pendingSeekValue.current);
+      pendingSeekValue.current = null;
     }
   };
   
@@ -399,8 +392,11 @@ const VideoPlayer: React.FC = () => {
   };
 
   const handleProgress = (event: any) => {
-    if (isDragging) return;
+    if (isDragging || isSeeking.current) return;
+    
     const currentTimeInSeconds = event.currentTime / 1000;
+    
+    // Only update if there's a significant change to avoid unnecessary updates
     if (Math.abs(currentTimeInSeconds - currentTime) > 0.5) {
       safeSetState(() => setCurrentTime(currentTimeInSeconds));
       const progressPercent = duration > 0 ? currentTimeInSeconds / duration : 0;
@@ -415,67 +411,34 @@ const VideoPlayer: React.FC = () => {
   };
 
   const onLoad = (data: any) => {
-    setDuration(data.duration / 1000);
-    if (data.videoSize && data.videoSize.width && data.videoSize.height) {
-      const aspectRatio = data.videoSize.width / data.videoSize.height;
-      setVideoAspectRatio(aspectRatio);
-      const is16x9 = Math.abs(aspectRatio - (16/9)) < 0.1;
-      setIs16by9Content(is16x9);
-      if (is16x9) {
-        setZoomScale(1.1);
-        setLastZoomScale(1.1);
-      } else {
-        setZoomScale(1);
-        setLastZoomScale(1);
+    if (DEBUG_MODE) {
+      logger.log('[VideoPlayer] Video loaded:', data);
+    }
+    if (isMounted.current) {
+      if (data.duration > 0) {
+        setDuration(data.duration / 1000);
       }
-      const styles = calculateVideoStyles(
-        data.videoSize.width,
-        data.videoSize.height,
-        screenDimensions.width,
-        screenDimensions.height
-      );
-      setCustomVideoStyles(styles);
-    } else {
-      setIs16by9Content(true);
-      setZoomScale(1.1);
-      setLastZoomScale(1.1);
-      const defaultStyles = {
-        position: 'absolute',
-        top: 0,
-        left: 0,
-        width: screenDimensions.width,
-        height: screenDimensions.height,
-      };
-      setCustomVideoStyles(defaultStyles);
+      setVideoAspectRatio(data.videoSize.width / data.videoSize.height);
+
+      if (data.audioTracks && data.audioTracks.length > 0) {
+        setVlcAudioTracks(data.audioTracks);
+      }
+      if (data.textTracks && data.textTracks.length > 0) {
+        setVlcTextTracks(data.textTracks);
+      }
+
+      setIsVideoLoaded(true);
+      setIsPlayerReady(true);
+      if (initialPosition && !isInitialSeekComplete) {
+        setTimeout(() => {
+          if (vlcRef.current && duration > 0 && isMounted.current) {
+            seekToTime(initialPosition);
+            setIsInitialSeekComplete(true);
+          }
+        }, 1000);
+      }
+      completeOpeningAnimation();
     }
-    setIsPlayerReady(true);
-    const audioTracksFromLoad = data.audioTracks || [];
-    const textTracksFromLoad = data.textTracks || [];
-    setVlcAudioTracks(audioTracksFromLoad);
-    setVlcTextTracks(textTracksFromLoad);
-    if (audioTracksFromLoad.length > 1) {
-        const firstEnabledAudio = audioTracksFromLoad.find((t: any) => t.id !== -1);
-        if(firstEnabledAudio) {
-            setSelectedAudioTrack(firstEnabledAudio.id);
-        }
-    } else if (audioTracksFromLoad.length > 0) {
-        setSelectedAudioTrack(audioTracksFromLoad[0].id);
-    }
-    if (imdbId && !customSubtitles.length) {
-      setTimeout(() => {
-        fetchAvailableSubtitles(imdbId, true);
-      }, 2000);
-    }
-    if (initialPosition !== null && !isInitialSeekComplete) {
-      setTimeout(() => {
-        if (vlcRef.current && duration > 0 && isMounted.current) {
-          seekToTime(initialPosition);
-          setIsInitialSeekComplete(true);
-        }
-      }, 1000);
-    }
-    setIsVideoLoaded(true);
-    completeOpeningAnimation();
   };
 
   const skip = (seconds: number) => {
@@ -793,61 +756,25 @@ const VideoPlayer: React.FC = () => {
       logger.log(`[VideoPlayer] Player ready after source change, seeking to position: ${pendingSeek.position}s out of ${duration}s total`);
       
       if (pendingSeek.position > 0 && vlcRef.current) {
-        // Longer delay for Android to ensure player is stable
-        const delayTime = Platform.OS === 'android' ? 2500 : 1500;
+        const delayTime = Platform.OS === 'android' ? 1500 : 1000;
         
         setTimeout(() => {
           if (vlcRef.current && duration > 0 && pendingSeek) {
             logger.log(`[VideoPlayer] Executing seek to ${pendingSeek.position}s`);
             
-            if (Platform.OS === 'android') {
-              // On Android, wait longer and set isBuffering to improve visual feedback
-              setIsBuffering(true);
-              
-              // For Android, use setPosition directly with normalized value
-              const normalizedPosition = Math.max(0, Math.min(pendingSeek.position / duration, 1));
-              vlcRef.current.setPosition(normalizedPosition);
-              
-              // Update the current time
-              setCurrentTime(pendingSeek.position);
-              
-              // Give the player time to recover from the seek
+            seekToTime(pendingSeek.position);
+            
+            if (pendingSeek.shouldPlay) {
               setTimeout(() => {
-                setIsBuffering(false);
-                
-                // Resume playback after a delay if needed
-                if (pendingSeek.shouldPlay) {
-                  setPaused(false);
-                }
-                
-                // Clean up
-                setPendingSeek(null);
-                setIsChangingSource(false);
-              }, 800);
-            } else {
-              // iOS - use the normal seekToTime function
-              seekToTime(pendingSeek.position);
-              
-              // Also update the current time state
-              setCurrentTime(pendingSeek.position);
-              
-              // Resume playback if needed
-              if (pendingSeek.shouldPlay) {
-                setTimeout(() => {
-                  logger.log('[VideoPlayer] Resuming playback after seek');
-                  setPaused(false);
-                  if (vlcRef.current && typeof vlcRef.current.play === 'function') {
-                    vlcRef.current.play();
-                  }
-                }, 700);
-              }
-              
-              // Clean up
-              setTimeout(() => {
-                setPendingSeek(null);
-                setIsChangingSource(false);
-              }, 800);
+                logger.log('[VideoPlayer] Resuming playback after source change seek');
+                setPaused(false);
+              }, 850); // Delay should be slightly more than seekToTime's internal timeout
             }
+            
+            setTimeout(() => {
+              setPendingSeek(null);
+              setIsChangingSource(false);
+            }, 900);
           }
         }, delayTime);
       } else {
@@ -856,9 +783,6 @@ const VideoPlayer: React.FC = () => {
           setTimeout(() => {
             logger.log('[VideoPlayer] No seek needed, just resuming playback');
             setPaused(false);
-            if (vlcRef.current && typeof vlcRef.current.play === 'function') {
-              vlcRef.current.play();
-            }
           }, 500);
         }
         
@@ -1018,7 +942,6 @@ const VideoPlayer: React.FC = () => {
               left: 0,
               width: screenDimensions.width,
               height: screenDimensions.height,
-              backgroundColor: '#000',
             }}>
               <TouchableOpacity
                 style={{ flex: 1 }}
@@ -1029,52 +952,21 @@ const VideoPlayer: React.FC = () => {
               >
                 <VLCPlayer
                   ref={vlcRef}
-                  style={{
-                    position: 'absolute',
-                    top: 0,
-                    left: 0,
-                    width: screenDimensions.width,
-                    height: screenDimensions.height,
-                    transform: [
-                      { scale: zoomScale },
-                    ],
-                  }}
-                  source={{
-                    uri: currentStreamUrl,
-                    initOptions: Platform.OS === 'android' ? [
-                      '--rtsp-tcp',
-                      '--network-caching=1500',
-                      '--rtsp-caching=1500',
-                      '--no-audio-time-stretch',
-                      '--clock-jitter=0',
-                      '--clock-synchro=0',
-                      '--drop-late-frames',
-                      '--skip-frames',
-                      '--aout=opensles',
-                      '--file-caching=1500',
-                      '--sout-mux-caching=1500',
-                    ] : [
-                      '--rtsp-tcp',
-                      '--network-caching=150',
-                      '--rtsp-caching=150',
-                      '--no-audio-time-stretch',
-                      '--clock-jitter=0',
-                      '--clock-synchro=0',
-                      '--drop-late-frames',
-                      '--skip-frames',
-                    ],
-                  }}
+                  style={[styles.video, customVideoStyles, { transform: [{ scale: zoomScale }] }]}
+                  source={{ uri: currentStreamUrl }}
                   paused={paused}
-                  autoplay={true}
-                  autoAspectRatio={false}
-                  resizeMode={'stretch' as any}
-                  audioTrack={selectedAudioTrack || undefined}
-                  textTrack={selectedTextTrack === -1 ? undefined : selectedTextTrack}
-                  onLoad={onLoad}
                   onProgress={handleProgress}
+                  onLoad={onLoad}
                   onEnd={onEnd}
                   onError={handleError}
                   onBuffering={onBuffering}
+                  onPlaying={onPlaying}
+                  onPaused={onPaused}
+                  resizeMode={resizeMode as any}
+                  audioTrack={selectedAudioTrack ?? undefined}
+                  textTrack={useCustomSubtitles ? -1 : (selectedTextTrack ?? undefined)}
+                  seek={Platform.OS === 'ios' ? (seekPosition ?? undefined) : undefined}
+                  autoAspectRatio
                 />
               </TouchableOpacity>
             </View>