Merge branch 'develop' into fix/network-location

Co-authored-by: lance chant <13349722+lancechant@users.noreply.github.com>

app/(auth)/(tabs)/(home)/settings.tv.tsx

@@ -5,7 +5,7 @@ import { Image } from "expo-image";
 import { useAtom } from "jotai";
 import { useMemo, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { Alert, Platform, ScrollView, View } from "react-native";
+import { Alert, ScrollView, View } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import { Text } from "@/components/common/Text";
 import { TVPasswordEntryModal } from "@/components/login/TVPasswordEntryModal";
@@ -33,16 +33,13 @@ import {
 } from "@/providers/JellyfinProvider";
 import {
   AudioTranscodeMode,
-  getActiveVideoPlayer,
   InactivityTimeout,
   type MpvCacheMode,
   type MpvVoDriver,
   TVTypographyScale,
   useSettings,
-  VideoPlayer,
 } from "@/utils/atoms/settings";
 import { storage } from "@/utils/mmkv";
-import { scaleSize } from "@/utils/scaleSize";
 import {
   getPreviousServers,
   type SavedServer,
@@ -265,25 +262,6 @@ export default function SettingsTV() {
   const currentVoDriver = settings.mpvVoDriver ?? "gpu-next";
   const currentLanguage = settings.preferedLanguage;
 
-  // Video player selection. MPV is the default; ExoPlayer is only offered
-  // as an opt-in alternative on Android TV. The selector is hidden on
-  // other platforms.
-  const isAndroidTv = Platform.OS === "android" && Platform.isTV;
-  const currentVideoPlayer = getActiveVideoPlayer(settings);
-  const isMpv = currentVideoPlayer !== VideoPlayer.ExoPlayer;
-
-  // Shared style for the ExoPlayer / MPV limitation notes shown under the
-  // selector when the respective player is active. All pixel values scaled
-  // so the layout holds on 4K TVs (see utils/scaleSize.ts).
-  const playerNoteStyle = {
-    color: "#9CA3AF",
-    fontSize: typography.callout - 2,
-    marginTop: scaleSize(4),
-    marginBottom: scaleSize(12),
-    marginLeft: scaleSize(8),
-    marginRight: scaleSize(8),
-  } as const;
-
   // Audio transcoding options
   const audioTranscodeModeOptions: TVOptionItem<AudioTranscodeMode>[] = useMemo(
     () => [
@@ -413,23 +391,6 @@ export default function SettingsTV() {
     [t, currentVoDriver],
   );
 
-  // Video player backend options (Android TV only)
-  const videoPlayerOptions: TVOptionItem<VideoPlayer>[] = useMemo(
-    () => [
-      {
-        label: t("home.settings.video_player.exoplayer"),
-        value: VideoPlayer.ExoPlayer,
-        selected: currentVideoPlayer === VideoPlayer.ExoPlayer,
-      },
-      {
-        label: t("home.settings.video_player.mpv"),
-        value: VideoPlayer.MPV,
-        selected: currentVideoPlayer === VideoPlayer.MPV,
-      },
-    ],
-    [t, currentVideoPlayer],
-  );
-
   // Typography scale options
   const typographyScaleOptions: TVOptionItem<TVTypographyScale>[] = useMemo(
     () => [
@@ -561,11 +522,6 @@ export default function SettingsTV() {
     return option?.label || t("home.settings.vo_driver.gpu_next");
   }, [voDriverOptions, t]);
 
-  const videoPlayerLabel = useMemo(() => {
-    const option = videoPlayerOptions.find((o) => o.selected);
-    return option?.label || "MPV";
-  }, [videoPlayerOptions]);
-
   const languageLabel = useMemo(() => {
     if (!currentLanguage) return t("home.settings.languages.system");
     const option = APP_LANGUAGES.find((l) => l.value === currentLanguage);
@@ -630,34 +586,6 @@ export default function SettingsTV() {
 
           {/* Audio Section */}
           <TVSectionHeader title={t("home.settings.audio.audio_title")} />
-
-          {/* Video Player selector — Android TV only */}
-          {isAndroidTv && (
-            <>
-              <TVSettingsOptionButton
-                label={t("home.settings.video_player.title")}
-                value={videoPlayerLabel}
-                onPress={() =>
-                  showOptions({
-                    title: t("home.settings.video_player.title"),
-                    options: videoPlayerOptions,
-                    onSelect: (value) => updateSettings({ videoPlayer: value }),
-                  })
-                }
-              />
-              {!isMpv && (
-                <Text style={playerNoteStyle}>
-                  {t("home.settings.video_player.exoplayer_note")}
-                </Text>
-              )}
-              {isMpv && (
-                <Text style={playerNoteStyle}>
-                  {t("home.settings.video_player.mpv_note")}
-                </Text>
-              )}
-            </>
-          )}
-
           <TVSettingsOptionButton
             label={t("home.settings.audio.transcode_mode.title")}
             value={audioTranscodeLabel}
@@ -734,23 +662,20 @@ export default function SettingsTV() {
               updateSettings({ mpvSubtitleMarginY: newValue });
             }}
           />
-          {isMpv && (
-            <TVSettingsOptionButton
-              label={t("home.settings.subtitles.mpv_subtitle_align_x")}
-              value={alignXLabel}
-              // ExoPlayer follows authored cue alignment; hide on ExoPlayer.
-              onPress={() =>
-                showOptions({
-                  title: t("home.settings.subtitles.mpv_subtitle_align_x"),
-                  options: alignXOptions,
-                  onSelect: (value) =>
-                    updateSettings({
-                      mpvSubtitleAlignX: value as "left" | "center" | "right",
-                    }),
-                })
-              }
-            />
-          )}
+          <TVSettingsOptionButton
+            label='Horizontal Alignment'
+            value={alignXLabel}
+            onPress={() =>
+              showOptions({
+                title: "Horizontal Alignment",
+                options: alignXOptions,
+                onSelect: (value) =>
+                  updateSettings({
+                    mpvSubtitleAlignX: value as "left" | "center" | "right",
+                  }),
+              })
+            }
+          />
           <TVSettingsOptionButton
             label='Vertical Alignment'
             value={alignYLabel}
@@ -823,24 +748,19 @@ export default function SettingsTV() {
             }
           />
 
-          {/* Video Output Section — MPV only (gpu-next/gpu is a libmpv concept) */}
-          {isMpv && (
-            <>
-              <TVSectionHeader title={t("home.settings.vo_driver.title")} />
-              <TVSettingsOptionButton
-                label={t("home.settings.vo_driver.vo_mode")}
-                value={voDriverLabel}
-                onPress={() =>
-                  showOptions({
-                    title: t("home.settings.vo_driver.vo_mode"),
-                    options: voDriverOptions,
-                    onSelect: (value) => updateSettings({ mpvVoDriver: value }),
-                  })
-                }
-              />
-            </>
-          )}
-
+          {/* Video Output Section */}
+          <TVSectionHeader title={t("home.settings.vo_driver.title")} />
+          <TVSettingsOptionButton
+            label={t("home.settings.vo_driver.vo_mode")}
+            value={voDriverLabel}
+            onPress={() =>
+              showOptions({
+                title: t("home.settings.vo_driver.vo_mode"),
+                options: voDriverOptions,
+                onSelect: (value) => updateSettings({ mpvVoDriver: value }),
+              })
+            }
+          />
           <TVSettingsStepper
             label={t("home.settings.buffer.buffer_duration")}
             value={settings.mpvCacheSeconds ?? 10}

app/(auth)/(tabs)/(home)/settings/appearance/hide-libraries/page.tsx

@@ -71,7 +71,7 @@ export default function AppearanceHideLibrariesPage() {
           ))}
         </ListGroup>
         <Text className='px-4 text-xs text-neutral-500 mt-1'>
-          {t("home.settings.other.select_liraries_you_want_to_hide")}
+          {t("home.settings.other.select_libraries_you_want_to_hide")}
         </Text>
       </DisabledSetting>
     </ScrollView>

app/(auth)/(tabs)/(home)/settings/hide-libraries/page.tsx

@@ -60,7 +60,7 @@ export default function HideLibrariesPage() {
         ))}
       </ListGroup>
       <Text className='px-4 text-xs text-neutral-500 mt-1'>
-        {t("home.settings.other.select_liraries_you_want_to_hide")}
+        {t("home.settings.other.select_libraries_you_want_to_hide")}
       </Text>
     </DisabledSetting>
   );

app/(auth)/player/direct-player.tsx

@@ -29,7 +29,6 @@ import {
   PlaybackSpeedScope,
   updatePlaybackSpeedSettings,
 } from "@/components/video-player/controls/utils/playback-speed-settings";
-import { VideoPlayerView } from "@/components/video-player/VideoPlayerView";
 import useRouter from "@/hooks/useAppRouter";
 import { useHaptic } from "@/hooks/useHaptic";
 import { useOrientation } from "@/hooks/useOrientation";
@@ -41,6 +40,7 @@ import {
   type MpvOnErrorEventPayload,
   type MpvOnPlaybackStateChangePayload,
   type MpvOnProgressEventPayload,
+  MpvPlayerView,
   type MpvPlayerViewRef,
   type MpvVideoSource,
 } from "@/modules";
@@ -51,7 +51,7 @@ import { apiAtom, userAtom } from "@/providers/JellyfinProvider";
 import { OfflineModeProvider } from "@/providers/OfflineModeProvider";
 
 import { getSubtitlesForItem } from "@/utils/atoms/downloadedSubtitles";
-import { getActivePlayerType, useSettings } from "@/utils/atoms/settings";
+import { useSettings } from "@/utils/atoms/settings";
 import { getDefaultPlaySettings } from "@/utils/jellyfin/getDefaultPlaySettings";
 import { getPrimaryImageUrl } from "@/utils/jellyfin/image/getPrimaryImageUrl";
 import { getStreamUrl } from "@/utils/jellyfin/media/getStreamUrl";
@@ -364,13 +364,7 @@ export default function DirectPlayerPage() {
             maxStreamingBitrate: bitrateValue,
             mediaSourceId: mediaSourceId,
             subtitleStreamIndex: subtitleIndex,
-            // Match the device profile to the player that will render the
-            // stream so the server picks a codec/container the player can
-            // actually decode.
-            deviceProfile: generateDeviceProfile({
-              player: getActivePlayerType(settings),
-              audioMode: settings.audioTranscodeMode,
-            }),
+            deviceProfile: generateDeviceProfile(),
           });
           if (!res) return null;
           const { mediaSource, sessionId, url, requiredHttpHeaders } = res;
@@ -1311,7 +1305,7 @@ export default function DirectPlayerPage() {
                 justifyContent: "center",
               }}
             >
-              <VideoPlayerView
+              <MpvPlayerView
                 ref={videoRef}
                 source={videoSource}
                 style={{ width: "100%", height: "100%" }}
@@ -1324,7 +1318,7 @@ export default function DirectPlayerPage() {
                   console.error("Video Error:", e.nativeEvent);
                   Alert.alert(
                     t("player.error"),
-                    t("player.an_error_occured_while_playing_the_video"),
+                    t("player.an_error_occurred_while_playing_the_video"),
                   );
                   writeToLog("ERROR", "Video Error", e.nativeEvent);
                 }}

app/_layout.tsx

@@ -27,6 +27,7 @@ import { NetworkStatusProvider } from "@/providers/NetworkStatusProvider";
 import { PlaySettingsProvider } from "@/providers/PlaySettingsProvider";
 import { ServerUrlProvider } from "@/providers/ServerUrlProvider";
 import { WebSocketProvider } from "@/providers/WebSocketProvider";
+import { WifiSsidProvider } from "@/providers/WifiSsidProvider";
 import { useSettings } from "@/utils/atoms/settings";
 import {
   BACKGROUND_FETCH_TASK,
@@ -85,7 +86,8 @@ configureReanimatedLogger({
 if (!Platform.isTV) {
   Notifications.setNotificationHandler({
     handleNotification: async () => ({
-      shouldShowAlert: true,
+      shouldShowBanner: true,
+      shouldShowList: true,
       shouldPlaySound: true,
       shouldSetBadge: false,
     }),
@@ -350,9 +352,12 @@ function Layout() {
       notificationListener.current =
         Notifications?.addNotificationReceivedListener(
           (notification: Notification) => {
+            // Log only the title — serializing the whole notification touches
+            // the deprecated dataString getter (deprecation warning) and dumps
+            // noisy payloads into the console.
             console.log(
-              "Notification received while app running",
-              notification,
+              "Notification received while app running:",
+              notification.request.content.title,
             );
           },
         );
@@ -421,143 +426,146 @@ function Layout() {
     >
       <JellyfinProvider>
         <InactivityProvider>
-          <ServerUrlProvider>
-            <NetworkStatusProvider>
-              <PlaySettingsProvider>
-                <LogProvider>
-                  <WebSocketProvider>
-                    <DownloadProvider>
-                      <MusicPlayerProvider>
-                        <GlobalModalProvider>
-                          <BottomSheetModalProvider>
-                            <IntroSheetProvider>
-                              <ThemeProvider value={DarkTheme}>
-                                <SystemBars style='light' hidden={false} />
-                                <Stack initialRouteName='(auth)/(tabs)'>
-                                  <Stack.Screen
-                                    name='(auth)/(tabs)'
-                                    options={{
-                                      headerShown: false,
-                                      title: "",
-                                      header: () => null,
+          <WifiSsidProvider>
+            <ServerUrlProvider>
+              <NetworkStatusProvider>
+                <PlaySettingsProvider>
+                  <LogProvider>
+                    <WebSocketProvider>
+                      <DownloadProvider>
+                        <MusicPlayerProvider>
+                          <GlobalModalProvider>
+                            <BottomSheetModalProvider>
+                              <IntroSheetProvider>
+                                <ThemeProvider value={DarkTheme}>
+                                  <SystemBars style='light' hidden={false} />
+                                  <Stack initialRouteName='(auth)/(tabs)'>
+                                    <Stack.Screen
+                                      name='(auth)/(tabs)'
+                                      options={{
+                                        headerShown: false,
+                                        title: "",
+                                        header: () => null,
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/player'
+                                      options={{
+                                        headerShown: false,
+                                        title: "",
+                                        header: () => null,
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/now-playing'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "modal",
+                                        gestureEnabled: true,
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='login'
+                                      options={{
+                                        headerShown: true,
+                                        title: "",
+                                        headerTransparent:
+                                          Platform.OS === "ios",
+                                      }}
+                                    />
+                                    <Stack.Screen name='+not-found' />
+                                    <Stack.Screen
+                                      name='(auth)/tv-option-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/tv-subtitle-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/tv-request-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/tv-season-select-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/tv-series-season-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='tv-account-action-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='tv-account-select-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                    <Stack.Screen
+                                      name='(auth)/tv-user-switch-modal'
+                                      options={{
+                                        headerShown: false,
+                                        presentation: "transparentModal",
+                                        animation: "fade",
+                                      }}
+                                    />
+                                  </Stack>
+                                  <Toaster
+                                    duration={4000}
+                                    toastOptions={{
+                                      style: {
+                                        backgroundColor: "#262626",
+                                        borderColor: "#363639",
+                                        borderWidth: 1,
+                                      },
+                                      titleStyle: {
+                                        color: "white",
+                                      },
                                     }}
+                                    closeButton
                                   />
-                                  <Stack.Screen
-                                    name='(auth)/player'
-                                    options={{
-                                      headerShown: false,
-                                      title: "",
-                                      header: () => null,
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='(auth)/now-playing'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "modal",
-                                      gestureEnabled: true,
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='login'
-                                    options={{
-                                      headerShown: true,
-                                      title: "",
-                                      headerTransparent: Platform.OS === "ios",
-                                    }}
-                                  />
-                                  <Stack.Screen name='+not-found' />
-                                  <Stack.Screen
-                                    name='(auth)/tv-option-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='(auth)/tv-subtitle-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='(auth)/tv-request-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='(auth)/tv-season-select-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='(auth)/tv-series-season-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='tv-account-action-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='tv-account-select-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                  <Stack.Screen
-                                    name='(auth)/tv-user-switch-modal'
-                                    options={{
-                                      headerShown: false,
-                                      presentation: "transparentModal",
-                                      animation: "fade",
-                                    }}
-                                  />
-                                </Stack>
-                                <Toaster
-                                  duration={4000}
-                                  toastOptions={{
-                                    style: {
-                                      backgroundColor: "#262626",
-                                      borderColor: "#363639",
-                                      borderWidth: 1,
-                                    },
-                                    titleStyle: {
-                                      color: "white",
-                                    },
-                                  }}
-                                  closeButton
-                                />
-                                {!Platform.isTV && <GlobalModal />}
-                              </ThemeProvider>
-                            </IntroSheetProvider>
-                          </BottomSheetModalProvider>
-                        </GlobalModalProvider>
-                      </MusicPlayerProvider>
-                    </DownloadProvider>
-                  </WebSocketProvider>
-                </LogProvider>
-              </PlaySettingsProvider>
-            </NetworkStatusProvider>
-          </ServerUrlProvider>
+                                  {!Platform.isTV && <GlobalModal />}
+                                </ThemeProvider>
+                              </IntroSheetProvider>
+                            </BottomSheetModalProvider>
+                          </GlobalModalProvider>
+                        </MusicPlayerProvider>
+                      </DownloadProvider>
+                    </WebSocketProvider>
+                  </LogProvider>
+                </PlaySettingsProvider>
+              </NetworkStatusProvider>
+            </ServerUrlProvider>
+          </WifiSsidProvider>
         </InactivityProvider>
       </JellyfinProvider>
     </PersistQueryClientProvider>

components/downloads/SeriesCard.tsx

@@ -16,9 +16,12 @@ export const SeriesCard: React.FC<{ items: BaseItemDto[] }> = ({ items }) => {
   const { showActionSheetWithOptions } = useActionSheet();
   const router = useRouter();
 
+  // Keyed on SeriesId so recycled FlashList cells re-read the correct poster
+  // instead of freezing the first-rendered series' image (empty deps bug).
   const base64Image = useMemo(() => {
-    return storage.getString(items[0].SeriesId!);
-  }, []);
+    const seriesId = items[0]?.SeriesId;
+    return seriesId ? storage.getString(seriesId) : undefined;
+  }, [items[0]?.SeriesId]);
 
   const deleteSeries = useCallback(
     async () =>

components/login/Login.tsx

@@ -146,7 +146,7 @@ export const Login: React.FC = () => {
       } else {
         Alert.alert(
           t("login.connection_failed"),
-          t("login.an_unexpected_error_occured"),
+          t("login.an_unexpected_error_occurred"),
         );
       }
     } finally {

components/login/TVLogin.tsx

@@ -437,7 +437,7 @@ export const TVLogin: React.FC = () => {
       } else {
         Alert.alert(
           t("login.connection_failed"),
-          t("login.an_unexpected_error_occured"),
+          t("login.an_unexpected_error_occurred"),
         );
       }
     } finally {
@@ -499,7 +499,7 @@ export const TVLogin: React.FC = () => {
         const message =
           error instanceof Error
             ? error.message
-            : t("login.an_unexpected_error_occured");
+            : t("login.an_unexpected_error_occurred");
         Alert.alert(t("login.connection_failed"), message);
         goToQRScreen();
       } finally {
@@ -523,7 +523,7 @@ export const TVLogin: React.FC = () => {
         } else {
           Alert.alert(
             t("login.connection_failed"),
-            t("login.an_unexpected_error_occured"),
+            t("login.an_unexpected_error_occurred"),
           );
         }
       } finally {
@@ -768,7 +768,7 @@ export const TVLogin: React.FC = () => {
               const message =
                 error instanceof Error
                   ? error.message
-                  : t("login.an_unexpected_error_occured");
+                  : t("login.an_unexpected_error_occurred");
               Alert.alert(t("login.connection_failed"), message);
               goToQRScreen();
             });

components/settings/LocalNetworkSettings.tsx

@@ -5,6 +5,7 @@ import { useTranslation } from "react-i18next";
 import { Switch, TouchableOpacity, View } from "react-native";
 import { toast } from "sonner-native";
 import { useWifiSSID } from "@/hooks/useWifiSSID";
+import { openLocationSettings } from "@/modules/wifi-ssid";
 import { useServerUrl } from "@/providers/ServerUrlProvider";
 import { storage } from "@/utils/mmkv";
 import {
@@ -26,16 +27,26 @@ const DEFAULT_CONFIG: LocalNetworkConfig = {
 
 interface StatusDisplayProps {
   currentSSID: string | null;
+  connectedToWifi: boolean;
   isUsingLocalUrl: boolean;
+  locationBlocked: boolean;
+  onOpenLocationSettings: () => void;
   t: (key: string) => string;
 }
 
 function StatusDisplay({
   currentSSID,
+  connectedToWifi,
   isUsingLocalUrl,
+  locationBlocked,
+  onOpenLocationSettings,
   t,
 }: StatusDisplayProps): React.ReactElement {
-  const wifiStatus = currentSSID ?? t("home.settings.network.not_connected");
+  const wifiStatus = currentSSID
+    ? currentSSID
+    : connectedToWifi
+      ? t("home.settings.network.ssid_hidden")
+      : t("home.settings.network.not_connected");
   const urlType = isUsingLocalUrl
     ? t("home.settings.network.local")
     : t("home.settings.network.remote");
@@ -55,6 +66,23 @@ function StatusDisplay({
         </Text>
         <Text className={urlTypeColor}>{urlType}</Text>
       </View>
+
+      {locationBlocked && (
+        <View className='mt-2 pt-2 border-t border-neutral-800'>
+          <Text className='text-xs text-amber-400'>
+            {t("home.settings.network.location_off_description")}
+          </Text>
+          <TouchableOpacity
+            onPress={onOpenLocationSettings}
+            className='mt-2 self-start'
+            hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+          >
+            <Text className='text-xs text-blue-400 font-semibold'>
+              {t("home.settings.network.open_location_settings")}
+            </Text>
+          </TouchableOpacity>
+        </View>
+      )}
     </View>
   );
 }
@@ -62,7 +90,17 @@ function StatusDisplay({
 export function LocalNetworkSettings(): React.ReactElement | null {
   const { t } = useTranslation();
   const { permissionStatus, requestPermission } = useWifiSSID();
-  const { isUsingLocalUrl, currentSSID, refreshUrlState } = useServerUrl();
+  const { isUsingLocalUrl, currentSSID, connectedToWifi, refreshUrlState } =
+    useServerUrl();
+
+  // Connected to Wi-Fi and have permission, but the OS won't reveal the SSID —
+  // on Android this means device Location services are off.
+  const locationBlocked =
+    permissionStatus === "granted" && connectedToWifi && !currentSSID;
+
+  const handleOpenLocationSettings = useCallback(() => {
+    openLocationSettings();
+  }, []);
 
   const remoteUrl = storage.getString("serverUrl");
   const [config, setConfig] = useState<LocalNetworkConfig>(DEFAULT_CONFIG);
@@ -195,18 +233,23 @@ export function LocalNetworkSettings(): React.ReactElement | null {
             )}
           </ListGroup>
 
-          <View className='py-2'>
-            <Button
-              onPress={handleAddCurrentNetwork}
-              disabled={!currentSSID || permissionStatus !== "granted"}
-            >
-              {addNetworkButtonText}
-            </Button>
-          </View>
+          {!locationBlocked && (
+            <View className='py-2'>
+              <Button
+                onPress={handleAddCurrentNetwork}
+                disabled={!currentSSID || permissionStatus !== "granted"}
+              >
+                {addNetworkButtonText}
+              </Button>
+            </View>
+          )}
 
           <StatusDisplay
             currentSSID={currentSSID}
+            connectedToWifi={connectedToWifi}
             isUsingLocalUrl={isUsingLocalUrl}
+            locationBlocked={locationBlocked}
+            onOpenLocationSettings={handleOpenLocationSettings}
             t={t}
           />
         </View>

components/settings/QuickConnect.tsx

@@ -58,7 +58,7 @@ export const QuickConnect: React.FC<Props> = ({ ...props }) => {
           successHapticFeedback();
           Alert.alert(
             t("home.settings.quick_connect.success"),
-            t("home.settings.quick_connect.quick_connect_autorized"),
+            t("home.settings.quick_connect.quick_connect_authorized"),
           );
           setQuickConnectCode(undefined);
           bottomSheetModalRef?.current?.close();

components/settings/StorageSettings.tsx

@@ -1,6 +1,6 @@
-import { useQuery } from "@tanstack/react-query";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useTranslation } from "react-i18next";
-import { Platform, View } from "react-native";
+import { Alert, Platform, View } from "react-native";
 import { toast } from "sonner-native";
 import { Text } from "@/components/common/Text";
 import { Colors } from "@/constants/Colors";
@@ -12,6 +12,7 @@ import { ListItem } from "../list/ListItem";
 export const StorageSettings = () => {
   const { deleteAllFiles, appSizeUsage } = useDownload();
   const { t } = useTranslation();
+  const queryClient = useQueryClient();
   const successHapticFeedback = useHaptic("success");
   const errorHapticFeedback = useHaptic("error");
 
@@ -27,16 +28,38 @@ export const StorageSettings = () => {
         used: (app.total - app.remaining) / app.total,
       };
     },
+    // Keep the bar moving while a download is writing to disk.
+    refetchInterval: 10 * 1000,
   });
 
-  const onDeleteClicked = async () => {
-    try {
-      await deleteAllFiles();
-      successHapticFeedback();
-    } catch (_e) {
-      errorHapticFeedback();
-      toast.error(t("home.settings.toasts.error_deleting_files"));
-    }
+  const onDeleteClicked = () => {
+    Alert.alert(
+      t("home.settings.storage.delete_all_downloaded_files_confirm"),
+      t("home.settings.storage.delete_all_downloaded_files_confirm_desc"),
+      [
+        {
+          text: t("common.cancel"),
+          style: "cancel",
+        },
+        {
+          text: t("common.ok"),
+          style: "destructive",
+          onPress: async () => {
+            try {
+              await deleteAllFiles();
+              successHapticFeedback();
+            } catch (_e) {
+              errorHapticFeedback();
+              toast.error(t("home.settings.toasts.error_deleting_files"));
+            } finally {
+              // Reflect the freed space immediately instead of waiting for
+              // the next poll.
+              queryClient.invalidateQueries({ queryKey: ["appSize"] });
+            }
+          },
+        },
+      ],
+    );
   };
 
   const calculatePercentage = (value: number, total: number) => {

components/tv/TVNextEpisodeCountdown.tsx

@@ -44,10 +44,8 @@ export interface TVNextEpisodeCountdownProps {
   playButtonRef?: RNView | null;
 }
 
-// Position constants — kept in sync with TVSkipSegmentCard (the two are
-// mutually exclusive). See TVSkipSegmentCard for the BOTTOM_WITH_CONTROLS
-// rationale (220 sits just above the controls bar; 300 floated too high).
-const BOTTOM_WITH_CONTROLS = scaleSize(220);
+// Position constants
+const BOTTOM_WITH_CONTROLS = scaleSize(300);
 const BOTTOM_WITHOUT_CONTROLS = scaleSize(120);
 
 export const TVNextEpisodeCountdown: FC<TVNextEpisodeCountdownProps> = ({

components/tv/TVSkipSegmentCard.tsx

@@ -33,15 +33,9 @@ export interface TVSkipSegmentCardProps {
   playButtonRef?: View | null;
 }
 
-// Position constants — kept in sync with TVNextEpisodeCountdown (the two
-// are mutually exclusive). Scaled to the screen so 4K TVs don't get a
-// card that floats far above the controls.
-//
-// BOTTOM_WITH_CONTROLS is tuned to sit just above the bottom controls bar
-// (metadata + seekbar + buttons ≈ 200px on 1080p). Previously 300, which
-// left the card hovering ~100px above the controls.
-const BOTTOM_WITH_CONTROLS = scaleSize(220);
-const BOTTOM_WITHOUT_CONTROLS = scaleSize(120);
+// Position constants - same as TVNextEpisodeCountdown (they're mutually exclusive)
+const BOTTOM_WITH_CONTROLS = 300;
+const BOTTOM_WITHOUT_CONTROLS = 120;
 
 export const TVSkipSegmentCard: FC<TVSkipSegmentCardProps> = ({
   show,

components/video-player/VideoPlayerView.tsx

@@ -1,30 +0,0 @@
-import * as React from "react";
-import type { MpvPlayerViewProps, MpvPlayerViewRef } from "@/modules";
-import { MpvPlayerView } from "@/modules";
-import { ExoPlayerView } from "@/modules/exoplayer-player";
-import {
-  getActiveVideoPlayer,
-  useSettings,
-  VideoPlayer,
-} from "@/utils/atoms/settings";
-
-/**
- * Unified video player view. MPV is the default on every platform; users
- * can opt into ExoPlayer on Android TV via settings.videoPlayer. Both
- * children conform to the same `MpvPlayerViewRef` interface, so the ref
- * is forwarded transparently regardless of which player is rendered.
- *
- * The Android-TV capability gate lives in getActiveVideoPlayer so that
- * the same resolver used for device-profile advertisement guarantees the
- * rendered backend matches what Jellyfin was told to stream for.
- */
-export const VideoPlayerView = React.forwardRef<
-  MpvPlayerViewRef,
-  MpvPlayerViewProps
->(function VideoPlayerView(props, ref) {
-  const { settings } = useSettings();
-  const useExo = getActiveVideoPlayer(settings) === VideoPlayer.ExoPlayer;
-
-  const Player = useExo ? ExoPlayerView : MpvPlayerView;
-  return <Player ref={ref} {...props} />;
-});

components/video-player/controls/Controls.tv.tsx

@@ -1132,16 +1132,7 @@ export const Controls: FC<Props> = ({
       {/* Skip intro card */}
       <TVSkipSegmentCard
         show={showSkipButton && !isCountdownActive}
-        onPress={() => {
-          // After the seek lands, showSkipButton flips false and this card
-          // unmounts. With controls visible the focus-stealing overlay is
-          // disabled, so without an explicit handoff the focus engine is
-          // stranded. Prime the play button to receive focus on the next
-          // render — when controls are hidden the focus overlay takes over
-          // naturally and this is a harmless no-op.
-          if (showControls) setFocusPlayButton(true);
-          skipIntro();
-        }}
+        onPress={skipIntro}
         type='intro'
         controlsVisible={showControls}
         refSetter={setSkipSegmentRef}
@@ -1156,11 +1147,7 @@ export const Controls: FC<Props> = ({
           (hasContentAfterCredits || !nextItem) &&
           !isCountdownActive
         }
-        onPress={() => {
-          // See the intro card above for the focus-handoff rationale.
-          if (showControls) setFocusPlayButton(true);
-          skipCredit();
-        }}
+        onPress={skipCredit}
         type='credits'
         controlsVisible={showControls}
         refSetter={setSkipSegmentRef}

components/video-player/controls/TechnicalInfoOverlay.tsx

@@ -213,10 +213,13 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
       );
 
       return {
+        container: mediaSource.Container,
         videoRange: videoStream?.VideoRangeType,
         bitDepth: videoStream?.BitDepth,
         audioChannels: audioStream?.Channels,
+        audioCodecFromSource: audioStream?.Codec,
         subtitleCodec: subtitleStream?.Codec,
+        subtitleTitle: subtitleStream?.DisplayTitle,
       };
     }, [mediaSource, currentAudioIndex, currentSubtitleIndex]);
 
@@ -302,14 +305,9 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
             <Text style={textStyle}>
               {info.videoWidth}x{info.videoHeight}
               {streamInfo?.bitDepth ? ` ${streamInfo.bitDepth}bit` : ""}
-              {/* Prefer the player-reported HDR format (authoritative —
-                  what's actually being decoded) over Jellyfin metadata. */}
-              {info?.hdrFormat
-                ? ` ${info.hdrFormat}`
-                : (() => {
-                    const videoRange = formatVideoRange(streamInfo?.videoRange);
-                    return videoRange ? ` ${videoRange}` : "";
-                  })()}
+              {formatVideoRange(streamInfo?.videoRange)
+                ? ` ${formatVideoRange(streamInfo?.videoRange)}`
+                : ""}
             </Text>
           )}
           {info?.videoCodec && (
@@ -321,17 +319,8 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
           {info?.audioCodec && (
             <Text style={textStyle}>
               Audio: {formatCodec(info.audioCodec)}
-              {/* Prefer player-reported channel count; fall back to
-                  Jellyfin metadata for MPV which doesn't populate it. */}
-              {(() => {
-                const audioChannels =
-                  info.audioChannels ?? streamInfo?.audioChannels;
-                return audioChannels
-                  ? ` ${formatAudioChannels(audioChannels)}`
-                  : "";
-              })()}
-              {info.audioSampleRate
-                ? ` @ ${(info.audioSampleRate / 1000).toFixed(1)}kHz`
+              {streamInfo?.audioChannels
+                ? ` ${formatAudioChannels(streamInfo.audioChannels)}`
                 : ""}
             </Text>
           )}
@@ -350,17 +339,6 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
                   : "N/A"}
             </Text>
           )}
-          {(info?.colorSpace || info?.colorRange || info?.colorTransfer) && (
-            <Text style={textStyle}>
-              Color:{" "}
-              {[info.colorSpace, info.colorRange, info.colorTransfer]
-                .filter(Boolean)
-                .join(" / ")}
-            </Text>
-          )}
-          {info?.videoCodecs && (
-            <Text style={textStyle}>Codec tag: {info.videoCodecs}</Text>
-          )}
           {info?.cacheSeconds !== undefined && (
             <Text style={textStyle}>
               Buffer: {info.cacheSeconds.toFixed(1)}s
@@ -378,12 +356,6 @@ export const TechnicalInfoOverlay: FC<TechnicalInfoOverlayProps> = memo(
               {info.hwdec ? ` / ${info.hwdec}` : ""}
             </Text>
           )}
-          {info?.decoderName && (
-            <Text style={textStyle}>
-              Decoder: {info.decoderName}
-              {info.decoderType ? ` (${info.decoderType})` : ""}
-            </Text>
-          )}
           {info?.estimatedVfFps !== undefined && (
             <Text style={textStyle}>
               Output FPS: {info.estimatedVfFps.toFixed(2)}

components/video-player/controls/TimeDisplay.tsx

@@ -20,7 +20,6 @@ export const TimeDisplay: FC<TimeDisplayProps> = ({
   const { t } = useTranslation();
 
   const getFinishTime = () => {
-    if (!Number.isFinite(remainingTime)) return "—";
     const now = new Date();
     // remainingTime is in ms
     const finishTime = new Date(now.getTime() + remainingTime);

components/video-player/controls/hooks/useVideoTime.ts

@@ -17,10 +17,7 @@ interface UseVideoTimeProps {
  */
 export function useVideoTime({ progress, max, isSeeking }: UseVideoTimeProps) {
   const [currentTime, setCurrentTime] = useState(0);
-  // Start at 0 (not Infinity) so the controls' first paint — before the first
-  // progress/max update — shows "0:00" instead of formatting Infinity into
-  // "Infinityh NaNm NaNs" and an Invalid Date for "ends at".
-  const [remainingTime, setRemainingTime] = useState(0);
+  const [remainingTime, setRemainingTime] = useState(Number.POSITIVE_INFINITY);
 
   const lastCurrentTimeRef = useRef(0);
   const lastRemainingTimeRef = useRef(0);

hooks/useWifiSSID.ts

@@ -1,125 +1,5 @@
-import { useCallback, useEffect, useState } from "react";
-import { Platform } from "react-native";
-import { getSSID } from "@/modules/wifi-ssid";
-
-export type PermissionStatus =
-  | "granted"
-  | "denied"
-  | "undetermined"
-  | "unavailable";
-
-export interface UseWifiSSIDReturn {
-  ssid: string | null;
-  permissionStatus: PermissionStatus;
-  requestPermission: () => Promise<boolean>;
-  isLoading: boolean;
-}
-
-// WiFi SSID is not available on tvOS
-if (Platform.isTV) {
-  // Export a stub hook for tvOS
-  module.exports = {
-    useWifiSSID: (): UseWifiSSIDReturn => ({
-      ssid: null,
-      permissionStatus: "unavailable" as PermissionStatus,
-      requestPermission: async () => false,
-      isLoading: false,
-    }),
-  };
-}
-
-// Only import Location on non-TV platforms
-const Location = Platform.isTV ? null : require("expo-location");
-
-function mapLocationStatus(status: number | undefined): PermissionStatus {
-  if (!Location) return "unavailable";
-  switch (status) {
-    case Location.PermissionStatus?.GRANTED:
-      return "granted";
-    case Location.PermissionStatus?.DENIED:
-      return "denied";
-    default:
-      return "undetermined";
-  }
-}
-
-export function useWifiSSID(): UseWifiSSIDReturn {
-  const [ssid, setSSID] = useState<string | null>(null);
-  const [permissionStatus, setPermissionStatus] = useState<PermissionStatus>(
-    Platform.isTV ? "unavailable" : "undetermined",
-  );
-  const [isLoading, setIsLoading] = useState(!Platform.isTV);
-
-  const fetchSSID = useCallback(async () => {
-    if (Platform.isTV) return;
-    const result = await getSSID();
-    setSSID(result);
-  }, []);
-
-  const requestPermission = useCallback(async (): Promise<boolean> => {
-    if (Platform.isTV || !Location) {
-      setPermissionStatus("unavailable");
-      return false;
-    }
-
-    try {
-      const { status } = await Location.requestForegroundPermissionsAsync();
-      const newStatus = mapLocationStatus(status);
-      setPermissionStatus(newStatus);
-
-      if (newStatus === "granted") {
-        await fetchSSID();
-      }
-
-      return newStatus === "granted";
-    } catch {
-      setPermissionStatus("unavailable");
-      return false;
-    }
-  }, [fetchSSID]);
-
-  useEffect(() => {
-    if (Platform.isTV || !Location) {
-      setIsLoading(false);
-      return;
-    }
-
-    async function initialize() {
-      setIsLoading(true);
-      try {
-        const { status } = await Location.getForegroundPermissionsAsync();
-        const mappedStatus = mapLocationStatus(status);
-        setPermissionStatus(mappedStatus);
-
-        if (mappedStatus === "granted") {
-          await fetchSSID();
-        }
-      } catch {
-        setPermissionStatus("unavailable");
-      }
-      setIsLoading(false);
-    }
-
-    initialize();
-  }, [fetchSSID]);
-
-  // Refresh SSID when permission status changes to granted
-  useEffect(() => {
-    if (Platform.isTV) return;
-
-    if (permissionStatus === "granted") {
-      fetchSSID();
-
-      // Also set up an interval to periodically check SSID
-      const interval = setInterval(fetchSSID, 10000); // Check every 10 seconds
-      return () => clearInterval(interval);
-    }
-  }, [permissionStatus, fetchSSID]);
-
-  return {
-    ssid,
-    permissionStatus,
-    requestPermission,
-    isLoading,
-  };
-}
+export {
+  type PermissionStatus,
+  type UseWifiSSIDReturn,
+  useWifiSsid as useWifiSSID,
+} from "@/providers/WifiSsidProvider";

modules/exoplayer-player/android/build.gradle

@@ -1,68 +0,0 @@
-apply plugin: 'com.android.library'
-
-group = 'expo.modules.exoplayerplayer'
-version = '0.1.0'
-
-def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
-apply from: expoModulesCorePlugin
-applyKotlinExpoModulesCorePlugin()
-useCoreDependencies()
-useExpoPublishing()
-
-def useManagedAndroidSdkVersions = false
-if (useManagedAndroidSdkVersions) {
-  useDefaultAndroidSdkVersions()
-} else {
-  buildscript {
-    ext.safeExtGet = { prop, fallback ->
-      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-    }
-  }
-  project.android {
-    compileSdkVersion safeExtGet("compileSdkVersion", 36)
-    defaultConfig {
-      minSdkVersion safeExtGet("minSdkVersion", 26)
-      targetSdkVersion safeExtGet("targetSdkVersion", 36)
-    }
-  }
-}
-
-android {
-  namespace "expo.modules.exoplayerplayer"
-  defaultConfig {
-    versionCode 1
-    versionName "0.1.0"
-  }
-  lintOptions {
-    abortOnError false
-  }
-}
-
-dependencies {
-  // Media3 (ExoPlayer). The default tracks react-native-track-player's
-  // pinned version (currently 1.10.1) so we don't end up with two media3
-  // versions on the classpath and duplicate-class errors. The
-  // DASH/SmoothStreaming/RTSP artifacts that RNTP pulls in are excluded
-  // globally via plugins/withExcludeMedia3Dash.js.
-  def media3Version = safeExtGet('media3Version', '1.10.1')
-  implementation "androidx.media3:media3-exoplayer:${media3Version}"
-  implementation "androidx.media3:media3-exoplayer-hls:${media3Version}"
-  implementation "androidx.media3:media3-ui:${media3Version}"
-  implementation "androidx.media3:media3-common:${media3Version}"
-
-  // FFmpeg software decoders — DTS / TrueHD / AC-4 / WMA / older video
-  // codecs that MediaCodec doesn't ship with on most Android TVs.
-  //
-  // This is the Jellyfin-published distribution of media3-decoder-ffmpeg
-  // with prebuilt native libraries (the upstream androidx artifact is a
-  // stub that requires building FFmpeg yourself). RNTP already pulls
-  // 1.9.0+1 in transitively, so declaring it here is mostly defensive —
-  // it guarantees we still get it if RNTP ever drops the dep.
-  //
-  // Version skew: this is built against media3 1.9.0 but RNTP (and we)
-  // resolve media3 core to 1.10.1. RNTP ships the same combination in
-  // production, and Media3 maintains binary compat for Renderer /
-  // RenderersFactory APIs across minor versions, so this works in
-  // practice. Re-evaluate when Jellyfin publishes a 1.10.x build.
-  implementation "org.jellyfin.media3:media3-ffmpeg-decoder:1.9.0+1"
-}

modules/exoplayer-player/android/src/main/java/expo/modules/exoplayerplayer/ExoPlayerModule.kt

@@ -1,193 +0,0 @@
-package expo.modules.exoplayerplayer
-
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-
-class ExoPlayerModule : Module() {
-    override fun definition() = ModuleDefinition {
-        Name("ExoPlayer")
-
-        // Enables the module to be used as a native view.
-        View(ExoPlayerView::class) {
-            // All video load options are passed via a single "source" prop,
-            // mirroring MpvPlayerView. MPV-only fields (voDriver, extra
-            // cacheConfig fields) are silently ignored.
-            Prop("source") { view: ExoPlayerView, source: Map<String, Any?>? ->
-                if (source == null) return@Prop
-
-                val urlString = source["url"] as? String ?: return@Prop
-
-                @Suppress("UNCHECKED_CAST")
-                val cacheConfig = source["cacheConfig"] as? Map<String, Any?>
-
-                val config = VideoLoadConfig(
-                    url = urlString,
-                    headers = source["headers"] as? Map<String, String>,
-                    externalSubtitles = source["externalSubtitles"] as? List<String>,
-                    startPosition = (source["startPosition"] as? Number)?.toDouble(),
-                    autoplay = (source["autoplay"] as? Boolean) ?: true,
-                    initialSubtitleId = (source["initialSubtitleId"] as? Number)?.toInt(),
-                    initialAudioId = (source["initialAudioId"] as? Number)?.toInt(),
-                    cacheEnabled = cacheConfig?.get("enabled") as? String,
-                    cacheSeconds = (cacheConfig?.get("cacheSeconds") as? Number)?.toInt(),
-                    demuxerMaxBytes = (cacheConfig?.get("maxBytes") as? Number)?.toInt(),
-                    demuxerMaxBackBytes = (cacheConfig?.get("maxBackBytes") as? Number)?.toInt()
-                )
-
-                view.loadVideo(config)
-            }
-
-            // Now Playing metadata is iOS-only on MPV; no-op here (TV has
-            // no Control Center equivalent — Android handles media sessions
-            // via MediaSessionCompat which we don't wire up for TV).
-            Prop("nowPlayingMetadata") { _: ExoPlayerView, _: Map<String, String>? ->
-                // No-op
-            }
-
-            AsyncFunction("play") { view: ExoPlayerView ->
-                view.play()
-            }
-
-            AsyncFunction("pause") { view: ExoPlayerView ->
-                view.pause()
-            }
-
-            AsyncFunction("destroy") { view: ExoPlayerView ->
-                view.destroy()
-            }
-
-            AsyncFunction("seekTo") { view: ExoPlayerView, position: Double ->
-                view.seekTo(position)
-            }
-
-            AsyncFunction("seekBy") { view: ExoPlayerView, offset: Double ->
-                view.seekBy(offset)
-            }
-
-            AsyncFunction("setSpeed") { view: ExoPlayerView, speed: Double ->
-                view.setSpeed(speed)
-            }
-
-            AsyncFunction("getSpeed") { view: ExoPlayerView ->
-                view.getSpeed()
-            }
-
-            AsyncFunction("isPaused") { view: ExoPlayerView ->
-                view.isPaused()
-            }
-
-            AsyncFunction("getCurrentPosition") { view: ExoPlayerView ->
-                view.getCurrentPosition()
-            }
-
-            AsyncFunction("getDuration") { view: ExoPlayerView ->
-                view.getDuration()
-            }
-
-            // Picture in Picture — TV does not use PiP; safe no-ops.
-            AsyncFunction("startPictureInPicture") { _: ExoPlayerView ->
-                // No-op
-            }
-
-            AsyncFunction("stopPictureInPicture") { _: ExoPlayerView ->
-                // No-op
-            }
-
-            AsyncFunction("isPictureInPictureSupported") { _: ExoPlayerView ->
-                false
-            }
-
-            AsyncFunction("isPictureInPictureActive") { _: ExoPlayerView ->
-                false
-            }
-
-            // Subtitle functions
-            AsyncFunction("getSubtitleTracks") { view: ExoPlayerView ->
-                view.getSubtitleTracks()
-            }
-
-            AsyncFunction("setSubtitleTrack") { view: ExoPlayerView, trackId: Int ->
-                view.setSubtitleTrack(trackId)
-            }
-
-            AsyncFunction("disableSubtitles") { view: ExoPlayerView ->
-                view.disableSubtitles()
-            }
-
-            AsyncFunction("getCurrentSubtitleTrack") { view: ExoPlayerView ->
-                view.getCurrentSubtitleTrack()
-            }
-
-            AsyncFunction("addSubtitleFile") { view: ExoPlayerView, url: String, select: Boolean ->
-                view.addSubtitleFile(url, select)
-            }
-
-            // Subtitle positioning / styling
-            AsyncFunction("setSubtitlePosition") { view: ExoPlayerView, position: Int ->
-                view.setSubtitlePosition(position)
-            }
-
-            AsyncFunction("setSubtitleScale") { view: ExoPlayerView, scale: Double ->
-                view.setSubtitleScale(scale)
-            }
-
-            AsyncFunction("setSubtitleMarginY") { view: ExoPlayerView, margin: Int ->
-                view.setSubtitleMarginY(margin)
-            }
-
-            AsyncFunction("setSubtitleAlignX") { _: ExoPlayerView, _: String ->
-                // No-op — SubtitleView follows authored cue alignment.
-            }
-
-            AsyncFunction("setSubtitleAlignY") { view: ExoPlayerView, alignment: String ->
-                view.setSubtitleAlignY(alignment)
-            }
-
-            AsyncFunction("setSubtitleFontSize") { view: ExoPlayerView, size: Int ->
-                view.setSubtitleFontSize(size)
-            }
-
-            AsyncFunction("setSubtitleBorderStyle") { view: ExoPlayerView, style: String ->
-                view.setSubtitleBorderStyle(style)
-            }
-
-            AsyncFunction("setSubtitleBackgroundColor") { view: ExoPlayerView, color: String ->
-                view.setSubtitleBackgroundColor(color)
-            }
-
-            AsyncFunction("setSubtitleAssOverride") { _: ExoPlayerView, _: String ->
-                // No-op — libass-specific, no Media3 equivalent.
-            }
-
-            // Audio track functions
-            AsyncFunction("getAudioTracks") { view: ExoPlayerView ->
-                view.getAudioTracks()
-            }
-
-            AsyncFunction("setAudioTrack") { view: ExoPlayerView, trackId: Int ->
-                view.setAudioTrack(trackId)
-            }
-
-            AsyncFunction("getCurrentAudioTrack") { view: ExoPlayerView ->
-                view.getCurrentAudioTrack()
-            }
-
-            // Video scaling
-            AsyncFunction("setZoomedToFill") { view: ExoPlayerView, zoomed: Boolean ->
-                view.setZoomedToFill(zoomed)
-            }
-
-            AsyncFunction("isZoomedToFill") { view: ExoPlayerView ->
-                view.isZoomedToFill()
-            }
-
-            // Technical info
-            AsyncFunction("getTechnicalInfo") { view: ExoPlayerView ->
-                view.getTechnicalInfo()
-            }
-
-            // Events that the view can send to JavaScript — same set as MPV.
-            Events("onLoad", "onPlaybackStateChange", "onProgress", "onError", "onTracksReady", "onPictureInPictureChange")
-        }
-    }
-}

modules/exoplayer-player/android/src/main/java/expo/modules/exoplayerplayer/ExoPlayerView.kt

@@ -1,976 +0,0 @@
-@file:OptIn(androidx.media3.common.util.UnstableApi::class)
-
-package expo.modules.exoplayerplayer
-
-import android.content.Context
-import android.graphics.Color
-import android.graphics.Typeface
-import android.net.Uri
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import android.view.ViewGroup
-import androidx.media3.common.AudioAttributes
-import androidx.media3.common.C
-import androidx.media3.common.ColorInfo
-import androidx.media3.common.Format
-import androidx.media3.common.MediaItem
-import androidx.media3.common.PlaybackParameters
-import androidx.media3.common.Player
-import androidx.media3.common.TrackSelectionOverride
-import androidx.media3.common.Tracks
-import androidx.media3.exoplayer.DefaultLoadControl
-import androidx.media3.exoplayer.ExoPlayer
-import androidx.media3.exoplayer.analytics.AnalyticsListener
-import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
-import androidx.media3.datasource.DefaultDataSource
-import androidx.media3.ui.CaptionStyleCompat
-import androidx.media3.ui.PlayerView
-import androidx.media3.ui.SubtitleView
-import expo.modules.kotlin.AppContext
-import expo.modules.kotlin.viewevent.EventDispatcher
-import expo.modules.kotlin.views.ExpoView
-
-/**
- * Configuration for loading a video. Mirrors MpvPlayerView.VideoLoadConfig —
- * MPV-only fields are accepted and ignored.
- */
-data class VideoLoadConfig(
-    val url: String,
-    val headers: Map<String, String>? = null,
-    val externalSubtitles: List<String>? = null,
-    val startPosition: Double? = null,
-    val autoplay: Boolean = true,
-    val initialSubtitleId: Int? = null,
-    val initialAudioId: Int? = null,
-    val cacheEnabled: String? = null,
-    val cacheSeconds: Int? = null,
-    val demuxerMaxBytes: Int? = null,
-    val demuxerMaxBackBytes: Int? = null,
-)
-
-/**
- * ExoPlayerView — ExpoView that hosts a Media3 ExoPlayer instance.
- *
- * Implements the same JS contract (events, ref methods, 1-based track IDs)
- * as MpvPlayerView so the React layer can swap between the two without
- * changes. Subtitle styling is mapped to androidx.media3.ui.SubtitleView +
- * CaptionStyleCompat. PiP methods are no-ops (TV doesn't use PiP).
- */
-class ExoPlayerView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
-
-    companion object {
-        private const val TAG = "ExoPlayerView"
-        private const val PROGRESS_INTERVAL_MS = 1000L
-    }
-
-    // Event dispatchers — names must match the Events() declaration in the module.
-    val onLoad by EventDispatcher()
-    val onPlaybackStateChange by EventDispatcher()
-    val onProgress by EventDispatcher()
-    val onError by EventDispatcher()
-    val onTracksReady by EventDispatcher()
-    val onPictureInPictureChange by EventDispatcher()
-
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    private var player: ExoPlayer? = null
-    private val playerView: PlayerView
-    private val subtitleView: SubtitleView?
-
-    private var currentUrl: String? = null
-    private var pendingConfig: VideoLoadConfig? = null
-    private var tracksReadyFired: Boolean = false
-
-    // Resume position handed to setMediaSource() on load. seekTo() uses it to
-    // drop the redundant re-seek the JS layer fires once tracks are ready
-    // (direct-player seeks to the same resume position). ExoPlayer re-buffers
-    // on every seek — even a no-op to the current position — so without this
-    // the start stutters.
-    private var loadStartPositionMs: Long = 0L
-
-    // Side-loaded subtitle configurations accumulated across loadVideo and
-    // addSubtitleFile. Media3 doesn't expose the live SubtitleConfiguration
-    // list on a playing MediaItem, so we shadow it here to preserve prior
-    // side-loaded subs when addSubtitleFile rebuilds the MediaItem.
-    private var sideLoadedSubs: List<MediaItem.SubtitleConfiguration> = emptyList()
-
-    // 1-based track ID mappings (matching MPV's contract).
-    // Each list is rebuilt on Tracks changed.
-    private var subtitleTrackList: List<TrackEntry> = emptyList()
-    private var audioTrackList: List<TrackEntry> = emptyList()
-    private var currentSubtitleId: Int = 0
-    private var currentAudioId: Int = 0
-
-    // Subtitle styling state — applied to the embedded SubtitleView.
-    private var subtitleScale: Float = 1f
-    private var subtitleFontSizePct: Int? = null // 0-100
-    // Last-write-wins override of the vertical position fraction
-    // (null = fall back to subtitleAlignY). Both setSubtitlePosition
-    // (0-100, MPV convention where 100 = bottom) and setSubtitleMarginY
-    // (px) funnel into this single SubtitleView API.
-    private var subtitleBottomFraction: Float? = null
-    private var subtitleAlignY: String = "bottom"
-    // Background color carries its own alpha (parsed from #RRGGBBAA in
-    // setSubtitleBackgroundColor) so no separate enabled/opacity flags.
-    private var subtitleBackgroundColor: Int = Color.argb(0, 0, 0, 0)
-    private var subtitleBorderStyle: String = "outline-and-shadow"
-
-    private var isZoomedToFill: Boolean = false
-
-    // Captured by analyticsListener; surfaced via getTechnicalInfo().
-    // Reset on destroy() and (for decoder names) on track changes.
-    private var videoDecoderName: String? = null
-    private var audioDecoderName: String? = null
-    private var cumulativeDroppedFrames: Int = 0
-
-    private val analyticsListener = object : AnalyticsListener {
-        override fun onVideoDecoderInitialized(
-            eventTime: AnalyticsListener.EventTime,
-            decoderName: String,
-            initializedTimestampMs: Long,
-        ) {
-            videoDecoderName = decoderName
-        }
-
-        override fun onAudioDecoderInitialized(
-            eventTime: AnalyticsListener.EventTime,
-            decoderName: String,
-            initializedTimestampMs: Long,
-        ) {
-            audioDecoderName = decoderName
-        }
-
-        override fun onDroppedVideoFrames(
-            eventTime: AnalyticsListener.EventTime,
-            droppedFrames: Int,
-            elapsedMs: Long,
-        ) {
-            // Incremental count since last call; accumulate for a cumulative
-            // total that matches MPV's droppedFrames semantics.
-            cumulativeDroppedFrames += droppedFrames
-        }
-    }
-
-    private val playerListener = object : Player.Listener {
-        override fun onPlaybackStateChanged(playbackState: Int) {
-            when (playbackState) {
-                Player.STATE_BUFFERING -> {
-                    onPlaybackStateChange(mapOf("isLoading" to true))
-                }
-                Player.STATE_READY -> {
-                    onPlaybackStateChange(mapOf(
-                        "isLoading" to false,
-                        "isReadyToSeek" to true
-                    ))
-                    if (!tracksReadyFired) {
-                        tracksReadyFired = true
-                        rebuildTrackMaps(player?.currentTracks)
-                        onTracksReady(emptyMap<String, Any>())
-                    }
-                }
-                Player.STATE_ENDED -> {
-                    onPlaybackStateChange(mapOf(
-                        "isPlaying" to false,
-                        "isPaused" to true
-                    ))
-                }
-                Player.STATE_IDLE -> {
-                    // no-op
-                }
-            }
-        }
-
-        override fun onIsPlayingChanged(isPlaying: Boolean) {
-            onPlaybackStateChange(mapOf(
-                "isPlaying" to isPlaying,
-                "isPaused" to !isPlaying
-            ))
-        }
-
-        override fun onPlayerErrorChanged(error: androidx.media3.common.PlaybackException?) {
-            val message = error?.message ?: "Unknown playback error"
-            Log.e(TAG, "Player error: $message", error)
-            onError(mapOf("error" to message))
-        }
-
-        override fun onTracksChanged(tracks: Tracks) {
-            rebuildTrackMaps(tracks)
-            // currentSubtitleId is a hand-maintained cache (ExoPlayer has no
-            // mpv-style "sid" property to read live), so re-derive it from the
-            // actual selection on every track change. Without this, any path
-            // that selects a track without going through setSubtitleTrack —
-            // notably addSubtitleFile(select=true), which clears the text
-            // override and lets the new SELECTION_FLAG_DEFAULT sub render —
-            // leaves the cache stale and getCurrentSubtitleTrack() reporting
-            // the old id. Run before applyInitialTrackSelections() so an
-            // explicit initial selection still wins.
-            syncCurrentSubtitleIdFromSelection(tracks)
-            applyInitialTrackSelections()
-            // A track change can re-initialize the codec under a different
-            // name (e.g. adaptive switch from HEVC to AV1). Clear stale
-            // decoder names so getTechnicalInfo() doesn't report the
-            // previous codec until the next onVideoDecoderInitialized fires.
-            videoDecoderName = null
-            audioDecoderName = null
-        }
-    }
-
-    private val progressRunnable = object : Runnable {
-        override fun run() {
-            val p = player ?: return
-            val positionMs = p.currentPosition
-            val durationMs = p.duration
-            val bufferedMs = p.bufferedPosition
-
-            val positionSec = positionMs / 1000.0
-            val durationSec = if (durationMs > 0) durationMs / 1000.0 else 0.0
-            val cacheSec = if (bufferedMs > positionMs) (bufferedMs - positionMs) / 1000.0 else 0.0
-
-            onProgress(mapOf(
-                "position" to positionSec,
-                "duration" to durationSec,
-                "progress" to if (durationSec > 0) positionSec / durationSec else 0.0,
-                "cacheSeconds" to cacheSec
-            ))
-
-            mainHandler.postDelayed(this, PROGRESS_INTERVAL_MS)
-        }
-    }
-
-    init {
-        setBackgroundColor(Color.BLACK)
-
-        playerView = PlayerView(context).apply {
-            layoutParams = ViewGroup.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-            // SurfaceView-backed for parity with MPV (direct surface to
-            // SurfaceFlinger). PlayerView defaults to a SurfaceView, so no
-            // explicit setSurfaceType() call is needed; the int constants
-            // backing it are @IntDef private in Media3.
-            setUseController(false)
-            setResizeMode(androidx.media3.ui.AspectRatioFrameLayout.RESIZE_MODE_FIT)
-        }
-        subtitleView = playerView.subtitleView
-        addView(playerView)
-    }
-
-    // MARK: - Video Loading
-
-    fun loadVideo(config: VideoLoadConfig) {
-        if (currentUrl == config.url) return
-        currentUrl = config.url
-        pendingConfig = config
-        ensurePlayer(config)
-        loadInternal(config)
-    }
-
-    private fun ensurePlayer(config: VideoLoadConfig) {
-        if (player != null) return
-
-        val loadControl = buildLoadControl(config)
-
-        // PREFER extension renderers so the FFmpeg decoder (DTS / TrueHD /
-        // AC-4 / WMA / etc.) takes over when MediaCodec doesn't ship a
-        // hardware decoder for the format. MediaCodec remains the fallback.
-        val renderersFactory = androidx.media3.exoplayer.DefaultRenderersFactory(context)
-            .setExtensionRendererMode(
-                androidx.media3.exoplayer.DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER
-            )
-            .setEnableDecoderFallback(true)
-
-        val exo = ExoPlayer.Builder(context, renderersFactory)
-            .setLoadControl(loadControl)
-            .setAudioAttributes(
-                AudioAttributes.Builder()
-                    .setUsage(C.USAGE_MEDIA)
-                    .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE)
-                    .build(),
-                /* handleAudioFocus = */ true
-            )
-            .build()
-
-        exo.addListener(playerListener)
-        exo.addAnalyticsListener(analyticsListener)
-        exo.repeatMode = Player.REPEAT_MODE_OFF
-        player = exo
-        playerView.player = exo
-
-        applySubtitleStyle()
-    }
-
-    private fun buildLoadControl(config: VideoLoadConfig): DefaultLoadControl {
-        // Map MPV-style cache config to ExoPlayer's LoadControl.
-        val cacheEnabled = when (config.cacheEnabled) {
-            "no" -> false
-            "yes" -> true
-            else -> true // "auto"
-        }
-
-        // Buffer thresholds used as fallbacks when the user's cache config
-        // doesn't override them. Media3's own defaults changed in 1.6.0
-        // (bufferForPlaybackMs 2500→1000, afterRebuffer 5000→2000) for a
-        // faster start; we intentionally keep the older 2500/5000 here
-        // because low-RAM Android TVs with slow tuners benefit from the
-        // extra headroom before playback kicks in. Media3's DEFAULT_*
-        // IntDef fields are private, hence the literals.
-        val defaultMinBufferMs = 15000
-        val defaultBufferForPlaybackMs = 2500
-        val defaultBufferForPlaybackAfterRebufferMs = 5000
-
-        val targetBufferMs = if (!cacheEnabled) {
-            50000
-        } else {
-            val seconds = config.cacheSeconds?.coerceIn(5, 120) ?: 10
-            seconds * 1000
-        }
-
-        val backBufferMs = if (!cacheEnabled) {
-            0
-        } else {
-            val mb = config.demuxerMaxBackBytes ?: 50
-            // Heuristic: 1 MB ≈ 1s of typical 1080p bitrate.
-            (mb * 1000).coerceAtLeast(1000)
-        }
-
-        val builder = DefaultLoadControl.Builder()
-            .setTargetBufferBytes(if (!cacheEnabled) 0 else ((config.demuxerMaxBytes ?: 150) * 1024 * 1024))
-            .setBufferDurationsMs(
-                /* minBufferMs = */ defaultMinBufferMs,
-                /* maxBufferMs = */ targetBufferMs,
-                /* bufferForPlaybackMs = */ defaultBufferForPlaybackMs,
-                /* bufferForPlaybackAfterRebufferMs = */ defaultBufferForPlaybackAfterRebufferMs
-            )
-        if (cacheEnabled) {
-            builder.setBackBuffer(backBufferMs, /* retainBackBufferFromKeyframe = */ true)
-        }
-        return builder.build()
-    }
-
-    private fun loadInternal(config: VideoLoadConfig) {
-        val p = player ?: return
-
-        val httpFactory = androidx.media3.datasource.DefaultHttpDataSource.Factory()
-            .setDefaultRequestProperties(config.headers ?: emptyMap())
-        val dataSourceFactory = DefaultDataSource.Factory(context, httpFactory)
-
-        val mediaItem = buildMediaItem(config)
-
-        val mediaSource = DefaultMediaSourceFactory(dataSourceFactory)
-            .createMediaSource(mediaItem)
-
-        // Resolve the resume position once and hand it to setMediaSource() so
-        // ExoPlayer prepares from that position directly. Calling prepare()
-        // first (which buffers from 0) and seekTo() afterwards makes the
-        // opening seconds replay from the start before jumping to the resume
-        // point — the "repeats the first few seconds" symptom. C.TIME_UNSET
-        // falls back to the media's default start position (0).
-        val startMs = config.startPosition?.let { sp ->
-            if (sp > 0) (sp * 1000).toLong() else C.TIME_UNSET
-        } ?: C.TIME_UNSET
-
-        loadStartPositionMs = if (startMs != C.TIME_UNSET) startMs else 0L
-
-        p.setMediaSource(mediaSource, startMs)
-        p.prepare()
-
-        if (config.autoplay) {
-            p.play()
-        }
-
-        onLoad(mapOf("url" to config.url))
-        startProgressLoop()
-    }
-
-    private fun buildMediaItem(config: VideoLoadConfig): MediaItem {
-        val builder = MediaItem.Builder().setUri(config.url)
-
-        // External subtitles: add as side-loaded SubtitleConfigurations.
-        // MIME-type sniffed from the file extension.
-        val subs = config.externalSubtitles
-        if (!subs.isNullOrEmpty()) {
-            val subtitleConfigs = subs.mapNotNull { subUrl ->
-                val mime = mimeTypeForSubtitleUrl(subUrl) ?: return@mapNotNull null
-                MediaItem.SubtitleConfiguration.Builder(Uri.parse(subUrl))
-                    .setMimeType(mime)
-                    .setSelectionFlags(C.SELECTION_FLAG_DEFAULT)
-                    .build()
-            }
-            if (subtitleConfigs.isNotEmpty()) {
-                sideLoadedSubs = subtitleConfigs
-                builder.setSubtitleConfigurations(subtitleConfigs)
-            } else {
-                sideLoadedSubs = emptyList()
-            }
-        } else {
-            sideLoadedSubs = emptyList()
-        }
-
-        return builder.build()
-    }
-
-    private fun mimeTypeForSubtitleUrl(url: String): String? {
-        val lower = url.substringBeforeLast('?').lowercase()
-        return when {
-            lower.endsWith(".vtt") || lower.endsWith(".webvtt") -> "text/vtt"
-            lower.endsWith(".srt") -> "application/x-subrip"
-            lower.endsWith(".ssa") || lower.endsWith(".ass") -> "text/x-ssa"
-            lower.endsWith(".ttml") || lower.endsWith(".xml") -> "application/ttml+xml"
-            else -> null
-        }
-    }
-
-    // MARK: - Playback Controls
-
-    fun play() {
-        player?.play()
-    }
-
-    fun pause() {
-        player?.pause()
-    }
-
-    fun destroy() {
-        stopProgressLoop()
-        player?.release()
-        player = null
-        playerView.player = null
-        tracksReadyFired = false
-        currentUrl = null
-        loadStartPositionMs = 0L
-        sideLoadedSubs = emptyList()
-        subtitleTrackList = emptyList()
-        audioTrackList = emptyList()
-        currentSubtitleId = 0
-        currentAudioId = 0
-        videoDecoderName = null
-        audioDecoderName = null
-        cumulativeDroppedFrames = 0
-    }
-
-    fun seekTo(positionSec: Double) {
-        val targetMs = (positionSec * 1000).toLong()
-        // Drop the redundant initial seek that mirrors the resume position we
-        // already applied via setMediaSource() — see loadInternal. Only the
-        // first seek after load is eligible, so a genuine seek to ~the start
-        // later on still works.
-        if (loadStartPositionMs > 0 && Math.abs(targetMs - loadStartPositionMs) < 1000L) {
-            loadStartPositionMs = 0L
-            return
-        }
-        loadStartPositionMs = 0L
-        player?.seekTo(targetMs)
-    }
-
-    fun seekBy(offsetSec: Double) {
-        val p = player ?: return
-        val target = (p.currentPosition + offsetSec * 1000).coerceAtLeast(0.0)
-        p.seekTo(target.toLong())
-    }
-
-    fun setSpeed(speed: Double) {
-        player?.playbackParameters = PlaybackParameters(speed.toFloat())
-    }
-
-    fun getSpeed(): Float {
-        return player?.playbackParameters?.speed ?: 1f
-    }
-
-    fun isPaused(): Boolean {
-        return player?.isPlaying == false
-    }
-
-    fun getCurrentPosition(): Double {
-        return (player?.currentPosition ?: 0L) / 1000.0
-    }
-
-    fun getDuration(): Double {
-        val d = player?.duration ?: 0L
-        return if (d > 0) d / 1000.0 else 0.0
-    }
-
-    // MARK: - Track Mapping (1-based IDs to match MPV's contract)
-
-    data class TrackEntry(
-        val id: Int,          // 1-based JS-facing ID
-        val trackGroupIndex: Int,
-        val trackIndex: Int,
-        val format: Format,
-    )
-
-    private fun rebuildTrackMaps(tracks: Tracks?) {
-        if (tracks == null) return
-
-        val subtitles = mutableListOf<TrackEntry>()
-        val audios = mutableListOf<TrackEntry>()
-
-        tracks.groups.forEachIndexed { groupIndex, group ->
-            val rendererType = group.type
-            // Skip groups that have no tracks the player supports
-            for (trackIdx in 0 until group.length) {
-                if (!group.isTrackSupported(trackIdx)) continue
-                val format = group.getTrackFormat(trackIdx)
-                val entry = TrackEntry(
-                    id = 0, // assigned per-list below
-                    trackGroupIndex = groupIndex,
-                    trackIndex = trackIdx,
-                    format = format
-                )
-                when (rendererType) {
-                    C.TRACK_TYPE_TEXT -> subtitles.add(entry)
-                    C.TRACK_TYPE_AUDIO -> audios.add(entry)
-                    else -> { /* video / metadata ignored */ }
-                }
-            }
-        }
-
-        // Assign 1-based IDs per track kind.
-        subtitles.forEachIndexed { i, e -> subtitles[i] = e.copy(id = i + 1) }
-        audios.forEachIndexed { i, e -> audios[i] = e.copy(id = i + 1) }
-
-        subtitleTrackList = subtitles
-        audioTrackList = audios
-    }
-
-    /**
-     * Mirror the player's actually-selected text track into [currentSubtitleId].
-     * Must run after [rebuildTrackMaps] so the 1-based IDs in [subtitleTrackList]
-     * are current for this [tracks] snapshot. Falls back to 0 (subs off) when no
-     * text track is selected.
-     */
-    private fun syncCurrentSubtitleIdFromSelection(tracks: Tracks) {
-        val groups = tracks.groups
-        val selected = subtitleTrackList.firstOrNull { entry ->
-            groups[entry.trackGroupIndex].isTrackSelected(entry.trackIndex)
-        }
-        currentSubtitleId = selected?.id ?: 0
-    }
-
-    private fun applyInitialTrackSelections() {
-        val p = player ?: return
-        val cfg = pendingConfig ?: return
-
-        // Initial subtitle/audio selection by 1-based ID.
-        if (cfg.initialAudioId != null && cfg.initialAudioId > 0) {
-            setAudioTrack(cfg.initialAudioId)
-        }
-        if (cfg.initialSubtitleId == null || cfg.initialSubtitleId <= 0) {
-            disableSubtitles()
-        } else {
-            setSubtitleTrack(cfg.initialSubtitleId)
-        }
-
-        // Only apply once per source load.
-        pendingConfig = null
-    }
-
-    // MARK: - Subtitle Controls
-
-    fun getSubtitleTracks(): List<Map<String, Any>> {
-        return subtitleTrackList.map { entry ->
-            mapOf(
-                "id" to entry.id,
-                "title" to (entry.format.label ?: ""),
-                "lang" to (entry.format.language ?: "")
-            )
-        }
-    }
-
-    fun setSubtitleTrack(trackId: Int) {
-        val p = player ?: return
-        val entry = subtitleTrackList.firstOrNull { it.id == trackId } ?: return
-        val matchedGroup = p.currentTracks.groups[entry.trackGroupIndex].mediaTrackGroup
-
-        // setOverrideForType replaces any existing override of the same
-        // track type — exactly what we want for single-track subtitle pickers.
-        val params = p.trackSelectionParameters.buildUpon()
-            .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, false)
-            .setOverrideForType(TrackSelectionOverride(matchedGroup, entry.trackIndex))
-            .build()
-        p.trackSelectionParameters = params
-        currentSubtitleId = trackId
-    }
-
-    fun disableSubtitles() {
-        val p = player ?: return
-        val params = p.trackSelectionParameters.buildUpon()
-            .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, true)
-            .build()
-        p.trackSelectionParameters = params
-        currentSubtitleId = 0
-    }
-
-    fun getCurrentSubtitleTrack(): Int = currentSubtitleId
-
-    fun addSubtitleFile(url: String, select: Boolean) {
-        val p = player ?: return
-        val mime = mimeTypeForSubtitleUrl(url) ?: return
-        val currentMediaItem = p.currentMediaItem ?: return
-        val newSubConfig = MediaItem.SubtitleConfiguration.Builder(Uri.parse(url))
-            .setMimeType(mime)
-            .setSelectionFlags(if (select) C.SELECTION_FLAG_DEFAULT else 0)
-            .build()
-
-        // Rebuild with the full accumulated list so previously loaded
-        // side-loaded subs (from VideoLoadConfig.externalSubtitles or
-        // earlier addSubtitleFile calls) survive.
-        val combined = sideLoadedSubs + newSubConfig
-        sideLoadedSubs = combined
-
-        val rebuilt = currentMediaItem.buildUpon()
-            .setSubtitleConfigurations(combined)
-            .build()
-
-        val wasPlaying = p.isPlaying
-        val pos = p.currentPosition
-        p.setMediaItem(rebuilt, pos)
-        p.prepare()
-        if (wasPlaying) p.play()
-
-        // Re-enabling text tracks alone isn't enough: a prior text override
-        // (e.g. left in place by disableSubtitles, or set by setSubtitleTrack
-        // before this add) survives the MediaItem rebuild and, since embedded
-        // subtitle groups persist across it, would win over the new sub's
-        // SELECTION_FLAG_DEFAULT. Clear any text override so the new default
-        // sub is the one that renders.
-        if (select) {
-            val params = p.trackSelectionParameters.buildUpon()
-                .setTrackTypeDisabled(C.TRACK_TYPE_TEXT, false)
-                .clearOverridesOfType(C.TRACK_TYPE_TEXT)
-                .build()
-            p.trackSelectionParameters = params
-        }
-    }
-
-    // MARK: - Subtitle Positioning / Styling
-
-    fun setSubtitlePosition(position: Int) {
-        // position is 0-100 (MPV convention: 100 = bottom, 0 = top).
-        // Map to SubtitleView's bottom-padding fraction. Reserve a small
-        // margin so 100 doesn't hug the very bottom edge.
-        val clamped = position.coerceIn(0, 100)
-        subtitleBottomFraction = 0.95f - (clamped / 100f) * 0.87f
-        applySubtitleStyle()
-    }
-
-    fun setSubtitleScale(scale: Double) {
-        subtitleScale = scale.toFloat()
-        applySubtitleStyle()
-    }
-
-    fun setSubtitleMarginY(margin: Int) {
-        // Margin in px (approximate). SubtitleView only accepts a single
-        // bottom-padding fraction, so convert via a heuristic (1px ≈ 0.1%
-        // of view height, capped). Last-write-wins vs. setSubtitlePosition.
-        val fraction = (margin / 1000f).coerceIn(0.02f, 0.95f)
-        subtitleBottomFraction = fraction
-        applySubtitleStyle()
-    }
-
-    fun setSubtitleAlignY(alignment: String) {
-        subtitleAlignY = alignment
-        applySubtitleStyle()
-    }
-
-    fun setSubtitleFontSize(size: Int) {
-        subtitleFontSizePct = size
-        applySubtitleStyle()
-    }
-
-    fun setSubtitleBackgroundColor(colorHex: String) {
-        subtitleBackgroundColor = parseColor(colorHex, subtitleBackgroundColor)
-        applySubtitleStyle()
-    }
-
-    fun setSubtitleBorderStyle(style: String) {
-        subtitleBorderStyle = style
-        applySubtitleStyle()
-    }
-
-    private fun parseColor(hex: String, fallback: Int): Int {
-        return try {
-            when {
-                hex.startsWith("#") && hex.length == 9 -> {
-                    // #RRGGBBAA
-                    val r = hex.substring(1, 3).toInt(16)
-                    val g = hex.substring(3, 5).toInt(16)
-                    val b = hex.substring(5, 7).toInt(16)
-                    val a = hex.substring(7, 9).toInt(16)
-                    Color.argb(a, r, g, b)
-                }
-                hex.startsWith("#") && hex.length == 7 -> Color.parseColor(hex)
-                else -> fallback
-            }
-        } catch (_: Throwable) {
-            fallback
-        }
-    }
-
-    private fun applySubtitleStyle() {
-        val sv = subtitleView ?: return
-
-        // Text size: explicit % wins; otherwise scale the default.
-        val textSizeFraction = if (subtitleFontSizePct != null) {
-            (subtitleFontSizePct!! / 100f) * SubtitleView.DEFAULT_TEXT_SIZE_FRACTION
-        } else {
-            SubtitleView.DEFAULT_TEXT_SIZE_FRACTION * subtitleScale
-        }
-        sv.setFractionalTextSize(textSizeFraction)
-
-        // Vertical position: explicit fraction (from setSubtitlePosition /
-        // setSubtitleMarginY) wins; otherwise fall back to alignY mapping.
-        val alignYFraction = when (subtitleAlignY) {
-            "top" -> 0.9f
-            "center" -> 0.5f
-            else -> 0.08f // bottom
-        }
-        val bottomFraction = subtitleBottomFraction ?: alignYFraction
-        sv.setBottomPaddingFraction(bottomFraction.coerceIn(0.02f, 0.95f))
-
-        // Edge / background style.
-        val foreground = Color.WHITE
-        val edgeType: Int
-        val backgroundColor: Int
-        when (subtitleBorderStyle) {
-            "background-box" -> {
-                edgeType = CaptionStyleCompat.EDGE_TYPE_NONE
-                // subtitleBackgroundColor already carries its own alpha
-                // (parsed from #RRGGBBAA by setSubtitleBackgroundColor).
-                // Alpha 0 → transparent, matching user intent.
-                backgroundColor = subtitleBackgroundColor
-            }
-            else -> {
-                // "outline-and-shadow"
-                edgeType = if (subtitleAlignY == "center")
-                    CaptionStyleCompat.EDGE_TYPE_DROP_SHADOW
-                else
-                    CaptionStyleCompat.EDGE_TYPE_OUTLINE
-                backgroundColor = Color.TRANSPARENT
-            }
-        }
-
-        val style = CaptionStyleCompat(
-            foreground,
-            backgroundColor,
-            Color.TRANSPARENT,
-            edgeType,
-            Color.BLACK,
-            Typeface.SANS_SERIF
-        )
-        sv.setApplyEmbeddedStyles(false)
-        sv.setApplyEmbeddedFontSizes(false)
-        sv.setStyle(style)
-    }
-
-    // MARK: - Audio Track Controls
-
-    fun getAudioTracks(): List<Map<String, Any>> {
-        return audioTrackList.map { entry ->
-            // channelCount is Format.NO_VALUE (-1) when unknown — report 0.
-            val channels = if (entry.format.channelCount == Format.NO_VALUE) 0
-                else entry.format.channelCount
-            mapOf(
-                "id" to entry.id,
-                "title" to (entry.format.label ?: ""),
-                "lang" to (entry.format.language ?: ""),
-                "codec" to (entry.format.sampleMimeType ?: ""),
-                "channels" to channels
-            )
-        }
-    }
-
-    fun setAudioTrack(trackId: Int) {
-        val p = player ?: return
-        val entry = audioTrackList.firstOrNull { it.id == trackId } ?: return
-        val matchedGroup = p.currentTracks.groups[entry.trackGroupIndex].mediaTrackGroup
-
-        val params = p.trackSelectionParameters.buildUpon()
-            .setTrackTypeDisabled(C.TRACK_TYPE_AUDIO, false)
-            .setOverrideForType(TrackSelectionOverride(matchedGroup, entry.trackIndex))
-            .build()
-        p.trackSelectionParameters = params
-        currentAudioId = trackId
-    }
-
-    fun getCurrentAudioTrack(): Int = currentAudioId
-
-    // MARK: - Video Scaling
-
-    fun setZoomedToFill(zoomed: Boolean) {
-        isZoomedToFill = zoomed
-        val resizeMode = if (zoomed) {
-            androidx.media3.ui.AspectRatioFrameLayout.RESIZE_MODE_ZOOM
-        } else {
-            androidx.media3.ui.AspectRatioFrameLayout.RESIZE_MODE_FIT
-        }
-        playerView.resizeMode = resizeMode
-    }
-
-    fun isZoomedToFill(): Boolean = isZoomedToFill
-
-    // MARK: - Technical Info
-
-    fun getTechnicalInfo(): Map<String, Any> {
-        val p = player ?: return emptyMap()
-        val tracks = p.currentTracks
-
-        // Prefer the currently-selected track within each renderer group;
-        // fall back to the first supported track if none is selected yet.
-        val videoFormat = pickFormat(tracks, C.TRACK_TYPE_VIDEO)
-        val audioFormat = pickFormat(tracks, C.TRACK_TYPE_AUDIO)
-
-        val cacheSec = if (p.bufferedPosition > p.currentPosition) {
-            (p.bufferedPosition - p.currentPosition) / 1000.0
-        } else 0.0
-
-        val info = LinkedHashMap<String, Any>()
-        info["cacheSeconds"] = cacheSec
-
-        // Dropped frames — populated by analyticsListener.onDroppedVideoFrames.
-        if (cumulativeDroppedFrames > 0) {
-            info["droppedFrames"] = cumulativeDroppedFrames
-        }
-
-        // Decoder info — populated by analyticsListener.onVideo/AudioDecoderInitialized.
-        // For ExoPlayer this replaces MPV's voDriver/hwdec pairing. The
-        // FFmpeg extension reports names beginning with "FFmpeg", which we
-        // classify as software; everything else is MediaCodec (hardware).
-        videoDecoderName?.let { name ->
-            info["decoderName"] = name
-            info["decoderType"] = if (name.lowercase().startsWith("ffmpeg")) {
-                "software"
-            } else {
-                "hardware"
-            }
-        }
-
-        videoFormat?.let { f ->
-            if (f.width != Format.NO_VALUE) info["videoWidth"] = f.width
-            if (f.height != Format.NO_VALUE) info["videoHeight"] = f.height
-            f.sampleMimeType?.let { info["videoCodec"] = it }
-            // FPS: Format.NO_VALUE (-1f) means unknown — omit so the
-            // overlay skips the row instead of showing "-1".
-            if (f.frameRate > 0f) {
-                info["fps"] = f.frameRate.toDouble()
-            }
-            // Bitrate: prefer average, fall back to peak. Both can be
-            // NO_VALUE for adaptive HLS renditions — omit when unknown
-            // rather than reporting 0 Kbps.
-            val vBitrate = if (f.averageBitrate != Format.NO_VALUE) {
-                f.averageBitrate
-            } else {
-                f.peakBitrate
-            }
-            if (vBitrate != Format.NO_VALUE && vBitrate > 0) {
-                info["videoBitrate"] = vBitrate.toDouble()
-            }
-
-            // Raw codec tag from the container (e.g. "hev1.2.4.L153.B0").
-            // Carries profile / tier / level / constraint bytes — power
-            // users can decode it manually to see why a stream hit our
-            // HEVC level cap.
-            f.codecs?.let { info["videoCodecs"] = it }
-
-            // HDR / color metadata. Format.colorInfo is the authoritative
-            // source — the file/Jellyfin may claim HDR but the player is
-            // what decides whether the decoder+surface path is HDR-capable.
-            f.colorInfo?.let { ci ->
-                val hdr = deriveHdrFormat(ci)
-                if (hdr != null) info["hdrFormat"] = hdr
-                colorSpaceName(ci.colorSpace)?.let { info["colorSpace"] = it }
-                colorRangeName(ci.colorRange)?.let { info["colorRange"] = it }
-                colorTransferName(ci.colorTransfer)?.let { info["colorTransfer"] = it }
-            }
-        }
-
-        audioFormat?.let { f ->
-            f.sampleMimeType?.let { info["audioCodec"] = it }
-            val aBitrate = if (f.averageBitrate != Format.NO_VALUE) {
-                f.averageBitrate
-            } else {
-                f.peakBitrate
-            }
-            if (aBitrate != Format.NO_VALUE && aBitrate > 0) {
-                info["audioBitrate"] = aBitrate.toDouble()
-            }
-            if (f.channelCount > 0) info["audioChannels"] = f.channelCount
-            if (f.sampleRate > 0) info["audioSampleRate"] = f.sampleRate
-        }
-
-        return info
-    }
-
-    /**
-     * Map the active color transfer to a human-readable HDR format string.
-     * Returns null for SDR / unknown so the overlay can skip the row.
-     *
-     * HDR10 vs HDR10+ distinction isn't possible from Format alone in
-     * Media3 — HDR10+ is signaled via ST2094-40 SEI metadata which isn't
-     * exposed on Format. Both report as "HDR10" here; that matches what
-     * Media3 actually decodes (no HDR10+ tone-mapping).
-     */
-    private fun deriveHdrFormat(ci: ColorInfo): String? {
-        return when (ci.colorTransfer) {
-            C.COLOR_TRANSFER_HLG -> "HLG"
-            C.COLOR_TRANSFER_ST2084 -> "HDR10"
-            else -> null
-        }
-    }
-
-    private fun colorSpaceName(value: Int): String? = when (value) {
-        Format.NO_VALUE -> null
-        C.COLOR_SPACE_BT709 -> "BT.709"
-        C.COLOR_SPACE_BT601 -> "BT.601"
-        C.COLOR_SPACE_BT2020 -> "BT.2020"
-        else -> "Unknown"
-    }
-
-    private fun colorRangeName(value: Int): String? = when (value) {
-        Format.NO_VALUE -> null
-        C.COLOR_RANGE_LIMITED -> "Limited"
-        C.COLOR_RANGE_FULL -> "Full"
-        else -> "Unknown"
-    }
-
-    private fun colorTransferName(value: Int): String? = when (value) {
-        Format.NO_VALUE -> null
-        C.COLOR_TRANSFER_SDR -> "SDR"
-        C.COLOR_TRANSFER_ST2084 -> "ST2084 (PQ)"
-        C.COLOR_TRANSFER_HLG -> "HLG"
-        C.COLOR_TRANSFER_GAMMA_2_2 -> "Gamma 2.2"
-        else -> "Unknown"
-    }
-
-    private fun pickFormat(tracks: Tracks, type: Int): Format? {
-        val group = tracks.groups.firstOrNull { it.type == type } ?: return null
-        // Selected track wins.
-        for (i in 0 until group.length) {
-            if (group.isTrackSelected(i)) return group.getTrackFormat(i)
-        }
-        // Otherwise the first supported track.
-        for (i in 0 until group.length) {
-            if (group.isTrackSupported(i)) return group.getTrackFormat(i)
-        }
-        return null
-    }
-
-    // MARK: - Progress Loop
-
-    private fun startProgressLoop() {
-        stopProgressLoop()
-        mainHandler.postDelayed(progressRunnable, PROGRESS_INTERVAL_MS)
-    }
-
-    private fun stopProgressLoop() {
-        mainHandler.removeCallbacks(progressRunnable)
-    }
-
-    // MARK: - Cleanup
-
-    override fun onDetachedFromWindow() {
-        super.onDetachedFromWindow()
-        destroy()
-    }
-}

modules/exoplayer-player/expo-module.config.json

@@ -1,6 +0,0 @@
-{
-  "platforms": ["android"],
-  "android": {
-    "modules": ["expo.modules.exoplayerplayer.ExoPlayerModule"]
-  }
-}

modules/exoplayer-player/index.ts

@@ -1,19 +0,0 @@
-// Re-export the shared player contract from mpv-player so ExoPlayer
-// and MPV present identical surfaces to React. The MPV-prefixed setting
-// keys keep their names to avoid migrating existing installs.
-export type {
-  AudioTrack,
-  MpvPlayerViewProps,
-  MpvPlayerViewRef,
-  NowPlayingMetadata,
-  OnErrorEventPayload,
-  OnLoadEventPayload,
-  OnPictureInPictureChangePayload,
-  OnPlaybackStateChangePayload,
-  OnProgressEventPayload,
-  OnTracksReadyEventPayload,
-  SubtitleTrack,
-  TechnicalInfo,
-  VideoSource,
-} from "../mpv-player/src/MpvPlayer.types";
-export { default as ExoPlayerView } from "./src/ExoPlayerView";

modules/exoplayer-player/src/ExoPlayerView.tsx

@@ -1,132 +0,0 @@
-import { requireNativeView } from "expo";
-import * as React from "react";
-import { useImperativeHandle, useRef } from "react";
-
-import type {
-  MpvPlayerViewProps,
-  MpvPlayerViewRef,
-} from "@/modules/mpv-player";
-
-const NativeView: React.ComponentType<MpvPlayerViewProps & { ref?: any }> =
-  requireNativeView("ExoPlayer");
-
-/**
- * ExoPlayer view wrapper. Exposes the same `MpvPlayerViewRef` interface as
- * `MpvPlayerView` so callers can swap between the two players without
- * changing code. PiP / ASS-override methods are forwarded to the native
- * module which implements them as no-ops.
- */
-export default React.forwardRef<MpvPlayerViewRef, MpvPlayerViewProps>(
-  function ExoPlayerView(props, ref) {
-    const nativeRef = useRef<any>(null);
-
-    useImperativeHandle(ref, () => ({
-      play: async () => {
-        await nativeRef.current?.play();
-      },
-      pause: async () => {
-        await nativeRef.current?.pause();
-      },
-      destroy: async () => {
-        await nativeRef.current?.destroy();
-      },
-      seekTo: async (position: number) => {
-        await nativeRef.current?.seekTo(position);
-      },
-      seekBy: async (offset: number) => {
-        await nativeRef.current?.seekBy(offset);
-      },
-      setSpeed: async (speed: number) => {
-        await nativeRef.current?.setSpeed(speed);
-      },
-      getSpeed: async () => {
-        return await nativeRef.current?.getSpeed();
-      },
-      isPaused: async () => {
-        return await nativeRef.current?.isPaused();
-      },
-      getCurrentPosition: async () => {
-        return await nativeRef.current?.getCurrentPosition();
-      },
-      getDuration: async () => {
-        return await nativeRef.current?.getDuration();
-      },
-      startPictureInPicture: async () => {
-        await nativeRef.current?.startPictureInPicture();
-      },
-      stopPictureInPicture: async () => {
-        await nativeRef.current?.stopPictureInPicture();
-      },
-      isPictureInPictureSupported: async () => {
-        return await nativeRef.current?.isPictureInPictureSupported();
-      },
-      isPictureInPictureActive: async () => {
-        return await nativeRef.current?.isPictureInPictureActive();
-      },
-      getSubtitleTracks: async () => {
-        return await nativeRef.current?.getSubtitleTracks();
-      },
-      setSubtitleTrack: async (trackId: number) => {
-        await nativeRef.current?.setSubtitleTrack(trackId);
-      },
-      disableSubtitles: async () => {
-        await nativeRef.current?.disableSubtitles();
-      },
-      getCurrentSubtitleTrack: async () => {
-        return await nativeRef.current?.getCurrentSubtitleTrack();
-      },
-      addSubtitleFile: async (url: string, select = true) => {
-        await nativeRef.current?.addSubtitleFile(url, select);
-      },
-      setSubtitlePosition: async (position: number) => {
-        await nativeRef.current?.setSubtitlePosition(position);
-      },
-      setSubtitleScale: async (scale: number) => {
-        await nativeRef.current?.setSubtitleScale(scale);
-      },
-      setSubtitleMarginY: async (margin: number) => {
-        await nativeRef.current?.setSubtitleMarginY(margin);
-      },
-      setSubtitleAlignX: async (alignment: "left" | "center" | "right") => {
-        await nativeRef.current?.setSubtitleAlignX(alignment);
-      },
-      setSubtitleAlignY: async (alignment: "top" | "center" | "bottom") => {
-        await nativeRef.current?.setSubtitleAlignY(alignment);
-      },
-      setSubtitleFontSize: async (size: number) => {
-        await nativeRef.current?.setSubtitleFontSize(size);
-      },
-      setSubtitleBackgroundColor: async (color: string) => {
-        await nativeRef.current?.setSubtitleBackgroundColor(color);
-      },
-      setSubtitleBorderStyle: async (
-        style: "outline-and-shadow" | "background-box",
-      ) => {
-        await nativeRef.current?.setSubtitleBorderStyle(style);
-      },
-      setSubtitleAssOverride: async (mode: "no" | "force") => {
-        await nativeRef.current?.setSubtitleAssOverride(mode);
-      },
-      getAudioTracks: async () => {
-        return await nativeRef.current?.getAudioTracks();
-      },
-      setAudioTrack: async (trackId: number) => {
-        await nativeRef.current?.setAudioTrack(trackId);
-      },
-      getCurrentAudioTrack: async () => {
-        return await nativeRef.current?.getCurrentAudioTrack();
-      },
-      setZoomedToFill: async (zoomed: boolean) => {
-        await nativeRef.current?.setZoomedToFill(zoomed);
-      },
-      isZoomedToFill: async () => {
-        return await nativeRef.current?.isZoomedToFill();
-      },
-      getTechnicalInfo: async () => {
-        return await nativeRef.current?.getTechnicalInfo();
-      },
-    }));
-
-    return <NativeView ref={nativeRef} {...props} />;
-  },
-);

modules/index.ts

@@ -7,8 +7,6 @@ export type {
   DownloadStartedEvent,
 } from "./background-downloader";
 export { default as BackgroundDownloader } from "./background-downloader";
-// ExoPlayer (Android TV)
-export { ExoPlayerView } from "./exoplayer-player";
 // Glass Poster (tvOS 26+)
 export type { GlassPosterViewProps } from "./glass-poster";
 export { GlassPosterView, isGlassEffectAvailable } from "./glass-poster";

modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MPVLayerRenderer.kt

@@ -125,14 +125,6 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
     private var currentUrl: String? = null
     private var currentHeaders: Map<String, String>? = null
     private var pendingExternalSubtitles: List<String> = emptyList()
-    // Persistent record of the external subtitle URLs attached to the
-    // current item. pendingExternalSubtitles above is a one-shot staging
-    // list: load() fills it and the FILE_LOADED handler drains it via
-    // sub-add, so it is always empty by the time a resume-recovery reload
-    // runs. This copy survives that drain so recoverVideoOutput() can hand
-    // the same sidecar URLs back to load() and the tracks re-attach after
-    // the decoder reset.
-    private var activeExternalSubtitles: List<String> = emptyList()
     private var initialSubtitleId: Int? = null
     private var initialAudioId: Int? = null
     
@@ -150,13 +142,6 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
      */
     private var voDriver: String = "gpu-next"
 
-    /**
-     * True on Android TV form-factor devices. Drives both the hwdec selection
-     * in [start] and the TV-only resume-recovery gating in [MpvPlayerView].
-     * Computed once from the system UI mode.
-     */
-    val isTv: Boolean = isTvDevice()
-
     fun start(voDriver: String = "gpu-next") {
         if (isRunning) return
 
@@ -167,6 +152,13 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
             this.mpv = mpv
             mpv.addObserver(this)
 
+            // Resolved once — TV gets the memory-pressure customizations
+            // (SCUDO_OPTIONS, hwdec/profile, demuxer-seekable-cache, larger
+            // audio-buffer) that would be counterproductive on higher-RAM
+            // mobile devices. Demuxer cache sizes are NOT included here —
+            // those come from user settings via load().
+            val isTV = isTvDevice()
+
             // mpv config directory — used by the config-dir option below and
             // as XDG_CONFIG_HOME for fontconfig.
             val mpvDir = File(context.getExternalFilesDir(null) ?: context.filesDir, "mpv")
@@ -220,7 +212,7 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
             //  - Real phone: `mediacodec-copy` (broadest compatibility).
             when {
                 isEmulator() -> mpv?.setOptionString("hwdec", "no")
-                isTv -> {
+                isTV -> {
                     mpv?.setOptionString("hwdec", "mediacodec")
                     mpv?.setOptionString("profile", "fast")
                     // Don't retain already-played content for backward
@@ -278,7 +270,6 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
         currentUrl = null
         currentHeaders = null
         pendingExternalSubtitles = emptyList()
-        activeExternalSubtitles = emptyList()
         initialSubtitleId = null
         initialAudioId = null
         cachedPosition = 0.0
@@ -386,67 +377,18 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
     }
 
     /**
-     * Restore video after a system-initiated surface loss (Android TV
-     * screensaver / app background while paused). Triggered from the host
-     * activity's onResume via [MpvPlayerView.runResumeRecovery].
-     *
-     * On TV, `hwdec=mediacodec` (zero-copy) binds MediaCodec directly to the
-     * display surface. When the screensaver invalidates that surface, the
-     * decoder is left bound to dead buffers and mpv auto-disables the video
-     * track (vid=no). Re-attaching the surface + cycling hwdec + re-selecting
-     * vid + seeking rebuilds the pipeline but leaves the video chain at EOF
-     * ("video=eof" in playback-restart) — the recreated MediaCodec produces no
-     * frames. Only a fresh `loadfile` deterministically recreates the decoder
-     * against the live surface, so we reload at the cached position.
-     *
-     * This is the Android counterpart to iOS's `performDecoderReset()`, which
-     * can get away with a `hwdec` cycle because VideoToolbox reinitializes
-     * cleanly; zero-copy MediaCodec bound to a lost surface does not.
+     * Force mpv to render a frame to the current surface.
+     * Steps forward one frame then seeks back to the original position.
+     * Used after PiP entry to work around mpv stopping pixel output.
      */
-    fun recoverVideoOutput(surface: Surface?) {
-        if (!isRunning) {
-            Log.w(TAG, "[Recover] recoverVideoOutput — renderer not running, skipping")
-            return
+    fun forceRedraw() {
+        if (!isRunning) return
+        val pos = cachedPosition
+        Log.i(TAG, "[PiP] forceRedraw — stepping frame then seeking to $pos")
+        mpv?.command(arrayOf("frame-step"))
+        if (pos > 0) {
+            mpv?.command(arrayOf("seek", pos.toString(), "absolute"))
         }
-        val url = currentUrl ?: run {
-            Log.w(TAG, "[Recover] recoverVideoOutput — no URL loaded, skipping")
-            return
-        }
-
-        Log.i(
-            TAG,
-            "[Recover] reload recovery — pos=$cachedPosition, aid=${getCurrentAudioTrack()}, sid=${getCurrentSubtitleTrack()}"
-        )
-
-        // Re-attach the surface first (covers the case where the surface
-        // survived and surfaceCreated never fired). The reload below fully
-        // rebuilds the pipeline anyway, but this keeps the VO target current
-        // while the load is in flight.
-        surface?.takeIf { it.isValid }?.let { mpv?.attachSurface(it) }
-
-        // Preserve the user's current audio/subtitle selection across the
-        // reload — pass them INTO load() (not via the field: load() overwrites
-        // the initial IDs from its parameters). They're re-applied when
-        // FILE_LOADED fires. (0 / "no" means "off", which setSubtitleTrack /
-        // setAudioTrack handle correctly.)
-        val savedAid = getCurrentAudioTrack()
-        val savedSid = getCurrentSubtitleTrack()
-
-        // Full reload at the paused position. With keep-open=always +
-        // cache-pause-initial=yes, mpv seeks to the position and holds on the
-        // first decoded frame, so the paused frame reappears.
-        load(
-            url = url,
-            headers = currentHeaders,
-            startPosition = cachedPosition,
-            initialAudioId = savedAid,
-            initialSubtitleId = savedSid,
-            externalSubtitles = activeExternalSubtitles
-        )
-
-        // Hold the paused state explicitly — we only get here while paused,
-        // and load() doesn't touch the pause property.
-        pause()
     }
     
     fun load(
@@ -464,7 +406,6 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
         currentUrl = url
         currentHeaders = headers
         pendingExternalSubtitles = externalSubtitles ?: emptyList()
-        activeExternalSubtitles = pendingExternalSubtitles
         this.initialSubtitleId = initialSubtitleId
         this.initialAudioId = initialAudioId
 
@@ -624,11 +565,6 @@ class MPVLayerRenderer(private val context: Context) : MPVLib.EventObserver {
     fun addSubtitleFile(url: String, select: Boolean = true) {
         val flag = if (select) "select" else "cached"
         mpv?.command(arrayOf("sub-add", url, flag))
-        // Track runtime side-loads too, so they survive a resume-recovery
-        // reload just like external subs passed to load().
-        if (url.isNotEmpty() && url !in activeExternalSubtitles) {
-            activeExternalSubtitles = activeExternalSubtitles + url
-        }
     }
     
     // MARK: - Subtitle Positioning

modules/mpv-player/android/src/main/java/expo/modules/mpvplayer/MpvPlayerView.kt

@@ -1,11 +1,7 @@
 package expo.modules.mpvplayer
 
-import android.app.Activity
-import android.app.Application
 import android.content.Context
-import android.content.ContextWrapper
 import android.graphics.Color
-import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
@@ -55,12 +51,6 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
 
     companion object {
         private const val TAG = "MpvPlayerView"
-
-        // Grace window after onActivityResumed before running the resume
-        // recovery, so surfaceCreated (surface-destroyed case) has fired and
-        // the holder has a valid surface. If the surface survived the
-        // screensaver and surfaceCreated never fires, this still runs.
-        private const val RESUME_RECOVERY_DELAY_MS = 300L
     }
 
     // Event dispatchers
@@ -87,15 +77,6 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
     // PiP state tracking
     private val pipHandler = Handler(Looper.getMainLooper())
 
-    // Resume-recovery state: recreate the decoder when returning from the
-    // screensaver / app background while paused. See
-    // MPVLayerRenderer.recoverVideoOutput for why zero-copy hwdec=mediacodec
-    // needs this.
-    private var hostActivity: Activity? = null
-    private var lifecycleCallbacks: Application.ActivityLifecycleCallbacks? = null
-    private var lifecycleRegistered = false
-    private val recoverResumeRunnable = Runnable { runResumeRecovery() }
-
     init {
         setBackgroundColor(Color.BLACK)
 
@@ -164,10 +145,6 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
         // Renderer is created lazily in loadVideo once we have the voDriver setting
         renderer = MPVLayerRenderer(context)
         renderer?.delegate = this
-
-        // Watch the host activity's lifecycle to recover the video pipeline
-        // when returning from the screensaver while paused.
-        registerLifecycleCallbacks()
     }
 
     /**
@@ -550,107 +527,6 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
         onError(mapOf("error" to message))
     }
 
-    // MARK: - Resume Recovery
-
-    /**
-     * Recreate the decoder when returning from the Android TV screensaver (or
-     * app background) while paused. Triggered from the host activity's
-     * onResume; the work is in [MPVLayerRenderer.recoverVideoOutput]. The
-     * playing case is skipped — the render thread re-primes the VO on surface
-     * reattach by itself — as is PiP (it owns its surface lifecycle).
-     */
-    private fun runResumeRecovery() {
-        if (!rendererStarted) return
-        if (pipController?.isPictureInPictureActive() == true) return
-        if (intendedPlayState) return  // playing self-heals
-        val surface = surfaceView.holder.surface?.takeIf { it.isValid }
-        Log.i(TAG, "[Recover] onResume recovery — paused, surfaceValid=${surface != null}")
-        renderer?.recoverVideoOutput(surface)
-    }
-
-    private fun registerLifecycleCallbacks() {
-        if (lifecycleRegistered) return
-        // Resume-recovery is TV-only. Only TV's zero-copy hwdec=mediacodec
-        // binds MediaCodec directly to the display surface, so only TV needs
-        // decoder recreation after a system-initiated surface loss (screensaver
-        // / app background while paused). Phones (mediacodec-copy) and the
-        // emulator self-heal via the surfaceCreated → attachSurface path, so we
-        // don't even register there — no callback overhead, no spurious resets.
-        if (renderer?.isTv != true) {
-            Log.i(TAG, "[Recover] skipping lifecycle registration (isTv=${renderer?.isTv})")
-            return
-        }
-        Log.i(TAG, "[Recover] registering lifecycle recovery (TV)")
-        val app = context.applicationContext as? Application ?: run {
-            Log.w(TAG, "Cannot register lifecycle callbacks: no Application")
-            return
-        }
-        lifecycleCallbacks = object : Application.ActivityLifecycleCallbacks {
-            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
-            override fun onActivityStarted(activity: Activity) {}
-            override fun onActivityResumed(activity: Activity) {
-                val host = hostActivity ?: findActivity().also { hostActivity = it }
-                if (activity !== host) {
-                    if (host == null) {
-                        Log.i(TAG, "[Recover] onActivityResumed — host unresolved, activity=${activity.javaClass.simpleName}; skipping")
-                    }
-                    return
-                }
-                Log.i(
-                    TAG,
-                    "[Recover] onActivityResumed — host resumed, hasMedia=${currentUrl != null}, pip=${pipController?.isPictureInPictureActive()}, paused=${!intendedPlayState}"
-                )
-                // Only recover when there's loaded media, we're paused, and not
-                // in PiP. Playing self-heals; nothing loaded yet = nothing to
-                // recover.
-                if (currentUrl == null) return
-                if (pipController?.isPictureInPictureActive() == true) return
-                if (intendedPlayState) return
-                // Post past the resume/surfaceCreated race so the holder has a
-                // valid surface, then recreate the decoder against it.
-                pipHandler.removeCallbacks(recoverResumeRunnable)
-                pipHandler.postDelayed(recoverResumeRunnable, RESUME_RECOVERY_DELAY_MS)
-            }
-            override fun onActivityPaused(activity: Activity) {
-                if (activity === hostActivity) {
-                    Log.i(TAG, "[Recover] onActivityPaused — host paused")
-                }
-            }
-            override fun onActivityStopped(activity: Activity) {
-                if (activity === hostActivity) {
-                    Log.i(TAG, "[Recover] onActivityStopped — host stopped")
-                }
-            }
-            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
-            override fun onActivityDestroyed(activity: Activity) {}
-        }
-        app.registerActivityLifecycleCallbacks(lifecycleCallbacks)
-        lifecycleRegistered = true
-    }
-
-    private fun unregisterLifecycleCallbacks() {
-        pipHandler.removeCallbacks(recoverResumeRunnable)
-        if (!lifecycleRegistered) return
-        val app = context.applicationContext as? Application
-        lifecycleCallbacks?.let { app?.unregisterActivityLifecycleCallbacks(it) }
-        lifecycleCallbacks = null
-        lifecycleRegistered = false
-    }
-
-    private fun findActivity(): Activity? {
-        // Prefer Expo's currentActivity. The view's Context is a ReactContext
-        // whose base is the Application, not the Activity, so walking the
-        // context chain does not reliably reach the Activity. Mirrors
-        // PiPController.getActivity().
-        appContext.currentActivity?.let { return it }
-        var ctx: Context = context
-        while (ctx is ContextWrapper) {
-            if (ctx is Activity) return ctx
-            ctx = ctx.baseContext
-        }
-        return null
-    }
-
     // MARK: - Cleanup
 
     /**
@@ -662,7 +538,6 @@ class MpvPlayerView(context: Context, appContext: AppContext) : ExpoView(context
      */
     fun cleanup() {
         pipHandler.removeCallbacksAndMessages(null)
-        unregisterLifecycleCallbacks()
         pipController?.stopPictureInPicture()
         renderer?.stop()
         renderer?.delegate = null

modules/mpv-player/src/MpvPlayer.types.ts

@@ -175,28 +175,4 @@ export type TechnicalInfo = {
   hwdec?: string;
   /** Estimated video output fps (mpv "estimated-vf-fps") */
   estimatedVfFps?: number;
-  // ---- Extended fields (primarily ExoPlayer-backed; MPV may fill some) ----
-  /** Derived HDR format: "SDR" | "HDR10" | "HDR10+" | "HLG" | null */
-  hdrFormat?: string;
-  /** Color space, e.g. "BT.709" / "BT.2020" */
-  colorSpace?: string;
-  /** Color range: "Limited" / "Full" */
-  colorRange?: string;
-  /** Color transfer: "SDR" / "ST2084 (PQ)" / "HLG" */
-  colorTransfer?: string;
-  /** Decoder path: "hardware" (MediaCodec) or "software" (FFmpeg extension) */
-  decoderType?: string;
-  /** Instantiated decoder name, e.g. "c2.amlogic.hevc.decoder" */
-  decoderName?: string;
-  /** Active audio channel count (2 = stereo, 6 = 5.1, 8 = 7.1) */
-  audioChannels?: number;
-  /** Active audio sample rate in Hz */
-  audioSampleRate?: number;
-  /**
-   * Raw codec tag from the container, e.g. "hev1.2.4.L153.B0". Encodes
-   * profile / tier / level / constraint bytes per ISO/IEC 14496-15. Power
-   * users can decode this manually; it's how Jellyfin's HEVC level cap
-   * (153 = Level 5.1) is checked against the file.
-   */
-  videoCodecs?: string;
 };

modules/wifi-ssid/android/build.gradle

@@ -0,0 +1,19 @@
+apply plugin: 'expo-module-gradle-plugin'
+
+group = 'expo.modules.wifissid'
+version = '1.0.0'
+
+expoModule {
+  canBePublished false
+}
+
+android {
+  namespace "expo.modules.wifissid"
+  defaultConfig {
+    versionCode 1
+    versionName "1.0.0"
+  }
+}
+
+dependencies {
+}

modules/wifi-ssid/android/src/main/AndroidManifest.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Reading the connected Wi-Fi SSID requires ACCESS_WIFI_STATE, and (since
+       Android 8) ACCESS_FINE_LOCATION granted at runtime. Location is requested
+       at runtime by the app via expo-location; the manifest declares the
+       Wi-Fi/network permissions this module needs directly. -->
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+</manifest>

modules/wifi-ssid/android/src/main/java/expo/modules/wifissid/WifiSsidModule.kt

@@ -0,0 +1,121 @@
+package expo.modules.wifissid
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.provider.Settings
+import android.util.Log
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class WifiSsidModule : Module() {
+  companion object {
+    private const val TAG = "WifiSsid"
+    private const val UNKNOWN_SSID = "<unknown ssid>"
+  }
+
+  private val context
+    get() = requireNotNull(appContext.reactContext)
+
+  override fun definition() = ModuleDefinition {
+    Name("WifiSsid")
+
+    AsyncFunction("getSSID") {
+      val (ssid, connectedToWifi) = readWifi()
+      mapOf(
+        "ssid" to ssid,
+        "connectedToWifi" to connectedToWifi,
+      )
+    }
+
+    Function("getSSIDSync") {
+      val (ssid, connectedToWifi) = readWifi()
+      mapOf(
+        "ssid" to ssid,
+        "connectedToWifi" to connectedToWifi,
+      )
+    }
+
+    Function("openLocationSettings") {
+      openLocationSettings()
+    }
+  }
+
+  /**
+   * Returns the current Wi-Fi SSID (or null when it can't be read) and whether
+   * the device is connected to a Wi-Fi network. When the device is connected but
+   * the SSID is null, the OS is withholding the network name — on Android this
+   * typically means device Location services are off (the SSID is treated as
+   * location-sensitive).
+   */
+  private fun readWifi(): Pair<String?, Boolean> {
+    val androidContext = context.applicationContext
+    var connectedToWifi = false
+    var ssid: String? = null
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      try {
+        val cm = androidContext.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+        val caps = cm?.let { manager ->
+          manager.activeNetwork?.let { net -> manager.getNetworkCapabilities(net) }
+        }
+        connectedToWifi = caps?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) == true
+        if (hasFineLocationPermission()) {
+          ssid = (caps?.transportInfo as? WifiInfo)?.ssid?.sanitize()
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Error reading Wi-Fi via ConnectivityManager", e)
+      }
+    } else {
+      // Pre-Q (API 26–28): NetworkCapabilities/transportInfo aren't available, so
+      // detect a Wi-Fi connection via the legacy active-network API. Without this,
+      // connectedToWifi stays false on Android 8/9 even when connected, so the
+      // "connected but SSID hidden" state never surfaces there.
+      try {
+        val cm = androidContext.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+        @Suppress("DEPRECATION")
+        connectedToWifi = cm?.activeNetworkInfo?.type == ConnectivityManager.TYPE_WIFI
+      } catch (e: Exception) {
+        Log.e(TAG, "Error reading Wi-Fi via ConnectivityManager (legacy)", e)
+      }
+    }
+
+    if (ssid == null && hasFineLocationPermission()) {
+      try {
+        val wm = androidContext.getSystemService(Context.WIFI_SERVICE) as? WifiManager
+        @Suppress("DEPRECATION")
+        ssid = wm?.connectionInfo?.ssid?.sanitize()
+      } catch (e: Exception) {
+        Log.e(TAG, "Error reading SSID via WifiManager", e)
+      }
+    }
+
+    return Pair(ssid, connectedToWifi)
+  }
+
+  private fun openLocationSettings() {
+    try {
+      val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      }
+      context.applicationContext.startActivity(intent)
+    } catch (e: Exception) {
+      Log.e(TAG, "Unable to open Location settings", e)
+    }
+  }
+
+  private fun hasFineLocationPermission(): Boolean =
+    context.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) ==
+      PackageManager.PERMISSION_GRANTED
+
+  private fun String.sanitize(): String? {
+    val cleaned = trim('"')
+    return if (cleaned.isBlank() || cleaned == UNKNOWN_SSID) null else cleaned
+  }
+}

modules/wifi-ssid/expo-module.config.json

@@ -1,8 +1,11 @@
 {
   "name": "wifi-ssid",
   "version": "1.0.0",
-  "platforms": ["ios"],
+  "platforms": ["ios", "android"],
   "ios": {
     "modules": ["WifiSsidModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.wifissid.WifiSsidModule"]
   }
 }

modules/wifi-ssid/index.ts

@@ -1,44 +1,92 @@
 import { Platform, requireNativeModule } from "expo-modules-core";
+import { Linking } from "react-native";
 
-// Only load the native module on iOS
-const WifiSsidModule =
-  Platform.OS === "ios" ? requireNativeModule("WifiSsid") : null;
+export interface WifiSsidResult {
+  ssid: string | null;
+  /**
+   * Whether the device is connected to a Wi-Fi network. When true but `ssid` is
+   * null, the OS is withholding the network name — on Android this happens when
+   * device Location services are off (the SSID is location-sensitive).
+   */
+  connectedToWifi: boolean;
+}
+
+// Load the native module on iOS and Android (not TV/web). Wrapped so a
+// missing/unlinked module degrades to null instead of crashing the bundle.
+const WifiSsidModule = (() => {
+  if (Platform.OS !== "ios" && Platform.OS !== "android") return null;
+  try {
+    return requireNativeModule("WifiSsid");
+  } catch {
+    return null;
+  }
+})();
 
 /**
- * Get the current WiFi SSID on iOS.
- * Returns null on Android or if not connected to WiFi.
+ * Get the current WiFi SSID and whether the device is on a Wi-Fi network.
  *
- * Requires:
+ * iOS requirements:
  * - Location permission granted
  * - com.apple.developer.networking.wifi-info entitlement
- * - Access WiFi Information capability enabled in Apple Developer Portal
+ *
+ * Android requirements:
+ * - ACCESS_FINE_LOCATION granted at runtime, and device Location services on
  */
-export async function getSSID(): Promise<string | null> {
+export async function getSSID(): Promise<WifiSsidResult> {
   if (!WifiSsidModule) {
-    return null;
+    return { ssid: null, connectedToWifi: false };
   }
-
   try {
-    const ssid = await WifiSsidModule.getSSID();
-    return ssid ?? null;
+    return normalize(await WifiSsidModule.getSSID());
   } catch (error) {
     console.error("[WifiSsid] Error getting SSID:", error);
-    return null;
+    return { ssid: null, connectedToWifi: false };
+  }
+}
+
+/** Synchronous version (uses the older CNCopyCurrentNetworkInfo API on iOS). */
+export function getSSIDSync(): WifiSsidResult {
+  if (!WifiSsidModule) {
+    return { ssid: null, connectedToWifi: false };
+  }
+  try {
+    return normalize(WifiSsidModule.getSSIDSync());
+  } catch (error) {
+    console.error("[WifiSsid] Error getting SSID (sync):", error);
+    return { ssid: null, connectedToWifi: false };
   }
 }
 
 /**
- * Synchronous version - uses older CNCopyCurrentNetworkInfo API
+ * Open the system Location settings so the user can enable Location services
+ * (required on Android for the OS to reveal the Wi-Fi SSID). Falls back to the
+ * app's settings page where there is no dedicated native action (e.g. iOS).
  */
-export function getSSIDSync(): string | null {
-  if (!WifiSsidModule) {
-    return null;
-  }
-
+export function openLocationSettings(): void {
   try {
-    return WifiSsidModule.getSSIDSync() ?? null;
+    if (WifiSsidModule?.openLocationSettings) {
+      WifiSsidModule.openLocationSettings();
+      return;
+    }
   } catch (error) {
-    console.error("[WifiSsid] Error getting SSID (sync):", error);
-    return null;
+    console.error("[WifiSsid] Error opening location settings:", error);
   }
+  Linking.openSettings();
+}
+
+// Both native modules return { ssid, connectedToWifi }. The string branch is a
+// defensive fallback in case a build returns the older plain-string shape.
+function normalize(result: unknown): WifiSsidResult {
+  if (typeof result === "string") {
+    const ssid = result || null;
+    return { ssid, connectedToWifi: ssid !== null };
+  }
+  if (result && typeof result === "object") {
+    const obj = result as { ssid?: string | null; connectedToWifi?: boolean };
+    return {
+      ssid: obj.ssid ?? null,
+      connectedToWifi: Boolean(obj.connectedToWifi),
+    };
+  }
+  return { ssid: null, connectedToWifi: false };
 }

modules/wifi-ssid/ios/WifiSsidModule.swift

@@ -1,50 +1,113 @@
 import ExpoModulesCore
 #if !os(tvOS)
+import Network
 import NetworkExtension
 import SystemConfiguration.CaptiveNetwork
 #endif
+import UIKit
 
 public class WifiSsidModule: Module {
+  #if !os(tvOS)
+  // NWPathMonitor reports whether the active path uses Wi-Fi WITHOUT requiring
+  // the wifi-info entitlement, so we can tell "on Wi-Fi but can't read the SSID"
+  // apart from "not connected to Wi-Fi" even when fetchCurrent returns nil.
+  private let pathMonitor = NWPathMonitor()
+  private let monitorQueue = DispatchQueue(label: "expo.modules.wifissid.pathmonitor")
+  private let lock = NSLock()
+  private var cachedOnWifi = false
+  private var pathMonitorStarted = false
+
+  private var isOnWifi: Bool {
+    lock.lock()
+    defer { lock.unlock() }
+    return cachedOnWifi
+  }
+
+  private func startPathMonitorIfNeeded() {
+    lock.lock()
+    if pathMonitorStarted {
+      lock.unlock()
+      return
+    }
+    pathMonitorStarted = true
+    lock.unlock()
+
+    pathMonitor.pathUpdateHandler = { [weak self] path in
+      guard let self else { return }
+      let onWifi = path.status == .satisfied && path.usesInterfaceType(.wifi)
+      self.lock.lock()
+      self.cachedOnWifi = onWifi
+      self.lock.unlock()
+    }
+    pathMonitor.start(queue: monitorQueue)
+  }
+
+  deinit {
+    pathMonitor.cancel()
+  }
+  #endif
+
   public func definition() -> ModuleDefinition {
     Name("WifiSsid")
 
-    // Get current WiFi SSID using NEHotspotNetwork (iOS 14+)
-    // Not available on tvOS
-    AsyncFunction("getSSID") { () -> String? in
+    AsyncFunction("getSSID") { () -> [String: Any] in
       #if os(tvOS)
-      return nil
+      return ["ssid": NSNull(), "connectedToWifi": false]
       #else
-      return await withCheckedContinuation { continuation in
-        NEHotspotNetwork.fetchCurrent { network in
-          if let ssid = network?.ssid {
-            print("[WifiSsid] Got SSID via NEHotspotNetwork: \(ssid)")
-            continuation.resume(returning: ssid)
-          } else {
-            // Fallback to CNCopyCurrentNetworkInfo for older iOS
-            print("[WifiSsid] NEHotspotNetwork returned nil, trying CNCopyCurrentNetworkInfo")
-            let ssid = self.getSSIDViaCNCopy()
-            continuation.resume(returning: ssid)
-          }
-        }
+      self.startPathMonitorIfNeeded()
+      let ssid = await self.resolveSSID()
+      var result: [String: Any] = ["connectedToWifi": self.isOnWifi]
+      if let ssid = ssid {
+        result["ssid"] = ssid
+      } else {
+        result["ssid"] = NSNull()
       }
+      return result
       #endif
     }
 
-    // Synchronous version using only CNCopyCurrentNetworkInfo
-    // Not available on tvOS
-    Function("getSSIDSync") { () -> String? in
+    Function("getSSIDSync") { () -> [String: Any] in
       #if os(tvOS)
-      return nil
+      return ["ssid": NSNull(), "connectedToWifi": false]
       #else
-      return self.getSSIDViaCNCopy()
+      self.startPathMonitorIfNeeded()
+      let ssid = self.getSSIDViaCNCopy()
+      var result: [String: Any] = ["connectedToWifi": self.isOnWifi]
+      if let ssid = ssid {
+        result["ssid"] = ssid
+      } else {
+        result["ssid"] = NSNull()
+      }
+      return result
+      #endif
+    }
+
+    Function("openLocationSettings") {
+      #if !os(tvOS)
+      DispatchQueue.main.async {
+        if let url = URL(string: UIApplication.openSettingsURLString) {
+          UIApplication.shared.open(url)
+        }
+      }
       #endif
     }
   }
 
   #if !os(tvOS)
+  private func resolveSSID() async -> String? {
+    await withCheckedContinuation { continuation in
+      NEHotspotNetwork.fetchCurrent { network in
+        if let ssid = network?.ssid {
+          continuation.resume(returning: ssid)
+        } else {
+          continuation.resume(returning: self.getSSIDViaCNCopy())
+        }
+      }
+    }
+  }
+
   private func getSSIDViaCNCopy() -> String? {
     guard let interfaces = CNCopySupportedInterfaces() as? [String] else {
-      print("[WifiSsid] CNCopySupportedInterfaces returned nil")
       return nil
     }
 
@@ -54,12 +117,10 @@ public class WifiSsidModule: Module {
       }
 
       if let ssid = networkInfo[kCNNetworkInfoKeySSID as String] as? String {
-        print("[WifiSsid] Got SSID via CNCopyCurrentNetworkInfo: \(ssid)")
         return ssid
       }
     }
 
-    print("[WifiSsid] No SSID found via CNCopyCurrentNetworkInfo")
     return nil
   }
   #endif

providers/Downloads/fileOperations.ts

@@ -96,5 +96,24 @@ export function getDownloadedItemSize(id: string): number {
  */
 export function calculateTotalDownloadedSize(): number {
   const items = getAllDownloadedItems();
-  return items.reduce((sum, item) => sum + (item.videoFileSize || 0), 0);
+  return items.reduce((sum, item) => {
+    // Trickplay bytes count too — getDownloadedItemSize models per-item size
+    // as video + trickplay, the total must match.
+    const trickplaySize = item.trickPlayData?.size ?? 0;
+    // Read the live file size on disk so the total reflects actual usage and
+    // self-heals items whose stored videoFileSize is 0 (old schema, or
+    // `fileInfo.size` was undefined at download time). Fall back to the stored
+    // value if the file can't be stat'd.
+    if (item.videoFilePath) {
+      try {
+        const file = new File(filePathToUri(item.videoFilePath));
+        if (file.exists) {
+          return sum + (file.size ?? item.videoFileSize ?? 0) + trickplaySize;
+        }
+      } catch (error) {
+        console.warn("Failed to stat downloaded file for size:", error);
+      }
+    }
+    return sum + (item.videoFileSize ?? 0) + trickplaySize;
+  }, 0);
 }

providers/Downloads/hooks/useDownloadOperations.ts

@@ -289,7 +289,24 @@ export function useDownloadOperations({
   );
 
   const appSizeUsage = useCallback(async () => {
-    const totalSize = calculateTotalDownloadedSize();
+    let totalSize = calculateTotalDownloadedSize();
+
+    // Also count in-progress downloads (they write straight to their final
+    // path) so the growing file shows up as app usage instead of drifting
+    // into the generic device share until completion.
+    for (const process of processes) {
+      try {
+        const file = new File(
+          Paths.document,
+          `${generateFilename(process.item)}.mp4`,
+        );
+        if (file.exists) {
+          totalSize += file.size ?? 0;
+        }
+      } catch {
+        // File not created yet — ignore.
+      }
+    }
 
     try {
       const [freeDiskStorage, totalDiskCapacity] = await Promise.all([
@@ -310,7 +327,7 @@ export function useDownloadOperations({
         appSize: totalSize,
       };
     }
-  }, []);
+  }, [processes]);
 
   return {
     startBackgroundDownload,

providers/JellyfinProvider.tsx

@@ -386,7 +386,7 @@ export const JellyfinProvider: React.FC<{ children: ReactNode }> = ({
             default:
               throw new Error(
                 t(
-                  "login.an_unexpected_error_occured_did_you_enter_the_correct_url",
+                  "login.an_unexpected_error_occurred_did_you_enter_the_correct_url",
                 ),
               );
           }

providers/PlaySettingsProvider.tsx

@@ -7,7 +7,7 @@ import type React from "react";
 import { createContext, useCallback, useContext, useState } from "react";
 import { Platform } from "react-native";
 import type { Bitrate } from "@/components/BitrateSelector";
-import { getActivePlayerType, settingsAtom } from "@/utils/atoms/settings";
+import { settingsAtom } from "@/utils/atoms/settings";
 import { getStreamUrl } from "@/utils/jellyfin/media/getStreamUrl";
 import { generateDeviceProfile } from "../utils/profiles/native";
 import { apiAtom, userAtom } from "./JellyfinProvider";
@@ -78,11 +78,10 @@ export const PlaySettingsProvider: React.FC<{ children: React.ReactNode }> = ({
       }
 
       try {
-        // Match the device profile to the actually-active player so the
-        // server picks codecs/containers the player can decode.
+        // Generate device profile for MPV player
         const native = generateDeviceProfile({
           platform: Platform.OS as "ios" | "android",
-          player: getActivePlayerType(settings),
+          player: "mpv",
           audioMode: settings.audioTranscodeMode,
         });
         const data = await getStreamUrl({

providers/ServerUrlProvider.tsx

@@ -6,6 +6,7 @@ import {
   useCallback,
   useContext,
   useEffect,
+  useMemo,
   useRef,
   useState,
 } from "react";
@@ -18,6 +19,7 @@ interface ServerUrlContextValue {
   effectiveServerUrl: string | null;
   isUsingLocalUrl: boolean;
   currentSSID: string | null;
+  connectedToWifi: boolean;
   refreshUrlState: () => void;
 }
 
@@ -32,7 +34,7 @@ interface Props {
 export function ServerUrlProvider({ children }: Props): React.ReactElement {
   const api = useAtomValue(apiAtom);
   const { switchServerUrl } = useJellyfin();
-  const { ssid, permissionStatus } = useWifiSSID();
+  const { ssid, connectedToWifi, permissionStatus } = useWifiSSID();
 
   const [isUsingLocalUrl, setIsUsingLocalUrl] = useState(false);
   const [effectiveServerUrl, setEffectiveServerUrl] = useState<string | null>(
@@ -101,15 +103,25 @@ export function ServerUrlProvider({ children }: Props): React.ReactElement {
     };
   }, [ssid, permissionStatus, evaluateAndSwitchUrl]);
 
+  const value = useMemo(
+    () => ({
+      effectiveServerUrl,
+      isUsingLocalUrl,
+      currentSSID: ssid,
+      connectedToWifi,
+      refreshUrlState,
+    }),
+    [
+      effectiveServerUrl,
+      isUsingLocalUrl,
+      ssid,
+      connectedToWifi,
+      refreshUrlState,
+    ],
+  );
+
   return (
-    <ServerUrlContext.Provider
-      value={{
-        effectiveServerUrl,
-        isUsingLocalUrl,
-        currentSSID: ssid,
-        refreshUrlState,
-      }}
-    >
+    <ServerUrlContext.Provider value={value}>
       {children}
     </ServerUrlContext.Provider>
   );

providers/WifiSsidProvider.tsx

@@ -0,0 +1,157 @@
+import type React from "react";
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { Platform } from "react-native";
+import { getSSID } from "@/modules/wifi-ssid";
+
+export type PermissionStatus =
+  | "granted"
+  | "denied"
+  | "undetermined"
+  | "unavailable";
+
+export interface UseWifiSSIDReturn {
+  ssid: string | null;
+  connectedToWifi: boolean;
+  permissionStatus: PermissionStatus;
+  requestPermission: () => Promise<boolean>;
+  isLoading: boolean;
+}
+
+const WifiSsidContext = createContext<UseWifiSSIDReturn | null>(null);
+
+// WiFi SSID is not available on tvOS, and expo-location isn't needed there.
+const Location = Platform.isTV ? null : require("expo-location");
+
+const POLL_INTERVAL_MS = 10_000;
+
+function mapLocationStatus(status: number | undefined): PermissionStatus {
+  if (!Location) return "unavailable";
+  switch (status) {
+    case Location.PermissionStatus?.GRANTED:
+      return "granted";
+    case Location.PermissionStatus?.DENIED:
+      return "denied";
+    default:
+      return "undetermined";
+  }
+}
+
+interface Props {
+  children: ReactNode;
+}
+
+/**
+ * Single source of truth for the current WiFi SSID and the location permission
+ * that gates it. State is shared via context so that granting permission in one
+ * place (e.g. the network settings screen) is reflected everywhere else — most
+ * importantly ServerUrlProvider, which switches between the local and remote
+ * server URLs based on the connected SSID.
+ *
+ * Previously each consumer created its own useWifiSSID instance with independent
+ * state, so the provider never learned that permission had been granted later
+ * in the session and reported "not connected to WiFi" forever.
+ */
+export function WifiSsidProvider({ children }: Props): React.ReactElement {
+  const [ssid, setSSID] = useState<string | null>(null);
+  const [connectedToWifi, setConnectedToWifi] = useState(false);
+  const [permissionStatus, setPermissionStatus] = useState<PermissionStatus>(
+    Platform.isTV ? "unavailable" : "undetermined",
+  );
+  const [isLoading, setIsLoading] = useState(!Platform.isTV);
+
+  const fetchSSID = useCallback(async () => {
+    if (Platform.isTV) return;
+    const result = await getSSID();
+    setSSID(result.ssid);
+    setConnectedToWifi(result.connectedToWifi);
+  }, []);
+
+  const requestPermission = useCallback(async (): Promise<boolean> => {
+    if (Platform.isTV || !Location) {
+      setPermissionStatus("unavailable");
+      return false;
+    }
+
+    try {
+      const { status } = await Location.requestForegroundPermissionsAsync();
+      const newStatus = mapLocationStatus(status);
+      setPermissionStatus(newStatus);
+      return newStatus === "granted";
+    } catch {
+      setPermissionStatus("unavailable");
+      return false;
+    }
+  }, []);
+
+  // Check the location permission once on mount. The poll effect below takes
+  // over fetching the SSID whenever permission becomes "granted".
+  useEffect(() => {
+    if (Platform.isTV || !Location) {
+      setIsLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+    async function initialize() {
+      setIsLoading(true);
+      try {
+        const { status } = await Location.getForegroundPermissionsAsync();
+        if (cancelled) return;
+        setPermissionStatus(mapLocationStatus(status));
+      } catch {
+        if (!cancelled) setPermissionStatus("unavailable");
+      }
+      if (!cancelled) setIsLoading(false);
+    }
+
+    initialize();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  // Fetch the SSID immediately, then poll, whenever permission is granted.
+  // Because permissionStatus is shared, this also covers the case where
+  // permission was granted later (from another consumer) than this provider's
+  // mount time — the original root cause of the "not connected to WiFi" bug.
+  useEffect(() => {
+    if (Platform.isTV || permissionStatus !== "granted") return;
+
+    fetchSSID();
+    const interval = setInterval(fetchSSID, POLL_INTERVAL_MS);
+    return () => clearInterval(interval);
+  }, [permissionStatus, fetchSSID]);
+
+  const value = useMemo(
+    () => ({
+      ssid,
+      connectedToWifi,
+      permissionStatus,
+      requestPermission,
+      isLoading,
+    }),
+    [ssid, connectedToWifi, permissionStatus, requestPermission, isLoading],
+  );
+
+  return (
+    <WifiSsidContext.Provider value={value}>
+      {children}
+    </WifiSsidContext.Provider>
+  );
+}
+
+export function useWifiSsid(): UseWifiSSIDReturn {
+  const context = useContext(WifiSsidContext);
+  if (!context) {
+    throw new Error("useWifiSsid must be used within WifiSsidProvider");
+  }
+  return context;
+}

translations/en.json

@@ -16,14 +16,14 @@
     "got_it": "Got it",
     "connection_failed": "Connection failed",
     "could_not_connect_to_server": "Could not connect to the server. Please check the URL and your network connection.",
-    "an_unexpected_error_occured": "An unexpected error occurred",
+    "an_unexpected_error_occurred": "An unexpected error occurred",
     "change_server": "Change server",
     "invalid_username_or_password": "Invalid username or password",
     "user_does_not_have_permission_to_log_in": "User does not have permission to log in",
     "server_is_taking_too_long_to_respond_try_again_later": "Server is taking too long to respond, try again later",
     "server_received_too_many_requests_try_again_later": "Server received too many requests, try again later.",
     "there_is_a_server_error": "There is a server error",
-    "an_unexpected_error_occured_did_you_enter_the_correct_url": "An unexpected error occurred. Did you enter the server URL correctly?",
+    "an_unexpected_error_occurred_did_you_enter_the_correct_url": "An unexpected error occurred. Did you enter the server URL correctly?",
     "too_old_server_text": "Unsupported Jellyfin server discovered",
     "too_old_server_description": "Please update Jellyfin to the latest version"
   },
@@ -174,7 +174,10 @@
         "network_already_added": "Network already added",
         "no_wifi_connected": "Not connected to Wi-Fi",
         "permission_denied": "Location permission denied",
-        "permission_denied_explanation": "Location permission is required to detect the Wi-Fi network for auto-switching. Please enable it in Settings."
+        "permission_denied_explanation": "Location permission is required to detect the Wi-Fi network for auto-switching. Please enable it in Settings.",
+        "ssid_hidden": "SSID hidden",
+        "location_off_description": "Connected to Wi-Fi, but the network name is hidden. Enable device Location services and grant the app location permission to detect it.",
+        "open_location_settings": "Open Location settings"
       },
       "user_info": {
         "user_info_title": "User info",
@@ -188,7 +191,7 @@
         "authorize_button": "Authorize Quick Connect",
         "enter_the_quick_connect_code": "Enter the Quick Connect code...",
         "success": "Success",
-        "quick_connect_autorized": "Quick Connect authorized",
+        "quick_connect_authorized": "Quick Connect authorized",
         "error": "Error",
         "invalid_code": "Invalid code",
         "authorize": "Authorize"
@@ -199,13 +202,6 @@
         "rewind_length": "Rewind length",
         "seconds_unit": "s"
       },
-      "video_player": {
-        "title": "Video Player",
-        "exoplayer": "ExoPlayer",
-        "mpv": "MPV",
-        "exoplayer_note": "ExoPlayer does not support advanced ASS/SSA subtitle styling or horizontal subtitle alignment. Switch to MPV if you need those.",
-        "mpv_note": "MPV on TV does not currently pass HDR metadata to the display — HDR10/HDR10+ content is tone-mapped to SDR. Switch to ExoPlayer for HDR output."
-      },
       "buffer": {
         "title": "Buffer settings",
         "cache_mode": "Cache mode",
@@ -305,7 +301,7 @@
         "show_custom_menu_links": "Show custom menu links",
         "show_large_home_carousel": "Show large home carousel (beta)",
         "hide_libraries": "Hide libraries",
-        "select_liraries_you_want_to_hide": "Select the libraries you want to hide from the Library tab and home page sections.",
+        "select_libraries_you_want_to_hide": "Select the libraries you want to hide from the Library tab and home page sections.",
         "disable_haptic_feedback": "Disable haptic feedback",
         "default_quality": "Default quality",
         "default_playback_speed": "Default playback speed",
@@ -391,6 +387,8 @@
         "device_usage": "Device {{availableSpace}}%",
         "size_used": "{{used}} of {{total}} used",
         "delete_all_downloaded_files": "Delete all downloaded files",
+        "delete_all_downloaded_files_confirm": "Delete All Downloaded Files?",
+        "delete_all_downloaded_files_confirm_desc": "Are you sure you want to delete all downloaded files? This action cannot be undone.",
         "music_cache_title": "Music cache",
         "music_cache_description": "Automatically cache songs as you listen for smoother playback and offline support",
         "clear_music_cache": "Clear music cache",
@@ -605,7 +603,7 @@
     "mpv_player_title": "MPV player",
     "error": "Error",
     "failed_to_get_stream_url": "Failed to get the stream URL",
-    "an_error_occured_while_playing_the_video": "An error occurred while playing the video. Check logs in settings.",
+    "an_error_occurred_while_playing_the_video": "An error occurred while playing the video. Check logs in settings.",
     "client_error": "Client error",
     "could_not_create_stream_for_chromecast": "Could not create a stream for Chromecast",
     "message_from_server": "Message from server: {{message}}",

utils/atoms/settings.ts

@@ -171,52 +171,11 @@ export type HomeSectionLatestResolver = {
   includeItemTypes?: Array<BaseItemKind>;
 };
 
-// Video player enum. MPV is the universal default; ExoPlayer is an
-// opt-in alternative on Android TV, selectable via settings.videoPlayer.
+// Video player enum - currently only MPV is supported
 export enum VideoPlayer {
   MPV = 0,
-  ExoPlayer = 1,
 }
 
-/**
- * Whether ExoPlayer's native module is available on the current platform.
- * ExoPlayer only ships for Android TV; on any other platform a persisted
- * `videoPlayer: ExoPlayer` preference (e.g. MMKV roaming) must fall back
- * to MPV rather than crash on requireNativeView().
- */
-export const isExoPlayerSupported =
-  Platform.OS === "android" && Platform.isTV === true;
-
-/**
- * Resolve the actually-active video player for the current settings.
- * MPV is the default on every platform; users can opt into ExoPlayer on
- * Android TV via settings.videoPlayer. The Android-TV capability gate is
- * folded in here so callers (VideoPlayerView, direct-player's device
- * profile, PlaySettingsProvider) can never advertise ExoPlayer on a
- * platform where MPV is actually rendering — that mismatch would let
- * Jellyfin pick a stream for the wrong renderer.
- */
-export const getActiveVideoPlayer = (
-  settings: Pick<Settings, "videoPlayer"> | null | undefined,
-): VideoPlayer => {
-  if (isExoPlayerSupported && settings?.videoPlayer === VideoPlayer.ExoPlayer) {
-    return VideoPlayer.ExoPlayer;
-  }
-  return VideoPlayer.MPV;
-};
-
-/**
- * Same selection as getActiveVideoPlayer but returns the lowercase
- * player-type identifier that `generateDeviceProfile` expects.
- */
-export const getActivePlayerType = (
-  settings: Pick<Settings, "videoPlayer"> | null | undefined,
-): "mpv" | "exoplayer" => {
-  return getActiveVideoPlayer(settings) === VideoPlayer.ExoPlayer
-    ? "exoplayer"
-    : "mpv";
-};
-
 // TV Typography scale presets
 export enum TVTypographyScale {
   Small = "small",
@@ -259,8 +218,6 @@ export type Settings = {
   mediaListCollectionIds?: string[];
   preferedLanguage?: string;
   searchEngine: "Marlin" | "Jellyfin" | "Streamystats";
-  /** Video player backend. Defaults to MPV when unset (see getActiveVideoPlayer). */
-  videoPlayer?: VideoPlayer;
   marlinServerUrl?: string;
   streamyStatsServerUrl?: string;
   streamyStatsMovieRecommendations?: boolean;
@@ -358,8 +315,6 @@ export const defaultValues: Settings = {
   mediaListCollectionIds: [],
   preferedLanguage: undefined,
   searchEngine: "Jellyfin",
-  // videoPlayer intentionally undefined — resolved at runtime via
-  // getActiveVideoPlayer() so existing installs are unaffected.
   marlinServerUrl: "",
   streamyStatsServerUrl: "",
   streamyStatsMovieRecommendations: false,

utils/profiles/native.ts

@@ -9,7 +9,7 @@ import MediaTypes from "../../constants/MediaTypes";
 import { getSubtitleProfiles } from "./subtitles";
 
 export type PlatformType = "ios" | "android";
-export type PlayerType = "mpv" | "exoplayer";
+export type PlayerType = "mpv";
 export type AudioTranscodeModeType = "auto" | "stereo" | "5.1" | "passthrough";
 
 export interface ProfileOptions {
@@ -63,26 +63,6 @@ const getAudioCodecProfile = (platform: PlatformType) => {
   };
 };
 
-/**
- * Resolves the MaxAudioChannels string for a given audio transcoding mode.
- * Used by both the MPV and ExoPlayer profile branches — the channel-cap
- * rule is player-agnostic (the player decodes; the cap just tells the
- * server when to transcode down).
- */
-const maxChannelsForMode = (audioMode: AudioTranscodeModeType): string => {
-  switch (audioMode) {
-    case "stereo":
-      return "2";
-    case "5.1":
-      return "6";
-    case "passthrough":
-      return "8";
-    default:
-      // Auto: default to 5.1 (6 channels)
-      return "6";
-  }
-};
-
 /**
  * Gets the video audio codec configuration based on platform and audio mode.
  *
@@ -109,59 +89,35 @@ const getVideoAudioCodecs = (
   // MPV can decode all codecs - only channel count varies by mode
   const allCodecs = `${baseCodecs},${surroundCodecs},${losslessHdCodecs},${platformCodecs}`;
 
-  return {
-    directPlayCodec: allCodecs,
-    maxAudioChannels: maxChannelsForMode(audioMode),
-  };
-};
+  switch (audioMode) {
+    case "stereo":
+      // Limit to 2 channels - MPV will decode and downmix
+      return {
+        directPlayCodec: allCodecs,
+        maxAudioChannels: "2",
+      };
 
-/**
- * ExoPlayer (Media3 1.10.1) direct-play profile for Android TV.
- *
- * Codec set aligned with Media3's documented supported-formats list:
- *   - Video: H.263, H.264, H.265, VP8, VP9, AV1
- *   - Audio: Vorbis, Opus, FLAC, ALAC, PCM, MP3, AAC, AC-3, E-AC-3, DTS,
- *     DTS-HD, TrueHD
- *
- * Hardware decode (MediaCodec) handles whatever the device ships with;
- * the rest fall through to FFmpeg software decode via the Jellyfin-published
- * `org.jellyfin.media3:media3-ffmpeg-decoder` extension wired up with
- * `DefaultRenderersFactory.EXTENSION_RENDERER_MODE_PREFER` (see
- * ExoPlayerView.kt:ensurePlayer).
- *
- * Cross-checked against the reference-device probe in
- * docs/research/hdr-dv-atmos-tv-plan.md (Amlogic Android 14 TV; HDMI sink
- * accepts AC3/EAC3 as bitstream and multichannel PCM up to 7.1 @ 192 kHz,
- * so software-decoded DTS/DTS-HD/TrueHD reach the sink as PCM).
- *
- * Dolby Vision: the CodecProfile below uses `NotEquals VideoRangeType
- * DOVI`, which in Jellyfin's semantics blocks ONLY pure Profile 5
- * (IPTPQc2 — the stream that renders purple/green without a DV-aware
- * decoder). DV Profiles 7/8 with HDR10 or SDR base layers (Jellyfin
- * reports these as `DOVIWithHDR10`, `DOVIWithHDR10Plus`, `DOVIWithEL`)
- * are NOT blocked — Media3 1.9.1+ correctly falls back to the AVC/HEVC
- * base layer.
- *
- * Containers limited to Media3's bundled extractors. FLV is intentionally
- * absent — Media3 has no FLV extractor (MPV claims it via FFmpeg).
- */
-const getExoPlayerDirectPlayProfile = () => {
-  const audioCodecs =
-    "vorbis,opus,flac,alac,pcm,mp3,aac,ac3,eac3,dts,dtshd,truehd";
+    case "5.1":
+      // Limit to 6 channels
+      return {
+        directPlayCodec: allCodecs,
+        maxAudioChannels: "6",
+      };
 
-  return {
-    video: {
-      Type: MediaTypes.Video,
-      Container: "mp4,mkv,webm,ts,mpegts,mov",
-      VideoCodec: "h263,h264,hevc,vp8,vp9,av1",
-      AudioCodec: audioCodecs,
-    },
-    audio: {
-      Type: MediaTypes.Audio,
-      Container: "mp3,m4a,aac,ogg,flac,wav,webm,mka",
-      AudioCodec: "vorbis,opus,flac,alac,pcm,mp3,aac",
-    },
-  };
+    case "passthrough":
+      // Allow up to 8 channels - for external DAC/receiver setups
+      return {
+        directPlayCodec: allCodecs,
+        maxAudioChannels: "8",
+      };
+
+    default:
+      // Auto mode: default to 5.1 (6 channels)
+      return {
+        directPlayCodec: allCodecs,
+        maxAudioChannels: "6",
+      };
+  }
 };
 
 /**
@@ -170,63 +126,6 @@ const getExoPlayerDirectPlayProfile = () => {
 export const generateDeviceProfile = (options: ProfileOptions = {}) => {
   const platform = (options.platform || Platform.OS) as PlatformType;
   const audioMode = options.audioMode || "auto";
-  const player = options.player || "mpv";
-
-  // ExoPlayer branch — Media3 capabilities on Android TV.
-  if (player === "exoplayer" && platform === "android") {
-    const exoDirect = getExoPlayerDirectPlayProfile();
-
-    return {
-      Name: "1. ExoPlayer",
-      MaxStaticBitrate: 999_999_999,
-      MaxStreamingBitrate: 999_999_999,
-      CodecProfiles: [
-        {
-          Type: MediaTypes.Video,
-          Codec: "h263,h264,vp8,vp9,av1",
-        },
-        {
-          Type: MediaTypes.Video,
-          Codec: "hevc,h265",
-          Conditions: [
-            {
-              Condition: "NotEquals",
-              Property: "VideoRangeType",
-              // Blocks ONLY pure DV Profile 5 (IPTPQc2). Profiles 7/8 with
-              // HDR10/SDR base layers fall through to Media3's HEVC fallback
-              // (1.9.1+). See getExoPlayerDirectPlayProfile doc above.
-              Value: "DOVI",
-              IsRequired: true,
-            },
-          ],
-        },
-        {
-          Type: MediaTypes.Audio,
-          Codec: "vorbis,opus,flac,alac,pcm,mp3,aac,ac3,eac3,dts,dtshd,truehd",
-        },
-      ],
-      DirectPlayProfiles: [exoDirect.video, exoDirect.audio],
-      TranscodingProfiles: [
-        {
-          Type: MediaTypes.Video,
-          Context: "Streaming",
-          Protocol: "hls",
-          Container: "ts",
-          VideoCodec: "h264,hevc",
-          AudioCodec: "aac,mp3,ac3",
-          MaxAudioChannels: maxChannelsForMode(audioMode),
-        },
-      ],
-      // Text-only subtitles for direct play. PGS delivered as Encode
-      // (burn-in) because Media3's PGS support is inconsistent.
-      SubtitleProfiles: [
-        { Format: "srt", Method: "External" },
-        { Format: "vtt", Method: "External" },
-        { Format: "ttml", Method: "External" },
-        { Format: "pgssub", Method: "Encode" },
-      ],
-    } satisfies DeviceProfile;
-  }
 
   const { directPlayCodec, maxAudioChannels } = getVideoAudioCodecs(
     platform,
@@ -299,3 +198,6 @@ export const generateDeviceProfile = (options: ProfileOptions = {}) => {
 
   return profile;
 };
+
+// Default export for backward compatibility
+export default generateDeviceProfile();

utils/time.ts

@@ -41,7 +41,7 @@ export const formatTimeString = (
   t: number | null | undefined,
   unit: "s" | "ms" | "tick" = "ms",
 ): string => {
-  if (t === null || t === undefined || !Number.isFinite(t)) return "0:00";
+  if (t === null || t === undefined) return "0:00";
 
   let seconds: number;
   switch (unit) {