small bugfix

changelog

···
   - Added update available prompt
 
   - Remove all sync stuff
-  - Removed automatic updates
+  - Removed automatic updates
+
+v0.2.7:
+  - Fixed loading when an image file is corrupted
+  - Fixed update prompt when not connected to internet

src-tauri/Cargo.lock

···
 
 [[package]]
 name = "VRChatPhotoManager"
-version = "0.2.6"
+version = "0.2.7"
 dependencies = [
  "arboard",
  "dirs 5.0.1",

src-tauri/Cargo.toml

···
 [package]
 name = "VRChatPhotoManager"
-version = "0.2.6"
+version = "0.2.7"
 description = "VRChat Photo Manager"
 authors = ["_phaz"]
 edition = "2021"

src-tauri/src/frontend_calls/load_photo_meta.rs

···
         let mut buffer = Vec::new();
 
         let _out = file.read_to_end(&mut buffer);
-        window
-          .emit("photo_meta_loaded", PNGImage::new(buffer, photo))
-          .unwrap();
+        let png = PNGImage::new(buffer, photo.clone());
+
+        if png.is_err(){
+          println!("Failed to load: {} => {}", base_dir, png.unwrap_err());
+
+          window.emit("photo_meta_loaded", PNGImage {
+            width: 1920,
+            height: 1080,
+            bit_depth: 0,
+            colour_type: 0,
+            compression_method: 0,
+            filter_method: 0,
+            interlace_method: 0,
+            metadata: "".into(),
+            error: true,
+            path: photo
+          }).unwrap();
+        } else{
+          println!("Loaded: {}", base_dir);
+          window.emit("photo_meta_loaded", png.unwrap()).unwrap();
+        }
       }
       Err(_) => {
         println!("Cannot read image file: {:?}", base_dir);

src-tauri/src/pngmeta.rs

···
-use serde::ser::{Serialize, SerializeStruct, Serializer};
 use std::str;
 
-#[derive(Clone)]
+use serde::Serialize;
+
+#[derive(Clone, Debug, Serialize)]
 pub struct PNGImage {
   pub width: u32,
   pub height: u32,
···
   pub interlace_method: u8,
   pub metadata: String,
   pub path: String,
+  pub error: bool
 }
 
 impl PNGImage {
-  pub fn new(buff: Vec<u8>, path: String) -> PNGImage {
+  pub fn new(buff: Vec<u8>, path: String) -> Result<PNGImage, &'static str> {
     if buff[0] != 0x89
       || buff[1] != 0x50
       || buff[2] != 0x4E
···
       || buff[7] != 0x0A
     {
       dbg!(path);
-      panic!("Image is not a PNG file");
+      return Err("Image is not a PNG file");
     }
 
     let mut img = PNGImage {
···
       interlace_method: 0,
       metadata: "".to_string(),
       path: path,
+      error: false
     };
 
     img.read_png_chunk(8, buff);
-    img
+    Ok(img)
   }
 
   fn read_png_chunk(&mut self, start_byte: usize, buff: Vec<u8>) {
···
     }
   }
 }
-
-impl Serialize for PNGImage {
-  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-  where
-    S: Serializer,
-  {
-    let mut s = serializer.serialize_struct("PNGImage", 7)?;
-    s.serialize_field("width", &self.width)?;
-    s.serialize_field("height", &self.height)?;
-    s.serialize_field("bit_depth", &self.bit_depth)?;
-    s.serialize_field("colour_type", &self.colour_type)?;
-    s.serialize_field("compression_method", &self.compression_method)?;
-    s.serialize_field("filter_method", &self.filter_method)?;
-    s.serialize_field("interlace_method", &self.interlace_method)?;
-    s.serialize_field("metadata", &self.metadata)?;
-    s.serialize_field("path", &self.path)?;
-    s.end()
-  }
-}

src/Components/Managers/PhotoListRenderingManager.tsx

···
             // ctx.strokeStyle = '#f00';
             // ctx.strokeRect((rowXPos - row.Width / 2) + canvas.width / 2, currentY - scroll, photo.scaledWidth!, row.Height);
 
-            if(!photo.loaded)
+            if(photo.error){
+              ctx.fillStyle = '#fff';
+              ctx.textAlign = 'center';
+              ctx.textBaseline = 'middle';
+
+              photo.x = (rowXPos  - row.Width / 2) + canvas.width / 2;
+              photo.y = currentY - scroll;
+
+              ctx.font = '18px Rubik'
+              ctx.fillText('Error loading image.', photo.x + photo.scaledWidth! / 2, photo.y + photo.scaledHeight! / 2);
+            } else if(!photo.loaded)
               // If the photo is not loaded, start a new task and load it in that task
               setTimeout(() => photo.loadImage(), 1);
             else{

src/Components/Managers/PhotoManager.tsx

···
       //       we don't need to store metadata of those photos as they inherit this
       //       data from the main photo.
 
+      photo.error = data.error;
       this._lastLoaded = photo.index;
 
       if(this._onLoadedMeta[photo.index]){
···
   
       photo.metadata = data.metadata.split('\u0000').filter(x => x !== '')[1];
       this._amountLoaded++;
-  
+
+      photo.loadingMeta = false;
       photo.metaLoaded = true;
       photo.onMetaLoaded();
 

src/Components/PhotoList.tsx

···
   onMount(() => {
     // Update Stuff
     fetch('https://api.github.com/repos/phaze-the-dumb/VRChat-Photo-Manager/releases/latest')
-      .then(data => data.json())
-      .then(async data => {
-        let currentVersion = await invoke('get_version');
-        setUpdateAvailable(data.tag_name !== currentVersion);
+      .then(data => {
+        if(data.status !== 200)return;
+
+        data.json().then(async data => {
+          let currentVersion = await invoke('get_version');
+          setUpdateAvailable(data.tag_name !== currentVersion);
+        })
+      })
+      .catch(e => {
+        console.error(e);
+        setUpdateAvailable(false);
       })
 
     // Other Stuff

src/Components/Structs/Photo.ts

···
 export class Photo{
   path: string;
   loaded: boolean = false;
+  loadingMeta: boolean = false;
   loading: boolean = false;
   metaLoaded: boolean = false;
   image?: HTMLCanvasElement;
···
   height?: number;
   loadingRotate: number = 0;
   metadata: any;
+
+  error: boolean = false;
 
   frames: number = 0;
   shown: boolean = false;
···
   }
 
   loadMeta(){
+    this.loadingMeta = true;
     invoke('load_photo_meta', { photo: this.path });
   }
 
   loadImage(){
-    if(this.loading || this.loaded || imagesLoading >= Vars.MAX_IMAGE_LOAD)return;
-
-    // this.loadMeta();
+    if(this.loadingMeta || this.loading || this.loaded || imagesLoading >= Vars.MAX_IMAGE_LOAD)return;
     if(!this.metaLoaded)return this.loadMeta();
 
     this.loading = true;
-
     imagesLoading++;
 
     this.image = document.createElement('canvas');
···
       this.loading = false;
 
       imagesLoading--;
+    }
+
+    this.imageEl.onerror = () => {
+      console.log('Cannot load image');
     }
   }
 }

src/Components/Structs/PhotoMetadata.ts

···
   height!: number;
   metadata!: string;
   path!: string;
+  error!: boolean;
 }