Pre 0.14 update commit

RedEpicness · RedEpicness · commit 20e57bedcf19 · 2025-10-26T16:49:19.000+01:00
diff --git a/wrapper/src/app.rs b/wrapper/src/app.rs
@@ -13,10 +13,9 @@
  * other in this repository, all of which is reserved by Essential.
  */
 
-use crate::download::download_java;
 use crate::file::extract_java_task;
 use crate::installer::{run_installer_task};
-use crate::java::get_java_executable_in_downloaded_jre;
+use crate::java::{fetch_java_url_task, get_java_executable_in_downloaded_jre};
 use crate::logging::get_logging_file_from_temp_directory;
 use crate::{fonts, WrapperInfo, BRAND};
 use arboard::Clipboard;
@@ -30,12 +29,12 @@ use iced::window::Mode;
 use iced::{
     color,
     widget::{progress_bar, text},
-    window, Alignment, Background, Border, Color, Element, Length, Padding, Pixels, Shadow, Size,
-    Subscription, Task, Vector,
+    window, Alignment, Background, Border, Color, Element, Length, Padding, Pixels, Shadow, Size, Task, Vector,
 };
 use log::{debug, error, warn};
 use std::fs::read_to_string;
 use std::path::PathBuf;
+use crate::download::download_java_task;
 
 pub fn start_app(app: WrapperApp, decorations: bool) {
     iced::application(
@@ -56,7 +55,6 @@ pub fn start_app(app: WrapperApp, decorations: bool) {
             .ok(),
         ..Default::default()
     })
-    .subscription(WrapperApp::subscription)
     .theme(move |_| AppTheme::default())
     .run_with(|| WrapperApp::new(app))
     .unwrap();
@@ -72,6 +70,8 @@ pub struct WrapperApp {
 pub enum AppState {
     #[default]
     Nothing,
+    FetchingURL,
+    StartDownloading(String),
     Downloading(String, f32),
     DownloadFinished(PathBuf),
     ExtractingJava(PathBuf),
@@ -94,7 +94,7 @@ static BODY_TEXT_SIZE: Pixels = Pixels(16.);
 
 impl WrapperApp {
     fn new(flags: WrapperApp) -> (WrapperApp, Task<AppMessage>) {
-        (flags, fonts::load_fonts())
+        (flags, Task::batch(vec![fonts::load_fonts(), fetch_java_url_task()]))
     }
 
     fn update(&mut self, message: AppMessage) -> Task<AppMessage> {
@@ -164,6 +164,10 @@ impl WrapperApp {
                 let state = self.app_state.clone();
                 window::get_oldest().and_then(move |id| match &state {
                     AppState::Downloading(_, _) => window::change_mode(id, Mode::Windowed),
+                    AppState::StartDownloading(url) => Task::batch(vec![
+                        window::change_mode(id, Mode::Windowed),
+                        download_java_task(url.clone(), cache_dir.clone()),
+                    ]),
                     AppState::ExtractingJava(download_path) => Task::batch(vec![
                         window::change_mode(id, Mode::Windowed),
                         extract_java_task(cache_dir.clone(), download_path.clone()),
@@ -286,15 +290,6 @@ impl WrapperApp {
             .into()
     }
 
-    fn subscription(&self) -> Subscription<AppMessage> {
-        debug!("Getting subscription {}", self.app_state);
-        match &self.app_state {
-            AppState::Downloading(url, _) => {
-                download_java(url.clone(), self.wrapper_info.cache_dir.clone())
-            }
-            _ => Subscription::none(),
-        }
-    }
 }
 
 // Visual stuff
diff --git a/wrapper/src/download.rs b/wrapper/src/download.rs
@@ -18,33 +18,32 @@ use crate::java::get_java_zip_path_from_cache_dir;
 use crate::util::TaskError;
 use iced::futures::{SinkExt, Stream, StreamExt};
 use iced::stream::try_channel;
-use iced::Subscription;
+use iced::Task;
 use log::{debug, error, info, warn};
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 use std::{fs, fs::File, io::Write};
 
-pub fn download_java<T: ToString>(url: T, cache_dir: PathBuf) -> Subscription<AppMessage> {
-    Subscription::run_with_id(
-        "download-java",
-        download_java_task(url.to_string(), cache_dir),
-    )
-    .map(|t| {
-        if let Err(e) = t {
+pub fn download_java_task(url: String, cache_dir: PathBuf) -> Task<AppMessage> {
+    Task::run(download_java_stream(url, cache_dir), move |r| {
+        if let Err(e) = r {
             error!("Error when downloading java: {}", e);
             AppMessage::UpdateState(AppState::Errored(format!("Error downloading java: {}", e)))
         } else {
-            AppMessage::UpdateState(t.unwrap())
+            debug!("Mapping: {}", r.clone().unwrap());
+            AppMessage::UpdateState(r.unwrap())
         }
     })
 }
 
-pub fn download_java_task(
+pub fn download_java_stream(
     url: String,
     cache_dir: PathBuf,
 ) -> impl Stream<Item = Result<AppState, TaskError>> {
-    try_channel(100000, move |mut output| async move {
+    try_channel(10000, move |mut output| async move {
+        output.send(AppState::Downloading(url.clone(), 0.0)).await?;
+
         info!("Starting download from {}", url);
         let download_path = get_java_zip_path_from_cache_dir(&cache_dir);
         info!("Temporary jre zip file: {}", download_path.display());
@@ -80,8 +79,6 @@ pub fn download_java_task(
             .content_length()
             .ok_or(TaskError::NoContentLength())?;
 
-        output.send(AppState::Downloading(url.clone(), 0.0)).await?;
-
         let mut buffer = vec![0u8; total as usize];
         let mut byte_stream = response.bytes_stream();
         let mut downloaded = 0;
@@ -92,14 +89,10 @@ pub fn download_java_task(
             downloaded += bytes.len();
             buffer[previously_downloaded..downloaded].copy_from_slice(&bytes);
             let progress = 100.0 * downloaded as f32 / total as f32;
-            if let Err(e) = output.try_send(AppState::Downloading(url.clone(), progress)) {
-                debug!("Channel full!")
-            }
+            output.send(AppState::Downloading(url.clone(), progress)).await?;
         }
 
-        if let Err(e) = output.try_send(AppState::Downloading(url.clone(), 100f32)) {
-            debug!("Channel full! {}", e)
-        }
+        output.send(AppState::Downloading(url.clone(), 100f32)).await?;
 
         info!("Finished downloading!");
 
@@ -112,9 +105,7 @@ pub fn download_java_task(
         file.write_all(&buffer[..downloaded])?;
 
         info!("Written to file!");
-        if let Err(e) = output.try_send(AppState::DownloadFinished(download_path.clone())) {
-            debug!("Channel full! {}", e)
-        }
+        output.send(AppState::DownloadFinished(download_path.clone())).await?;
         Ok(())
     })
 }
diff --git a/wrapper/src/file.rs b/wrapper/src/file.rs
@@ -19,7 +19,7 @@ use crate::{app, WrapperInfo, BRAND};
 use app::AppState;
 use iced::futures::channel::oneshot;
 use iced::Task;
-use log::{info, warn};
+use log::{debug, info, warn};
 use std::fs::File;
 use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -96,15 +96,18 @@ pub fn extract_zip(zip_path: PathBuf, target_path: PathBuf) -> ZipResult<()> {
 }
 
 pub fn extract_java_task(cache_dir: PathBuf, download_path: PathBuf) -> Task<AppMessage> {
+    debug!("Extracting java task requested.");
     Task::perform(
         async move {
+            info!("Extracting java...");
             let (tx, rx) = oneshot::channel();
             std::thread::spawn(move || {
                 let extract_path = get_java_extract_folder_from_cache_dir(&cache_dir);
                 info!("Temporary jre folder: {}", extract_path.display());
                 let res = extract_zip(download_path, extract_path)
                     .map(|_| AppState::ExtractFinished)
                     .unwrap_or_else(|e| AppState::Errored(format!("Error extracting java: {e}")));
+                info!("Finished extracting java! {}", res);
                 let _ = tx.send(res);
             });
             rx.await.unwrap_or_else(|_| AppState::Errored("Extraction thread dropped".into()))
diff --git a/wrapper/src/installer.rs b/wrapper/src/installer.rs
@@ -191,7 +191,6 @@ pub fn run_installer_task(
             let res = rx
                 .await
                 .unwrap_or_else(|_| AppState::Errored("Extraction thread dropped".into()));
-            info!("Result 2: {}", res);
             res
         },
         AppMessage::UpdateState,
diff --git a/wrapper/src/java.rs b/wrapper/src/java.rs
@@ -13,13 +13,15 @@
  * other in this repository, all of which is reserved by Essential.
  */
 
+use crate::app::{AppMessage, AppState};
 use crate::process::run_process;
+use iced::Task;
 use log::info;
 use serde::Deserialize;
 use std::fs;
 use std::path::{Path, PathBuf};
 
-pub fn get_java_download_url() -> Result<String, String> {
+pub async fn get_java_download_url() -> Result<String, String> {
     #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
     let api = "https://api.azul.com/metadata/v1/zulu/packages/?java_version=17&os=macos&arch=x64&archive_type=zip&java_package_type=jre&javafx_bundled=false&crac_supported=false&crs_supported=false&support_term=lts&distro_version=17&release_status=ga&availability_types=CA&certifications=tck&page=1&page_size=100";
     #[cfg(all(target_os = "macos", target_arch = "aarch64"))]
@@ -35,9 +37,9 @@ pub fn get_java_download_url() -> Result<String, String> {
 
     info!("Calling API to get java download! {}", api);
 
-    let packages: Vec<Package> = reqwest::blocking::get(api)
+    let packages: Vec<Package> = reqwest::get(api).await
         .map_err(|e| e.to_string())?
-        .json()
+        .json().await
         .map_err(|e| e.to_string())?;
 
     packages
@@ -46,6 +48,23 @@ pub fn get_java_download_url() -> Result<String, String> {
         .ok_or("No packages returned".to_string())
 }
 
+pub fn fetch_java_url_task() -> Task<AppMessage> {
+    Task::perform(
+        async move {
+            info!("Fetching java url");
+            let url = get_java_download_url().await;
+            info!("Fetched!");
+            if let Err(e) = url {
+                AppState::Errored(format!("Error when fetching Java download URL: {}", e))
+            } else {
+                info!("Successfully fetched Java url: {}", url.clone().unwrap());
+                AppState::StartDownloading(url.unwrap())
+            }
+        },
+        AppMessage::UpdateState,
+    )
+}
+
 pub fn get_java_zip_path_from_cache_dir(cache_dir: &Path) -> PathBuf {
     cache_dir.join("wrapper-jre.zip")
 }
@@ -105,7 +124,7 @@ pub fn find_java(cache_dir: &Path) -> Vec<String> {
                             str_path, file_name
                         ))
                     }
-                }     
+                }
             });
     }
 
diff --git a/wrapper/src/main.rs b/wrapper/src/main.rs
@@ -19,7 +19,7 @@
 use crate::app::{start_app, AppState, WrapperApp};
 use crate::file::{delete_temp_dir, get_cache_directory, get_invalid_path, get_temp_directory};
 use crate::installer::run_installer_with_permissive_error_handling;
-use crate::java::{find_java, get_java_download_url};
+use crate::java::find_java;
 use crate::logging::setup_logging;
 use log::info;
 use std::iter::Iterator;
@@ -85,18 +85,9 @@ pub fn main() {
 
     info!("Downloading java");
 
-    let url = get_java_download_url()
-        .inspect_err(|e| {
-            show_error!(
-                format!("Error when fetching Java download URL: {}", e),
-                wrapper_info.clone()
-            );
-        })
-        .unwrap();
-
     start_app(
         WrapperApp {
-            app_state: AppState::Downloading(url, 0.),
+            app_state: AppState::FetchingURL,
             wrapper_info: wrapper_info.clone(),
         },
         false,
diff --git a/wrapper/src/util.rs b/wrapper/src/util.rs
@@ -23,6 +23,8 @@ impl Display for AppState {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
             AppState::Nothing => write!(f, "Nothing"),
+            AppState::FetchingURL => write!(f, "FetchingURL"),
+            AppState::StartDownloading(url) => write!(f, "StartDownloading({})", url),
             AppState::Downloading(url, percent) => write!(f, "Downloading({}, {})", url, percent),
             AppState::DownloadFinished(_) => write!(f, "DownloadFinished"),
             AppState::ExtractingJava(_) => write!(f, "ExtractingJava"),
