chore: refactor

hooks/useDownloadMedia.ts

@@ -0,0 +1,117 @@
+import { useCallback, useRef, useState } from "react";
+import { useAtom } from "jotai";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import * as FileSystem from "expo-file-system";
+import { Api } from "@jellyfin/sdk";
+import { BaseItemDto } from "@jellyfin/sdk/lib/generated-client/models";
+import { runningProcesses } from "@/utils/atoms/downloads";
+
+/**
+ * Custom hook for downloading media using the Jellyfin API.
+ *
+ * @param api - The Jellyfin API instance
+ * @param userId - The user ID
+ * @returns An object with download-related functions and state
+ */
+export const useDownloadMedia = (api: Api | null, userId?: string | null) => {
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [_, setProgress] = useAtom(runningProcesses);
+  const downloadResumableRef = useRef<FileSystem.DownloadResumable | null>(
+    null,
+  );
+
+  const downloadMedia = useCallback(
+    async (item: BaseItemDto | null): Promise<boolean> => {
+      if (!item?.Id || !api || !userId) {
+        setError("Invalid item or API");
+        return false;
+      }
+
+      setIsDownloading(true);
+      setError(null);
+      setProgress({ item, progress: 0 });
+
+      try {
+        const filename = item.Id;
+        const fileUri = `${FileSystem.documentDirectory}${filename}`;
+        const url = `${api.basePath}/Items/${item.Id}/File`;
+
+        downloadResumableRef.current = FileSystem.createDownloadResumable(
+          url,
+          fileUri,
+          {
+            headers: {
+              Authorization: `MediaBrowser DeviceId="${api.deviceInfo.id}", Token="${api.accessToken}"`,
+            },
+          },
+          (downloadProgress) => {
+            const currentProgress =
+              downloadProgress.totalBytesWritten /
+              downloadProgress.totalBytesExpectedToWrite;
+            setProgress({ item, progress: currentProgress * 100 });
+          },
+        );
+
+        const res = await downloadResumableRef.current.downloadAsync();
+
+        if (!res?.uri) {
+          throw new Error("Download failed: No URI returned");
+        }
+
+        await updateDownloadedFiles(item);
+
+        setIsDownloading(false);
+        setProgress(null);
+        return true;
+      } catch (error) {
+        console.error("Error downloading media:", error);
+        setError("Failed to download media");
+        setIsDownloading(false);
+        setProgress(null);
+        return false;
+      }
+    },
+    [api, userId, setProgress],
+  );
+
+  const cancelDownload = useCallback(async (): Promise<void> => {
+    if (!downloadResumableRef.current) return;
+
+    try {
+      await downloadResumableRef.current.pauseAsync();
+      setIsDownloading(false);
+      setError("Download cancelled");
+      setProgress(null);
+      downloadResumableRef.current = null;
+    } catch (error) {
+      console.error("Error cancelling download:", error);
+      setError("Failed to cancel download");
+    }
+  }, [setProgress]);
+
+  return { downloadMedia, isDownloading, error, cancelDownload };
+};
+
+/**
+ * Updates the list of downloaded files in AsyncStorage.
+ *
+ * @param item - The item to add to the downloaded files list
+ */
+async function updateDownloadedFiles(item: BaseItemDto): Promise<void> {
+  try {
+    const currentFiles: BaseItemDto[] = JSON.parse(
+      (await AsyncStorage.getItem("downloaded_files")) ?? "[]",
+    );
+    const updatedFiles = [
+      ...currentFiles.filter((file) => file.Id !== item.Id),
+      item,
+    ];
+    await AsyncStorage.setItem(
+      "downloaded_files",
+      JSON.stringify(updatedFiles),
+    );
+  } catch (error) {
+    console.error("Error updating downloaded files:", error);
+  }
+}

hooks/useFiles.ts

@@ -0,0 +1,84 @@
+import { BaseItemDto } from "@jellyfin/sdk/lib/generated-client/models";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { useQueryClient } from "@tanstack/react-query";
+import * as FileSystem from "expo-file-system";
+
+/**
+ * Custom hook for managing downloaded files.
+ * @returns An object with functions to delete individual files and all files.
+ */
+export const useFiles = () => {
+  const queryClient = useQueryClient();
+
+  /**
+   * Deletes all downloaded files and clears the download record.
+   */
+  const deleteAllFiles = async (): Promise<void> => {
+    const directoryUri = FileSystem.documentDirectory;
+    if (!directoryUri) {
+      console.error("Document directory is undefined");
+      return;
+    }
+
+    try {
+      const fileNames = await FileSystem.readDirectoryAsync(directoryUri);
+      await Promise.all(
+        fileNames.map((item) =>
+          FileSystem.deleteAsync(`${directoryUri}/${item}`, {
+            idempotent: true,
+          }),
+        ),
+      );
+      await AsyncStorage.removeItem("downloaded_files");
+      queryClient.invalidateQueries({ queryKey: ["downloaded_files"] });
+    } catch (error) {
+      console.error("Failed to delete all files:", error);
+    }
+  };
+
+  /**
+   * Deletes a specific file and updates the download record.
+   * @param id - The ID of the file to delete.
+   */
+  const deleteFile = async (id: string): Promise<void> => {
+    if (!id) {
+      console.error("Invalid file ID");
+      return;
+    }
+
+    try {
+      await FileSystem.deleteAsync(
+        `${FileSystem.documentDirectory}/${id}.mp4`,
+        { idempotent: true },
+      );
+
+      const currentFiles = await getDownloadedFiles();
+      const updatedFiles = currentFiles.filter((f) => f.Id !== id);
+
+      await AsyncStorage.setItem(
+        "downloaded_files",
+        JSON.stringify(updatedFiles),
+      );
+
+      queryClient.invalidateQueries({ queryKey: ["downloaded_files"] });
+    } catch (error) {
+      console.error(`Failed to delete file with ID ${id}:`, error);
+    }
+  };
+
+  return { deleteFile, deleteAllFiles };
+};
+
+/**
+ * Retrieves the list of downloaded files from AsyncStorage.
+ * @returns An array of BaseItemDto objects representing downloaded files.
+ */
+async function getDownloadedFiles(): Promise<BaseItemDto[]> {
+  try {
+    const filesJson = await AsyncStorage.getItem("downloaded_files");
+    return filesJson ? JSON.parse(filesJson) : [];
+  } catch (error) {
+    console.error("Failed to retrieve downloaded files:", error);
+    return [];
+  }
+}

hooks/useRemuxHlsToMp4.ts

@@ -0,0 +1,127 @@
+import { useCallback } from "react";
+import { useAtom } from "jotai";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import * as FileSystem from "expo-file-system";
+import { FFmpegKit, FFmpegKitConfig } from "ffmpeg-kit-react-native";
+import { BaseItemDto } from "@jellyfin/sdk/lib/generated-client/models";
+import { runningProcesses } from "@/utils/atoms/downloads";
+import { writeToLog } from "@/utils/log";
+
+/**
+ * Custom hook for remuxing HLS to MP4 using FFmpeg.
+ *
+ * @param url - The URL of the HLS stream
+ * @param item - The BaseItemDto object representing the media item
+ * @returns An object with remuxing-related functions
+ */
+export const useRemuxHlsToMp4 = (url: string, item: BaseItemDto) => {
+  const [_, setProgress] = useAtom(runningProcesses);
+
+  if (!item.Id || !item.Name) {
+    writeToLog("ERROR", "useRemuxHlsToMp4 ~ missing arguments");
+    throw new Error("Item must have an Id and Name");
+  }
+
+  const output = `${FileSystem.documentDirectory}${item.Id}.mp4`;
+  const command = `-y -fflags +genpts -i ${url} -c copy -bufsize 10M -max_muxing_queue_size 4096 ${output}`;
+
+  const startRemuxing = useCallback(async () => {
+    writeToLog(
+      "INFO",
+      `useRemuxHlsToMp4 ~ startRemuxing for item ${item.Id} with url ${url}`,
+    );
+
+    try {
+      setProgress({ item, progress: 0 });
+
+      FFmpegKitConfig.enableStatisticsCallback((statistics) => {
+        const videoLength =
+          (item.MediaSources?.[0]?.RunTimeTicks || 0) / 10000000; // In seconds
+        const fps = item.MediaStreams?.[0]?.RealFrameRate || 25;
+        const totalFrames = videoLength * fps;
+        const processedFrames = statistics.getVideoFrameNumber();
+        const speed = statistics.getSpeed();
+
+        const percentage =
+          totalFrames > 0
+            ? Math.floor((processedFrames / totalFrames) * 100)
+            : 0;
+
+        setProgress((prev) =>
+          prev?.item.Id === item.Id!
+            ? { ...prev, progress: percentage, speed }
+            : prev,
+        );
+      });
+
+      await FFmpegKit.executeAsync(command, async (session) => {
+        const returnCode = await session.getReturnCode();
+
+        if (returnCode.isValueSuccess()) {
+          await updateDownloadedFiles(item);
+          writeToLog(
+            "INFO",
+            `useRemuxHlsToMp4 ~ remuxing completed successfully for item: ${item.Name}`,
+          );
+        } else if (returnCode.isValueError()) {
+          writeToLog(
+            "ERROR",
+            `useRemuxHlsToMp4 ~ remuxing failed for item: ${item.Name}`,
+          );
+        } else if (returnCode.isValueCancel()) {
+          writeToLog(
+            "INFO",
+            `useRemuxHlsToMp4 ~ remuxing was canceled for item: ${item.Name}`,
+          );
+        }
+
+        setProgress(null);
+      });
+    } catch (error) {
+      console.error("Failed to remux:", error);
+      writeToLog(
+        "ERROR",
+        `useRemuxHlsToMp4 ~ remuxing failed for item: ${item.Name}`,
+      );
+      setProgress(null);
+    }
+  }, [output, item, command, setProgress]);
+
+  const cancelRemuxing = useCallback(() => {
+    FFmpegKit.cancel();
+    setProgress(null);
+    writeToLog(
+      "INFO",
+      `useRemuxHlsToMp4 ~ remuxing cancelled for item: ${item.Name}`,
+    );
+  }, [item.Name, setProgress]);
+
+  return { startRemuxing, cancelRemuxing };
+};
+
+/**
+ * Updates the list of downloaded files in AsyncStorage.
+ *
+ * @param item - The item to add to the downloaded files list
+ */
+async function updateDownloadedFiles(item: BaseItemDto): Promise<void> {
+  try {
+    const currentFiles: BaseItemDto[] = JSON.parse(
+      (await AsyncStorage.getItem("downloaded_files")) || "[]",
+    );
+    const updatedFiles = [
+      ...currentFiles.filter((i) => i.Id !== item.Id),
+      item,
+    ];
+    await AsyncStorage.setItem(
+      "downloaded_files",
+      JSON.stringify(updatedFiles),
+    );
+  } catch (error) {
+    console.error("Error updating downloaded files:", error);
+    writeToLog(
+      "ERROR",
+      `Failed to update downloaded files for item: ${item.Name}`,
+    );
+  }
+}