add caching for home and view + add storage cleanup + update app version

Author: GoodDay360

snap/snapcraft.yaml

@@ -1,6 +1,6 @@
 name: hyperionbox
 base: core22
-version: '2.0.5'
+version: '2.0.6'
 summary: An open-source anime and movie streaming desktop app. # 79 char long summary
 description: |
   An open-source anime and movie streaming app that support watch progress and download for many sources.

src-tauri/Cargo.lock

@@ -58,6 +58,7 @@ tauri-plugin-android-fs = "16.1.2"
 tauri-plugin-dialog = "2"
 dunce = "1.0.5"
 html-escape = "0.2.13"
+fs_extra = "1.3.0"
 
 [target.'cfg(target_os = "android")'.dependencies]
 tauri-plugin-android-package-install = "2.0.2"

src-tauri/Cargo.toml

@@ -226,6 +226,33 @@ pub fn get_item_from_favorite(tag_name: String) -> Result<Vec<ItemFromFavorite>,
     Ok(items)
 }
 
+
+pub fn get_all_item_from_favorite() -> Result<Vec<ItemFromFavorite>, String> {
+    let conn = get_db()?;
+
+    let mut stmt = conn
+        .prepare(
+            "SELECT source, id, timestamp
+                FROM favorite
+                GROUP BY source, id, timestamp",
+        )
+        .map_err(|e| e.to_string())?;
+
+    let items = stmt
+        .query_map([], |row| {
+            Ok(ItemFromFavorite {
+                source: row.get(0)?,
+                id: row.get(1)?,
+                timestamp: row.get::<_, i64>(2)? as usize,
+            })
+        })
+        .map_err(|e| e.to_string())?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| e.to_string())?;
+
+    Ok(items)
+}
+
 #[tauri::command]
 pub async fn update_timestamp_favorite(source: String, id: String) -> Result<(), String> {
     let conn = get_db()?; // Reuse your existing get_db function

src-tauri/src/commands/favorite.rs

@@ -1,4 +1,4 @@
-use serde_json::{from_reader, to_string_pretty};
+use serde_json::{from_reader, to_string};
 use std::fs;
 use std::io::BufReader;
 
@@ -72,7 +72,7 @@ pub async fn save_local_manifest(
     let manifest_path = item_dir.join("manifest.json");
 
     let local_manifest_data_to_string =
-        to_string_pretty(&local_manifest_data).map_err(|e| e.to_string())?;
+        to_string(&local_manifest_data).map_err(|e| e.to_string())?;
     fs::write(&manifest_path, local_manifest_data_to_string).map_err(|e| e.to_string())?;
 
     return Ok(());

src-tauri/src/commands/local_manifest.rs

@@ -0,0 +1,68 @@
+use fs_extra::dir::get_size;
+use std::fs;
+
+use crate::utils::configs::Configs;
+use crate::commands::favorite;
+
+#[tauri::command]
+pub async fn get_storage_size() -> Result<usize, String> {
+    let app_configs = Configs::get()?;
+    let storage_dir = app_configs.storage_dir.ok_or("Storage directory not set".to_string())?;
+
+    if storage_dir.exists() {
+        match get_size(&storage_dir) {
+            Ok(size) => return Ok(size as usize),
+            Err(e) => return Err(e.to_string()),
+        }
+    }else {
+        return Ok(0);
+    }
+}
+
+#[tauri::command]
+pub async fn clean_storage() -> Result<(), String> {
+    let app_configs = Configs::get()?;
+    let storage_dir = app_configs.storage_dir.ok_or("Storage directory not set".to_string())?;
+
+    let favorite_data = favorite::get_all_item_from_favorite()?;
+
+
+    let mut favorite_source_data: Vec<String> = Vec::new();
+    let mut favorite_id_data: Vec<String> = Vec::new();
+
+    for item in favorite_data {
+        favorite_source_data.push(item.source);
+        favorite_id_data.push(item.id);
+    }
+
+    /* Clean all item that not in favorite */
+    let entries = fs::read_dir(&storage_dir).map_err(|e|e.to_string())?;
+    for entry in entries {
+        let entry = entry.map_err(|e|e.to_string())?;
+        let path = entry.path();
+        if path.is_dir() {
+            let folder_name = path.file_name().ok_or("Fail to get folder name")?.to_string_lossy().to_string();
+            if !favorite_source_data.contains(&folder_name) {
+                fs::remove_dir_all(path).map_err(|e|e.to_string())?;
+            }else{
+                let current_source_dir = storage_dir.join(&folder_name);
+                let current_source_entries = fs::read_dir(&current_source_dir).map_err(|e|e.to_string())?;
+                for current_source_entry in current_source_entries {
+                    let current_source_entry = current_source_entry.map_err(|e|e.to_string())?;
+                    let path = current_source_entry.path();
+                    if path.is_dir() {
+                        let folder_name = path.file_name().ok_or("Fail to get folder name")?.to_string_lossy().to_string();
+                        if !favorite_id_data.contains(&folder_name) {
+                            fs::remove_dir_all(path).map_err(|e|e.to_string())?;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /* --- */
+
+
+
+    return Ok(())
+}

src-tauri/src/commands/manage_storage.rs

@@ -0,0 +1,141 @@
+use tracing::{error};
+use std::fs;
+use std::io::BufReader;
+use serde_json::{from_reader, to_string};
+use chrono::Utc;
+
+use crate::sources::anime;
+use crate::sources::movie;
+use crate::commands::favorite::{get_recent_from_favorite};
+use crate::commands::local_manifest::{get_local_manifest};
+use crate::utils::configs::Configs;
+
+use crate::models::home::{Content, ContentData, HomeData};
+
+const CACHE_DELAY: usize = 3 * 60 * 60 * 1000; // In milliseconds
+
+async fn get_cache(source: &str) -> Result<Option<HomeData>, String> {
+    let app_config = Configs::get()?;
+    
+    let cache_dir = app_config.cache_dir.ok_or("Cache dir not set!")?;
+
+    let home_cache_path = cache_dir.join(&format!("home_{}.json", source));
+
+    if  home_cache_path.exists() {
+        let file = fs::File::open(& home_cache_path).map_err(|e| e.to_string())?;
+        let reader = BufReader::new(file);
+        match from_reader::<BufReader<std::fs::File>, HomeData>(reader) {
+            Ok(data) => return Ok(Some(data)),
+            Err(_) => {
+                return Ok(None)
+            }
+        }
+    }
+    
+    return Ok(None);
+}
+
+async fn save_cache(source: &str, data: &HomeData) -> Result<(), String> {
+    let app_config = Configs::get()?;
+    let cache_dir = app_config.cache_dir.ok_or("Cache dir not set!")?;
+
+    if !cache_dir.exists() {
+        fs::create_dir_all(&cache_dir).map_err(|e| e.to_string())?;
+    }
+
+    let home_cache_path = cache_dir.join(&format!("home_{}.json", source));
+    
+    let data_to_string = to_string(&data).map_err(|e| e.to_string())?;
+    fs::write(&home_cache_path, data_to_string).map_err(|e| e.to_string())?;
+    
+    return Ok(());
+}
+
+#[tauri::command]
+pub async fn home(source: String, force_remote: bool) -> Result<HomeData, String> {
+    let mut home_data: HomeData = HomeData {
+        relevant_content: vec![],
+        content: vec![],
+        last_save_timestamp: 0,
+    };
+
+    let mut should_fetch_remote: bool = true;
+
+    if !force_remote {
+        if let Some(cache_home_data) = get_cache(&source).await?{
+            let current_timestamp: usize = Utc::now().timestamp_millis() as usize;
+            if (current_timestamp - cache_home_data.last_save_timestamp) < CACHE_DELAY {
+                home_data = cache_home_data;
+                should_fetch_remote = false;
+            }
+        }
+    }
+
+    if should_fetch_remote {
+        if source == "anime" {
+            match anime::home::new(&source).await {
+                Ok(data) => home_data = data,
+                Err(e) => {
+                    error!("[HOME] Error: {}", e);
+                }
+            }
+        }else if source == "movie" {
+            match movie::home::new(&source).await {
+                Ok(data) => home_data = data,
+                Err(e) => {
+                    error!("[HOME] Error: {}", e);
+                }
+            }
+        }else{
+            return Err("Unkown Source".to_string());
+        }
+
+        save_cache(&source, &home_data).await?;
+    }
+    
+
+    /* Load Recent Watch */
+    let content_data = &mut home_data.content;
+
+    let mut recent_content_data: Vec<ContentData> = vec![];
+    let recent_from_favorite = get_recent_from_favorite(15).await?;
+    for item in recent_from_favorite {
+        let local_manifest = get_local_manifest(item.source.clone(), item.id.to_string()).await?;
+        match local_manifest.manifest_data {
+            Some(data) => {
+                let new_content = ContentData {
+                    source: item.source,
+                    id: item.id.to_string().clone(),
+                    title: data.title,
+                    poster: data.poster,
+                };
+                recent_content_data.push(new_content);
+            }
+            None => {
+                let new_content = ContentData {
+                    source: item.source,
+                    id: item.id.to_string().clone(),
+                    title: "?".to_string(),
+                    poster: "".to_string(),
+                };
+                recent_content_data.push(new_content);
+            }
+        }
+    }
+
+    if recent_content_data.len() > 0 {
+        content_data.insert(
+            0,
+            Content {
+                label: "Continue watching".to_string(),
+                data: recent_content_data,
+            },
+        );
+    }
+    /* --- */
+
+    return Ok(home_data);
+}
+
+
+

src-tauri/src/commands/methods/home.rs

@@ -0,0 +1,3 @@
+pub mod home;
+pub mod view;
+pub mod search;

src-tauri/src/commands/methods/mod.rs

@@ -0,0 +1,29 @@
+
+use tracing::{error};
+
+use crate::sources::anime;
+use crate::sources::movie;
+use crate::models::search::SearchData;
+
+
+#[tauri::command]
+pub async fn search(source: String, page: usize, search: String) -> Result<Vec<SearchData>, String> {
+    if source == "anime" {
+        match anime::search::new(page, &search).await {
+            Ok(data) => return Ok(data),
+            Err(e) => {
+                error!("Error: {}", e);
+                return Err(e);
+            }
+        }
+    }else if source == "movie" {
+        match movie::search::new(page, &search).await {
+            Ok(data) => return Ok(data),
+            Err(e) => {
+                error!("[HOME] Error: {}", e);
+                return Err(e)?;
+            }
+        }
+    }
+    return Err("Unkown Source".to_string());
+}