feat: use API to check for updates

Author: CodeDead

src-tauri/src/main.rs

@@ -9,6 +9,7 @@ use std::sync::{Arc, Mutex};
 use std::thread::available_parallelism;
 use std::time::Duration;
 use std::{fs, thread};
+use tauri::Manager;
 
 mod result;
 
@@ -26,6 +27,15 @@ fn main() {
     };
 
     tauri::Builder::default()
+        .setup(|app| {
+            #[cfg(debug_assertions)] // only include this code on debug builds
+            {
+                let window = app.get_webview_window("main").unwrap();
+                window.open_devtools();
+                window.close_devtools();
+            }
+            Ok(())
+        })
         .plugin(tauri_plugin_os::init())
         .plugin(tauri_plugin_dialog::init())
         .manage(shared_state)

src/components/Layout/index.jsx

@@ -2,9 +2,9 @@ import React, { Suspense, useContext, useEffect } from 'react';
 import Box from '@mui/material/Box';
 import CssBaseline from '@mui/material/CssBaseline';
 import { createTheme, ThemeProvider } from '@mui/material/styles';
-import { platform } from '@tauri-apps/plugin-os';
+import { getVersion } from '@tauri-apps/api/app';
+import { platform, arch } from '@tauri-apps/plugin-os';
 import { Outlet } from 'react-router-dom';
-import packageJson from '../../../package.json';
 import { MainContext } from '../../contexts/MainContextProvider';
 import {
   getNumberOfThreads,
@@ -49,7 +49,7 @@ const Layout = () => {
   /**
    * Check for updates
    */
-  const checkForUpdates = () => {
+  const checkForUpdates = async () => {
     if (loading) {
       return;
     }
@@ -59,7 +59,10 @@ const Layout = () => {
 
     try {
       const res = platform();
-      Updater(res.toLowerCase(), packageJson.version)
+      const archRes = arch();
+      const ver = 'v' + (await getVersion());
+
+      Updater(res.toLowerCase(), archRes, ver)
         .then((up) => {
           d1(setUpdate(up));
         })

src/routes/Settings/index.jsx

@@ -35,8 +35,8 @@ import RadioGroup from '@mui/material/RadioGroup';
 import Select from '@mui/material/Select';
 import TextField from '@mui/material/TextField';
 import Typography from '@mui/material/Typography';
-import { platform } from '@tauri-apps/plugin-os';
-import packageJson from '../../../package.json';
+import { getVersion } from '@tauri-apps/api/app';
+import { platform, arch } from '@tauri-apps/plugin-os';
 import AlertDialog from '../../components/AlertDialog';
 import GridList from '../../components/GridList';
 import Theme from '../../components/Theme';
@@ -146,7 +146,7 @@ const Settings = () => {
   /**
    * Check for updates
    */
-  const checkForUpdates = () => {
+  const checkForUpdates = async () => {
     if (loading) {
       return;
     }
@@ -156,7 +156,10 @@ const Settings = () => {
 
     try {
       const res = platform();
-      Updater(res.toLowerCase(), packageJson.version)
+      const archRes = arch();
+      const ver = 'v' + (await getVersion());
+
+      Updater(res.toLowerCase(), archRes.toLowerCase(), ver)
         .then((up) => {
           d1(setUpdate(up));
           d1(setCheckedForUpdates(true));

src/utils/Updater/index.js

@@ -1,57 +1,62 @@
-const Updater = (os, currentVersion) => {
+const Updater = (os, architectureName, currentVersion) => {
   /**
-   * Check whether version b is newer than version a
-   * @param a Version a
-   * @param b Version b
-   * @returns {boolean} True if version b is newer than version a, otherwise false
+   * Compare two semantic versions
+   * @param ver1 Version 1
+   * @param ver2 Version 2
+   * @returns {number} 1 if ver1 > ver2, -1 if ver1 < ver2, 0 if equal
    */
-  const isNewer = (a, b) => {
-    const partsA = a.split('.');
-    const partsB = b.split('.');
-    const numParts =
-      partsA.length > partsB.length ? partsA.length : partsB.length;
+  const semverCompare = (ver1, ver2) => {
+    const v1Parts = ver1.slice(1).split('.').map(Number);
+    const v2Parts = ver2.slice(1).split('.').map(Number);
 
-    for (let i = 0; i < numParts; i += 1) {
-      if ((parseInt(partsB[i], 10) || 0) !== (parseInt(partsA[i], 10) || 0)) {
-        return (parseInt(partsB[i], 10) || 0) > (parseInt(partsA[i], 10) || 0);
-      }
+    for (let i = 0; i < 3; i++) {
+      if (v1Parts[i] > v2Parts[i]) return 1;
+      if (v1Parts[i] < v2Parts[i]) return -1;
     }
-
-    return false;
+    return 0;
   };
 
   /**
-   * Parse the information inside an external update
-   * @param update The update data
-   * @returns {{infoUrl: null, updateUrl: boolean, downloadUrl: null, version: null}}
+   * Parse the update data
+   * @param data The update data
+   * @returns {{updateUrl, infoUrl: *, version: SemVer, updateAvailable: boolean}} The parsed update data
    */
-  const parseUpdate = (update) => {
-    const platform = update.platforms[os];
-    const data = {
-      updateUrl: false,
-      downloadUrl: null,
-      infoUrl: null,
-      version: null,
-    };
+  const parseUpdate = (data) => {
+    const platform = data.platforms.find(
+      (p) => p.platformName.toLowerCase() === os.toLowerCase(),
+    );
+    if (!platform) {
+      throw new Error(`Platform ${os} not found`);
+    }
 
-    if (
-      isNewer(
-        currentVersion,
-        `${platform.version.majorVersion}.${platform.version.minorVersion}.${platform.version.buildVersion}.${platform.version.revisionVersion}`,
-      )
-    ) {
-      data.updateAvailable = true;
+    // Find the architecture
+    const architecture = platform.architectures.find(
+      (a) => a.name === architectureName,
+    );
+    if (!architecture) {
+      throw new Error(
+        `Architecture ${architectureName} not found for platform ${os}`,
+      );
     }
 
-    data.updateUrl = platform.updateUrl;
-    data.infoUrl = platform.infoUrl;
-    data.version = `${platform.version.majorVersion}.${platform.version.minorVersion}.${platform.version.buildVersion}.${platform.version.revisionVersion}`;
+    // Sort releases by semver in descending order
+    const sortedReleases = architecture.releases.sort((a, b) => {
+      return semverCompare(b.semver, a.semver);
+    });
 
-    return data;
+    return {
+      updateUrl: sortedReleases[0].downloadUrl,
+      infoUrl: sortedReleases[0].infoUrl,
+      version: sortedReleases[0].semver,
+      updateAvailable:
+        semverCompare(currentVersion, sortedReleases[0].semver) < 0,
+    };
   };
 
   return new Promise((resolve, reject) => {
-    fetch('https://codedead.com/Software/Advanced%20PortChecker/version.json')
+    fetch(
+      'https://api.codedead.com/api/v1/applications/47cd7e8f-2744-443c-850e-619df5d5c43f',
+    )
       .then((res) => {
         if (!res.ok) {
           throw Error(res.statusText);