feat: android tv menu to tabs

Change for the android tv side to use tabs instead of the mobile menu

Signed-off-by: Lance Chant <13349722+lancechant@users.noreply.github.com>

.github/workflows/trivy-scan.yml

@@ -0,0 +1,60 @@
+name: 🛡️ Trivy Security Scan
+
+# Filesystem scan (Streamyfin ships no container image): finds vulnerable dependencies,
+# leaked secrets and misconfigurations, and reports them to GitHub code scanning.
+# Runs post-merge + weekly (not on PRs — dependency-review already gates PRs, and SARIF
+# upload needs a write token that fork PRs don't get).
+on:
+  push:
+    branches: [develop, master]
+  schedule:
+    - cron: "50 7 * * 5" # Weekly, Friday 07:50 UTC
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: trivy-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  trivy:
+    name: 🔎 Filesystem scan
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+      security-events: write # upload SARIF to code scanning
+    steps:
+      - name: 📥 Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      # Rotate the DB cache weekly (matches the scheduled scan): cache hits within the week
+      # instead of a fresh immutable entry per run, still refreshing the DB every week.
+      - name: 🗓️ Compute weekly Trivy cache key
+        id: trivy-cache-key
+        run: echo "value=trivy-db-${{ runner.os }}-$(date -u +%G-%V)" >> "$GITHUB_OUTPUT"
+
+      - name: 💾 Cache Trivy vulnerability DB
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        with:
+          path: ~/.cache/trivy
+          key: ${{ steps.trivy-cache-key.outputs.value }}
+          restore-keys: trivy-db-${{ runner.os }}-
+
+      - name: 🔎 Run Trivy filesystem scan
+        uses: aquasecurity/trivy-action@ed142fd0673e97e23eac54620cfb913e5ce36c25 # v0.36.0
+        with:
+          scan-type: fs
+          scan-ref: .
+          scanners: vuln,secret,misconfig
+          ignore-unfixed: true
+          severity: CRITICAL,HIGH
+          format: sarif
+          output: trivy-results.sarif
+
+      - name: 📤 Upload results to code scanning
+        uses: github/codeql-action/upload-sarif@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
+        with:
+          sarif_file: trivy-results.sarif
+          category: trivy-fs

app/(auth)/(tabs)/_layout.tsx

@@ -3,16 +3,24 @@ import {
   type NativeBottomTabNavigationEventMap,
   type NativeBottomTabNavigationOptions,
 } from "@bottom-tabs/react-navigation";
-import { withLayoutContext } from "expo-router";
+import { Stack, useSegments, withLayoutContext } from "expo-router";
 import type {
   ParamListBase,
   TabNavigationState,
 } from "expo-router/react-navigation";
+import { useCallback, useEffect, useMemo } from "react";
 import { useTranslation } from "react-i18next";
 import { Platform, View } from "react-native";
 import { SystemBars } from "react-native-edge-to-edge";
+import type { TVNavBarTab } from "@/components/tv/TVNavBar";
+import { TVNavBar } from "@/components/tv/TVNavBar";
 import { Colors } from "@/constants/Colors";
-import { useTVHomeBackHandler } from "@/hooks/useTVBackHandler";
+import useRouter from "@/hooks/useAppRouter";
+import {
+  isTabRoute,
+  useTVHomeBackHandler,
+  useTVTabRootBackHandler,
+} from "@/hooks/useTVBackHandler";
 import { useSettings } from "@/utils/atoms/settings";
 import { eventBus } from "@/utils/eventBus";
 
@@ -33,13 +41,107 @@ export const NativeTabs = withLayoutContext<
   NativeBottomTabNavigationEventMap
 >(Navigator);
 
+const IS_ANDROID_TV = Platform.isTV && Platform.OS === "android";
+
+function TVTabLayout() {
+  const { settings } = useSettings();
+  const { t } = useTranslation();
+  const segments = useSegments();
+  const router = useRouter();
+
+  const currentTab = segments.find(isTabRoute);
+  const atTabRoot = isTabRoute(segments[segments.length - 1] ?? "");
+
+  const tabs: TVNavBarTab[] = useMemo(
+    () =>
+      [
+        { key: "(home)", label: t("tabs.home") },
+        { key: "(search)", label: t("tabs.search") },
+        { key: "(favorites)", label: t("tabs.favorites") },
+        !settings?.streamyStatsServerUrl || settings?.hideWatchlistsTab
+          ? null
+          : { key: "(watchlists)", label: t("watchlists.title") },
+        { key: "(libraries)", label: t("tabs.library") },
+        !settings?.showCustomMenuLinks
+          ? null
+          : { key: "(custom-links)", label: t("tabs.custom_links") },
+        { key: "(settings)", label: t("tabs.settings") },
+      ].filter((tab): tab is TVNavBarTab => tab !== null),
+    [
+      settings?.streamyStatsServerUrl,
+      settings?.hideWatchlistsTab,
+      settings?.showCustomMenuLinks,
+      t,
+    ],
+  );
+
+  const activeTabKey = currentTab ?? "(home)";
+
+  const visibleKeys = useMemo(
+    () => new Set(tabs.map((tab) => tab.key)),
+    [tabs],
+  );
+
+  const handleTabChange = useCallback(
+    (key: string) => {
+      if (key === currentTab) return;
+
+      if (key === "(home)") eventBus.emit("scrollToTop");
+      if (key === "(search)") eventBus.emit("searchTabPressed");
+
+      router.replace(`/(auth)/(tabs)/${key}`);
+    },
+    [currentTab, router],
+  );
+
+  const navigateHome = useCallback(() => {
+    router.replace("/(auth)/(tabs)/(home)");
+  }, [router]);
+  useTVTabRootBackHandler(navigateHome, atTabRoot, currentTab);
+
+  // If current tab is no longer visible (setting changed), navigate to home
+  useEffect(() => {
+    if (!visibleKeys.has(activeTabKey) && activeTabKey !== "(home)") {
+      router.replace("/(auth)/(tabs)/(home)");
+    }
+  }, [visibleKeys, activeTabKey, router]);
+
+  return (
+    <View style={{ flex: 1 }}>
+      <SystemBars hidden={false} style='light' />
+      <Stack
+        screenOptions={{ headerShown: false, animation: "none" }}
+        initialRouteName='(home)'
+      >
+        <Stack.Screen name='index' redirect />
+      </Stack>
+      <TVNavBar
+        tabs={tabs}
+        activeTabKey={activeTabKey}
+        onTabChange={handleTabChange}
+        style={{
+          position: "absolute",
+          top: 0,
+          left: 0,
+          right: 0,
+          zIndex: 1000,
+        }}
+      />
+    </View>
+  );
+}
+
 export default function TabLayout() {
   const { settings } = useSettings();
   const { t } = useTranslation();
 
-  // Handle TV back button - prevent app exit when at root
+  // Must be called before any conditional return (rules of hooks)
   useTVHomeBackHandler();
 
+  if (IS_ANDROID_TV) {
+    return <TVTabLayout />;
+  }
+
   return (
     <View style={{ flex: 1 }}>
       <SystemBars hidden={false} style='light' />

components/home/TVHeroCarousel.tsx

@@ -379,7 +379,7 @@ export const TVHeroCarousel: React.FC<TVHeroCarouselProps> = ({
   if (items.length === 0) return null;
 
   // Extra top padding for tvOS to clear the menu bar
-  const tvosTopPadding = Platform.OS === "ios" ? scaleSize(145) : 0;
+  const tvosTopPadding = scaleSize(145);
   const heroHeight = SCREEN_HEIGHT * sizes.padding.heroHeight;
 
   return (

components/tv/TVNavBar.tsx

@@ -0,0 +1,148 @@
+import React from "react";
+import { Animated, Pressable, ScrollView, View } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { Text } from "@/components/common/Text";
+import { TVPadding } from "@/constants/TVSizes";
+import { useScaledTVTypography } from "@/constants/TVTypography";
+import { scaleSize } from "@/utils/scaleSize";
+import { useTVFocusAnimation } from "./hooks/useTVFocusAnimation";
+
+export interface TVNavBarTab {
+  key: string;
+  label: string;
+}
+
+export interface TVNavBarProps {
+  tabs: TVNavBarTab[];
+  activeTabKey: string;
+  onTabChange: (key: string) => void;
+  style?: ViewStyleProp;
+}
+
+const TVNavBarTabItem: React.FC<{
+  label: string;
+  isActive: boolean;
+  onSelect: () => void;
+  onLayout: (e: {
+    nativeEvent: { layout: { x: number; width: number } };
+  }) => void;
+  hasTVPreferredFocus: boolean;
+}> = ({ label, isActive, onSelect, onLayout, hasTVPreferredFocus }) => {
+  const typography = useScaledTVTypography();
+  const { focused, handleFocus, handleBlur, animatedStyle } =
+    useTVFocusAnimation({
+      scaleAmount: 1.05,
+      duration: 120,
+    });
+
+  const bg = focused
+    ? "rgba(255, 255, 255, 0.95)"
+    : isActive
+      ? "rgba(255, 255, 255, 0.15)"
+      : "transparent";
+
+  const textColor = focused
+    ? "#000"
+    : isActive
+      ? "#fff"
+      : "rgba(255, 255, 255, 0.7)";
+
+  return (
+    <Pressable
+      onPress={onSelect}
+      onFocus={handleFocus}
+      onBlur={handleBlur}
+      hasTVPreferredFocus={hasTVPreferredFocus}
+      onLayout={onLayout}
+    >
+      <Animated.View
+        style={[
+          animatedStyle,
+          {
+            backgroundColor: bg,
+            borderRadius: scaleSize(24),
+            borderWidth: isActive && !focused ? 1 : 0,
+            borderColor: "rgba(255, 255, 255, 0.3)",
+            paddingHorizontal: scaleSize(28),
+            paddingVertical: scaleSize(14),
+          },
+        ]}
+      >
+        <Text
+          style={{
+            fontSize: typography.heading,
+            color: textColor,
+            fontWeight: isActive || focused ? "600" : "400",
+          }}
+        >
+          {label}
+        </Text>
+      </Animated.View>
+    </Pressable>
+  );
+};
+
+export const TVNavBar: React.FC<TVNavBarProps> = ({
+  tabs,
+  activeTabKey,
+  onTabChange,
+  style,
+}) => {
+  const scrollRef = React.useRef<ScrollView>(null);
+  const tabLayouts = React.useRef<Record<string, { x: number; width: number }>>(
+    {},
+  );
+  const insets = useSafeAreaInsets();
+
+  const handleTabLayout = React.useCallback(
+    (key: string) =>
+      (e: { nativeEvent: { layout: { x: number; width: number } } }) => {
+        tabLayouts.current[key] = e.nativeEvent.layout;
+      },
+    [],
+  );
+
+  const handleTabChange = React.useCallback(
+    (key: string) => {
+      onTabChange(key);
+
+      const layout = tabLayouts.current[key];
+      if (layout && scrollRef.current) {
+        scrollRef.current.scrollTo({
+          x: Math.max(0, layout.x - TVPadding.horizontal / 2),
+          animated: true,
+        });
+      }
+    },
+    [onTabChange],
+  );
+
+  if (tabs.length === 0) return null;
+
+  return (
+    <View style={[{ paddingTop: insets.top + 16, paddingBottom: 8 }, style]}>
+      <ScrollView
+        ref={scrollRef}
+        horizontal
+        showsHorizontalScrollIndicator={false}
+        keyboardShouldPersistTaps='handled'
+        contentContainerStyle={{
+          flexGrow: 1,
+          justifyContent: "center",
+          gap: scaleSize(12),
+        }}
+      >
+        {tabs.map((tab) => (
+          <TVNavBarTabItem
+            key={tab.key}
+            label={tab.label}
+            isActive={tab.key === activeTabKey}
+            onSelect={() => handleTabChange(tab.key)}
+            onLayout={handleTabLayout(tab.key)}
+            hasTVPreferredFocus={tab.key === activeTabKey}
+          />
+        ))}
+      </ScrollView>
+    </View>
+  );
+};

components/tv/index.ts

@@ -35,6 +35,8 @@ export type { TVLanguageCardProps } from "./TVLanguageCard";
 export { TVLanguageCard } from "./TVLanguageCard";
 export type { TVMetadataBadgesProps } from "./TVMetadataBadges";
 export { TVMetadataBadges } from "./TVMetadataBadges";
+export type { TVNavBarProps, TVNavBarTab } from "./TVNavBar";
+export { TVNavBar } from "./TVNavBar";
 export type { TVNextEpisodeCountdownProps } from "./TVNextEpisodeCountdown";
 export { TVNextEpisodeCountdown } from "./TVNextEpisodeCountdown";
 export type { TVOptionButtonProps } from "./TVOptionButton";

hooks/useTVBackHandler.ts

@@ -4,41 +4,42 @@ import { Platform } from "react-native";
 import {
   disableTVMenuKeyInterception,
   enableTVMenuKeyInterception,
+  useTVBackPress,
 } from "./useTVBackPress";
 
 export { enableTVMenuKeyInterception } from "./useTVBackPress";
 
+/** All tab route names used in the bottom tab navigator. */
+export const TAB_ROUTES = [
+  "(home)",
+  "(search)",
+  "(favorites)",
+  "(libraries)",
+  "(watchlists)",
+  "(custom-links)",
+  "(settings)",
+] as const;
+
+export type TabRoute = (typeof TAB_ROUTES)[number];
+
+/** Check if a segment string is a tab route. */
+export function isTabRoute(s: string): s is TabRoute {
+  return (TAB_ROUTES as readonly string[]).includes(s);
+}
+
 /**
  * Check if we're at the root of a tab
  */
 function isAtTabRoot(segments: string[]): boolean {
   const lastSegment = segments[segments.length - 1];
-  const tabNames = [
+  return isTabRoute(lastSegment) || lastSegment === "index";
-    "(home)",
-    "(search)",
-    "(favorites)",
-    "(libraries)",
-    "(watchlists)",
-    "(settings)",
-    "(custom-links)",
-  ];
-  return tabNames.includes(lastSegment) || lastSegment === "index";
 }
 
 /**
  * Get the current tab name from segments
  */
-function getCurrentTab(segments: string[]): string | undefined {
+function getCurrentTab(segments: string[]): TabRoute | undefined {
-  return segments.find(
+  return segments.find(isTabRoute);
-    (s) =>
-      s === "(home)" ||
-      s === "(search)" ||
-      s === "(favorites)" ||
-      s === "(libraries)" ||
-      s === "(watchlists)" ||
-      s === "(settings)" ||
-      s === "(custom-links)",
-  );
 }
 
 /**
@@ -49,7 +50,6 @@ function getCurrentTab(segments: string[]): string | undefined {
 export function useTVHomeBackHandler() {
   const segments = useSegments();
 
-  // Get current state
   const currentTab = getCurrentTab(segments);
   const atTabRoot = isAtTabRoot(segments);
   const isOnHomeRoot = atTabRoot && currentTab === "(home)";
@@ -65,3 +65,24 @@ export function useTVHomeBackHandler() {
     enableTVMenuKeyInterception();
   }, [isOnHomeRoot]);
 }
+
+/**
+ * Handles back press at a non-Home tab root on Android TV by navigating to Home.
+ *
+ * Without NativeTabs, the Stack navigator used for the Android TV nav bar has no
+ * built-in tab-level back handling — pressing back at a tab root would pop the
+ * Stack entirely and exit the tab navigator. This hook intercepts that and routes
+ * to Home instead.
+ */
+export function useTVTabRootBackHandler(
+  onNavigateHome: () => void,
+  isAtTabRoot: boolean,
+  currentTab: string | undefined,
+) {
+  useTVBackPress(() => {
+    if (!Platform.isTV || Platform.OS !== "android") return false;
+    if (!isAtTabRoot || currentTab === "(home)") return false;
+    onNavigateHome();
+    return true;
+  }, [isAtTabRoot, currentTab, onNavigateHome]);
+}

modules/tv-recommendations/android/src/main/AndroidManifest.xml

@@ -1,5 +1,4 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-  <uses-permission android:name="com.android.providers.tv.permission.WRITE_EPG_DATA" />
   <application>
     <receiver android:name=".TvRecommendationsReceiver" android:exported="true">
       <intent-filter>

modules/tv-recommendations/android/src/main/java/expo/modules/tvrecommendations/TvRecommendationsPublisher.kt

@@ -16,12 +16,13 @@ import androidx.tvprovider.media.tv.PreviewProgram
 import androidx.tvprovider.media.tv.TvContractCompat
 import org.json.JSONArray
 import org.json.JSONObject
+import java.security.MessageDigest
 
 internal object TvRecommendationsPublisher {
   private const val TAG = "TvRecommendations"
   private const val PREFS_NAME = "StreamyfinTvRecommendations"
   private const val KEY_PAYLOAD = "payload"
-  private const val KEY_CHANNEL_ID = "channelId"
+  private const val KEY_CHANNEL_ID_PREFIX = "channelId_"
   private const val KEY_PROGRAM_IDS = "programIds"
   private const val DEFAULT_CHANNEL_NAME = "Continue and Next Up"
 
@@ -162,16 +163,24 @@ internal object TvRecommendationsPublisher {
     val prefs = preferences(context)
     val programIdsJson = prefs.getString(KEY_PROGRAM_IDS, null) ?: return
     try {
-      val programIds = JSONObject(programIdsJson)
+      val channelMap = JSONObject(programIdsJson)
-      val keys = programIds.keys()
+      val channelKeys = channelMap.keys()
-      while (keys.hasNext()) {
+      while (channelKeys.hasNext()) {
-        val key = keys.next()
+        val channelId = channelKeys.next()
-        if (programIds.optLong(key, -1L) == programId) {
+        val inner = channelMap.optJSONObject(channelId) ?: continue
-          programIds.remove(key)
+        val providerKeys = inner.keys()
-          break
+        while (providerKeys.hasNext()) {
+          val providerId = providerKeys.next()
+          if (inner.optLong(providerId, -1L) == programId) {
+            inner.remove(providerId)
+            if (inner.length() == 0) {
+              channelMap.remove(channelId)
+            }
+            break
+          }
         }
       }
-      prefs.edit().putString(KEY_PROGRAM_IDS, programIds.toString()).apply()
+      prefs.edit().putString(KEY_PROGRAM_IDS, channelMap.toString()).apply()
     } catch (e: Exception) {
       Log.w(TAG, "removeProgramFromPrefs(): failed to update prefs for programId=$programId", e)
     }
@@ -322,7 +331,8 @@ internal object TvRecommendationsPublisher {
 
   private fun getOrCreateChannel(context: Context, displayName: String): Long {
     val prefs = preferences(context)
-    val existingChannelId = prefs.getLong(KEY_CHANNEL_ID, -1L)
+    val channelKey = getChannelKey(displayName)
+    val existingChannelId = prefs.getLong(channelKey, -1L)
     val contentResolver = context.contentResolver
 
     if (existingChannelId > 0L) {
@@ -363,7 +373,7 @@ internal object TvRecommendationsPublisher {
 
       // Channel truly doesn't exist in provider — recreate
       Log.w(TAG, "getOrCreateChannel(): channelId=$existingChannelId not in provider, recreating")
-      prefs.edit().remove(KEY_CHANNEL_ID).apply()
+      prefs.edit().remove(channelKey).apply()
     }
 
     // Create a new channel
@@ -384,6 +394,7 @@ internal object TvRecommendationsPublisher {
     } ?: return -1L
 
     val channelId = ContentUris.parseId(channelUri)
+    prefs.edit().putLong(channelKey, channelId).apply()
     TvContractCompat.requestChannelBrowsable(context, channelId)
     storeChannelLogo(context, channelId)
     Log.d(TAG, "getOrCreateChannel(): created new channelId=$channelId displayName=\"$displayName\"")
@@ -391,6 +402,10 @@ internal object TvRecommendationsPublisher {
     return channelId
   }
 
+  private fun getChannelKey(displayName: String): String {
+    return KEY_CHANNEL_ID_PREFIX + displayName.hashCode()
+  }
+
   private fun upsertPreviewProgram(
     context: Context,
     channelId: Long,
@@ -462,13 +477,18 @@ internal object TvRecommendationsPublisher {
   }
 
   /**
-   * Append a cache-busting parameter to ensure unique URIs when images change.
+   * Append a stable cache key derived from the image URL.
-   * Per Android docs: "Use unique Uris for all images... the old image will
+   * The Jellyfin image URLs already include a `tag=` query param (etag)
-   * continue to appear if you don't change the Uri."
+   * that changes whenever the image content changes, so a deterministic
+   * hash of the URL is sufficient — the param only changes when the URL
+   * (and therefore the image) actually changes, avoiding unnecessary
+   * re-downloads on every sync.
    */
   private fun appendCacheBuster(imageUrl: String): String {
+    val digest = MessageDigest.getInstance("MD5").digest(imageUrl.toByteArray())
+    val hash = digest.joinToString("") { "%02x".format(it) }.substring(0, 16)
     val separator = if (imageUrl.contains("?")) "&" else "?"
-    return "$imageUrl${separator}_t=${System.currentTimeMillis()}"
+    return "$imageUrl${separator}_v=$hash"
   }
 
   private fun buildIntentUri(context: Context, deepLink: String): Uri {
@@ -531,8 +551,8 @@ internal object TvRecommendationsPublisher {
     return bitmap
   }
 
-  fun getChannelId(context: Context): Long {
+  fun getChannelId(context: Context, displayName: String = DEFAULT_CHANNEL_NAME): Long {
-    return preferences(context).getLong(KEY_CHANNEL_ID, -1L)
+    return preferences(context).getLong(getChannelKey(displayName), -1L)
   }
 
   private fun preferences(context: Context): SharedPreferences {
@@ -567,8 +587,10 @@ internal object TvRecommendationsPublisher {
           Log.w(TAG, "logProviderState(): channelId=$channelId exists=false")
         }
       } ?: Log.w(TAG, "logProviderState(): channel query returned null for channelId=$channelId")
-    } catch (error: SecurityException) {
+} catch (error: SecurityException) {
-      Log.w(TAG, "logProviderState(): lost provider permission for channelId=$channelId", error)
+  Log.w(TAG, "logProviderState(): lost provider permission for channelId=$channelId", error)
-    }
+} catch (error: Exception) {
+  Log.w(TAG, "logProviderState(): failed to query channelId=$channelId", error)
+}
   }
 }

modules/tv-recommendations/android/src/main/java/expo/modules/tvrecommendations/TvRecommendationsReceiver.kt

@@ -3,16 +3,24 @@ package expo.modules.tvrecommendations
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.ContentUris
 import android.util.Log
 import androidx.tvprovider.media.tv.TvContractCompat
 
 class TvRecommendationsReceiver : BroadcastReceiver() {
   override fun onReceive(context: Context, intent: Intent) {
-    if (intent.action != TvContractCompat.ACTION_INITIALIZE_PROGRAMS) {
+    when (intent.action) {
-      return
+      TvContractCompat.ACTION_INITIALIZE_PROGRAMS -> {
+        Log.d("TvRecommendations", "Handling INITIALIZE_PROGRAMS broadcast")
+        TvRecommendationsPublisher.refreshFromCache(context)
+      }
+      "android.media.tv.action.PREVIEW_PROGRAM_BROWSABLE_DISABLED" -> {
+        val programId = intent.data?.let { ContentUris.parseId(it) } ?: -1L
+        if (programId > 0L) {
+          Log.d("TvRecommendations", "Handling PREVIEW_PROGRAM_BROWSABLE_DISABLED for programId=$programId")
+          TvRecommendationsPublisher.deletePreviewProgram(context, programId)
+        }
+      }
     }
-
-    Log.d("TvRecommendations", "Handling INITIALIZE_PROGRAMS broadcast")
-    TvRecommendationsPublisher.refreshFromCache(context)
   }
 }

utils/jellyfin/media/getDownloadUrl.ts

@@ -50,7 +50,7 @@ export const getDownloadUrl = async ({
   if (maxBitrate.key === "Max" && !streamDetails?.mediaSource?.TranscodingUrl) {
     console.log("Downloading item directly");
     return {
-      url: `${api.basePath}/Items/${item.Id}/Download?api_key=${api.accessToken}`,
+      url: `${api.basePath}/Items/${mediaSource.Id}/Download?api_key=${api.accessToken}`,
       mediaSource: streamDetails?.mediaSource ?? null,
     };
   }