more updates

changelog

···
   - Move away from localstorage and use the .config file
   - Seems to be semi-stable on linux
   - Update deeplink library
-  - Fix bugs with multiple screens displaying on frontend
+  - Fix bugs with multiple screens displaying on frontend
+  - Fix caching issues with photo paths
+  - Fix VRCPM using way to many resources while being minimised after starting in the background

src-tauri/src/frontend_calls/delete_photo.rs

···
-use crate::util::get_photo_path::get_photo_path;
-use std::{fs, thread, time::Duration};
+use tauri::State;
+
+use crate::util::cache::Cache;
+use std::{ fs, thread, time::Duration };
 
 // Delete a photo when the users confirms the prompt in the ui
 #[tauri::command]
-pub fn delete_photo(path: String, token: String, is_syncing: bool) {
+pub fn delete_photo(path: String, token: String, is_syncing: bool, cache: State<Cache>) {
+  let photo_path = cache.get("photo-path".into());
+
   thread::spawn(move || {
-    let p = get_photo_path().join(&path);
+    let p = photo_path.unwrap() + "/" + &path;
     fs::remove_file(p).unwrap();
 
     let photo = path.split("/").last().unwrap();

src-tauri/src/frontend_calls/get_user_photos_path.rs

···
-use crate::util::get_photo_path::get_photo_path;
-use std::path;
+use tauri::State;
+
+use crate::util::cache::Cache;
 
 // Check if the photo config file exists
 // if not just return the default vrchat path
 #[tauri::command]
-pub fn get_user_photos_path() -> path::PathBuf {
-  get_photo_path()
+pub fn get_user_photos_path( cache: State<Cache> ) -> String {
+  let photo_path = cache.get("photo-path".into());
+  photo_path.unwrap()
 }

src-tauri/src/frontend_calls/load_photo_meta.rs

···
-use crate::util::get_photo_path::get_photo_path;
+use crate::util::cache::Cache;
 use crate::PNGImage;
 use std::{fs, io::Read, thread};
-use tauri::Emitter;
+use tauri::{Emitter, State};
 
 // Reads the PNG file and loads the image metadata from it
 // then sends the metadata to the frontend, returns width, height, colour depth and so on... more info "pngmeta.rs"
 #[tauri::command]
-pub fn load_photo_meta(photo: &str, window: tauri::Window) {
+pub fn load_photo_meta(photo: &str, window: tauri::Window, cache: State<Cache> ) {
+  let photo_path = cache.get("photo-path".into());
   let photo = photo.to_string();
 
   thread::spawn(move || {
-    let base_dir = get_photo_path().join(&photo);
+    let base_dir = photo_path.unwrap() + "/" + &photo;
 
     let file = fs::File::open(base_dir.clone());
 

src-tauri/src/frontend_calls/load_photos.rs

···
-use crate::util::get_photo_path::get_photo_path;
+use crate::util::cache::Cache;
 use regex::Regex;
 use std::{fs, path, thread};
-use tauri::Emitter;
+use tauri::{Emitter, State};
 
 // Scans all files under the "Pictures/VRChat" path
 // then sends the list of photos to the frontend
···
 }
 
 #[tauri::command]
-pub fn load_photos(window: tauri::Window) {
+pub fn load_photos(window: tauri::Window, cache: State<Cache> ) {
+  let base_dir = cache.get("photo-path".into()).unwrap();
+
   thread::spawn(move || {
-    let base_dir = get_photo_path();
 
     let mut photos: Vec<path::PathBuf> = Vec::new();
     let mut size: usize = 0;

src-tauri/src/main.rs

···
 use notify::{EventKind, RecursiveMode, Watcher};
 use pngmeta::PNGImage;
 use regex::Regex;
+use util::cache::Cache;
 use std::{env, fs, thread};
 use tauri::{Emitter, Manager, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
···
 // TODO: Linux support
 
 fn main() {
+  let cache = Cache::new();
+
   // Double check the app has an install directory
   let container_folder = dirs::config_dir()
     .unwrap()
···
 
   println!("Loading App...");
   let photos_path = util::get_photo_path::get_photo_path();
+
+  cache.insert("photo-path".into(), photos_path.to_str().unwrap().to_owned());
 
   match fs::metadata(&photos_path) {
     Ok(_) => {}
···
       }
       _ => {}
     })
+    .manage(cache)
     .setup(|app| {
       let handle = app.handle();
 

src-tauri/src/util/cache.rs

···
+use std::{collections::HashMap, sync::Mutex};
+
+pub struct Cache{
+  store: Mutex<HashMap<String, String>>,
+}
+
+impl Cache{
+  pub fn new() -> Self{
+    Cache {
+      store: Mutex::new(HashMap::new())
+    }
+  }
+
+  pub fn insert( &self, key: String, value: String ){
+    self.store.lock().unwrap().insert(key, value);
+  }
+
+  pub fn get( &self, key: String ) -> Option<String>{
+    let store = self.store.lock().unwrap();
+    let val = store.get(&key);
+
+    if val.is_none(){
+      None
+    } else{
+      Some(val.unwrap().clone())
+    }
+  }
+}

src-tauri/src/util/get_photo_path.rs

···
-use std::{fs, path, sync::RwLock};
-
-static CACHED_PATH: RwLock<Option<path::PathBuf>> = RwLock::new(None);
+use std::{ fs, path };
 
 pub fn get_photo_path() -> path::PathBuf {
-  let path = CACHED_PATH.read().unwrap();
-  if path.is_none(){
-    let config_path = dirs::config_dir()
-      .unwrap()
-      .join("PhazeDev/VRChatPhotoManager/.photos_path");
-
-    dbg!(&config_path);
-
-    match fs::read_to_string(config_path) {
-      Ok(path) => {
-        let p = path::PathBuf::from(path);
+  let config_path = dirs::config_dir()
+    .unwrap()
+    .join("PhazeDev/VRChatPhotoManager/.photos_path");
 
-        let mut wpath = CACHED_PATH.write().unwrap();
-        *wpath = Some(p.clone());
+  dbg!(&config_path);
 
-        p
-      },
-      Err(_) => {
-        let p = dirs::picture_dir().unwrap().join("VRChat");
+  match fs::read_to_string(config_path) {
+    Ok(path) => {
+      path::PathBuf::from(path)
+    },
+    Err(_) => {
+      let p = dirs::picture_dir().unwrap().join("VRChat");
 
-        p
-      }
+      p
     }
-  } else{
-    path.clone().unwrap()
   }
 }

src-tauri/src/util/mod.rs

···
 pub mod handle_uri_proto;
 pub mod handle_deeplink;
 pub mod setup_traymenu;
+pub mod cache;

src/Components/PhotoList.tsx

···
   let scroll: number = 0;
   let targetScroll: number = 0;
 
-  let quitRender: boolean = false;
+  let quitRender: boolean = true;
   let photoPath: string;
 
   let currentPopup = ListPopup.NONE;
···
   })
 
   let render = () => {
+    console.log('render', quitRender);
+
     if(!quitRender)
       requestAnimationFrame(render);
     else
···
   }
 
   listen('hide-window', () => {
+    console.log('Hide Window');
     quitRender = true;
   })
 
   listen('show-window', () => {
+    console.log('Shown Window');
+    quitRender = false;
+
     if(hasFirstLoaded)
       requestAnimationFrame(render);
   })