Works when no progress bar...

RedEpicness · RedEpicness · commit 72cecb46c745 · 2025-10-08T21:27:46.000+02:00
diff --git a/wrapper/src/app.rs b/wrapper/src/app.rs
@@ -15,7 +15,7 @@
 
 use crate::download::download_java;
 use crate::file::extract_java_task;
-use crate::installer::run_installer;
+use crate::installer::{run_installer_task};
 use crate::java::get_java_executable_in_downloaded_jre;
 use crate::logging::get_logging_file_from_temp_directory;
 use crate::{fonts, WrapperInfo, BRAND};
@@ -142,15 +142,7 @@ impl WrapperApp {
                     self.app_state = new_state
                 }
                 if let AppState::DownloadFinished(download_path) = &mut self.app_state {
-                    let task = extract_java_task(
-                        self.wrapper_info.cache_dir.clone(),
-                        download_path.clone(),
-                    );
-                    // self.app_state = AppState::ExtractingJava(download_path.clone());
-                    return Task::perform(
-                        async { AppState::ExtractFinished },
-                        AppMessage::UpdateState,
-                    );
+                    self.app_state = AppState::ExtractingJava(download_path.clone());
                 }
                 if let AppState::ExtractFinished = &mut self.app_state {
                     self.app_state = if let Some(exec) =
@@ -166,9 +158,20 @@ impl WrapperApp {
                     return iced::exit();
                 }
                 // Compiler complained?
+
+                let info = self.wrapper_info.clone();
+                let cache_dir = info.cache_dir.clone();
                 let state = self.app_state.clone();
-                window::get_oldest().and_then(move |id| match state {
+                window::get_oldest().and_then(move |id| match &state {
                     AppState::Downloading(_, _) => window::change_mode(id, Mode::Windowed),
+                    AppState::ExtractingJava(download_path) => Task::batch(vec![
+                        window::change_mode(id, Mode::Windowed),
+                        extract_java_task(cache_dir.clone(), download_path.clone()),
+                    ]),
+                    AppState::InstallerRunning(exec) => Task::batch(vec![
+                        window::change_mode(id, Mode::Hidden),
+                        run_installer_task(exec.clone(), info.clone()),
+                    ]),
                     AppState::Errored(_) => Task::batch(vec![
                         window::change_mode(id, Mode::Windowed),
                         window::toggle_decorations(id),
@@ -289,12 +292,6 @@ impl WrapperApp {
             AppState::Downloading(url, _) => {
                 download_java(url.clone(), self.wrapper_info.cache_dir.clone())
             }
-            /*AppState::ExtractingJava(download_path) => {
-                extract_java(self.wrapper_info.cache_dir.clone(), download_path.clone())
-            }*/
-            AppState::InstallerRunning(java_executable) => {
-                run_installer(java_executable.clone(), self.wrapper_info.clone())
-            }
             _ => Subscription::none(),
         }
     }
diff --git a/wrapper/src/download.rs b/wrapper/src/download.rs
@@ -60,12 +60,6 @@ pub fn download_java_task(
             })?;
         }
 
-        let mut file = File::create(download_path.clone()).map_err(|e| {
-            TaskError::IOError("Error creating the download file!".to_string(), Arc::new(e))
-        })?;
-
-        info!("File created!");
-
         let client = reqwest::Client::builder()
             .connect_timeout(Duration::from_secs(10))
             .timeout(Duration::from_secs(120)) // 3 mbit download for 45MB file
@@ -88,21 +82,39 @@ pub fn download_java_task(
 
         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;
 
         while let Some(next_bytes) = byte_stream.next().await {
             let bytes = next_bytes?;
+            let previously_downloaded = downloaded;
             downloaded += bytes.len();
-            file.write_all(&bytes)?;
+            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::DownloadFinished(download_path)).await?;
-        info!("Successfully downloaded java!");
+        if let Err(e) = output.try_send(AppState::Downloading(url.clone(), 100f32)) {
+            debug!("Channel full! {}", e)
+        }
+
+        info!("Finished downloading!");
+
+        let mut file = File::create(download_path.clone()).map_err(|e| {
+            TaskError::IOError("Error creating the download file!".to_string(), Arc::new(e))
+        })?;
+
+        info!("File created!");
+
+        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)
+        }
         Ok(())
     })
 }
diff --git a/wrapper/src/file.rs b/wrapper/src/file.rs
@@ -95,39 +95,6 @@ pub fn extract_zip(zip_path: PathBuf, target_path: PathBuf) -> ZipResult<()> {
     ZipArchive::new(file)?.extract_unwrapped_root_dir(target_path, root_dir_common_filter)
 }
 
-/*pub fn extract_java(cache_dir: PathBuf, download_path: PathBuf) -> Subscription<AppMessage> {
-    Subscription::run_with_id("extract-java", extract_java_task(cache_dir, download_path))
-        .map(|t| {
-            if let Err(e) = t {
-                error!("Error when extracting java: {}", e);
-                AppMessage::UpdateState(AppState::Errored(format!("Error extracting java: {}", e)))
-            } else {
-                AppMessage::UpdateState(t.unwrap())
-            }
-        })
-}
-
-pub fn extract_java_task(
-    cache_dir: PathBuf,
-    download_path: PathBuf,
-) -> impl Stream<Item = Result<AppState, TaskError>> {
-    try_channel(10, move |mut output| async move {
-        let extract_path = get_java_extract_folder_from_cache_dir(&cache_dir);
-        info!("Temporary jre folder: {}", extract_path.display());
-        let state = extract_zip(download_path.clone(), extract_path.clone())
-            .map(|_| {
-                info!("Successfully extracted java!");
-                AppState::ExtractFinished
-            })
-            .unwrap_or_else(|e| {
-                error!("Error when extracting java: {}", e);
-                AppState::Errored(format!("Error extracting java: {}", e))
-            });
-        output.try_send(state).map_err(|_| TaskError::ChannelFailure())?;
-        Ok(())
-    })
-}*/
-
 pub fn extract_java_task(cache_dir: PathBuf, download_path: PathBuf) -> Task<AppMessage> {
     Task::perform(
         async move {
@@ -138,14 +105,9 @@ pub fn extract_java_task(cache_dir: PathBuf, download_path: PathBuf) -> Task<App
                 let res = extract_zip(download_path, extract_path)
                     .map(|_| AppState::ExtractFinished)
                     .unwrap_or_else(|e| AppState::Errored(format!("Error extracting java: {e}")));
-                info!("Result: {}", res);
                 let _ = tx.send(res);
             });
-            let res = rx
-                .await
-                .unwrap_or_else(|_| AppState::Errored("Extraction thread dropped".into()));
-            info!("Result 2: {}", res);
-            res
+            rx.await.unwrap_or_else(|_| AppState::Errored("Extraction thread dropped".into()))
         },
         AppMessage::UpdateState,
     )
diff --git a/wrapper/src/installer.rs b/wrapper/src/installer.rs
@@ -17,12 +17,10 @@ use crate::java::test_java;
 use crate::process::run_process;
 use crate::{app, show_error, WrapperInfo, VERSION};
 use app::{AppMessage, AppState};
-use iced::futures::Stream;
-use iced::futures::{SinkExt, StreamExt};
-use iced::stream::channel;
-use iced::Subscription;
+use iced::{Task};
 use log::{error, info, warn};
 use std::process::exit;
+use iced::futures::channel::oneshot;
 
 pub enum InstallerExitCode {
     Success,
@@ -153,50 +151,49 @@ pub fn get_installer_path(_wrapper_info: &WrapperInfo) -> Option<String> {
     path.into_os_string().into_string().ok()
 }
 
-pub fn run_installer(
-    java_executable: String,
-    wrapper_info: WrapperInfo,
-) -> Subscription<AppMessage> {
-    Subscription::run_with_id(
-        "run-installer",
-        run_installer_task(java_executable, wrapper_info).map(AppMessage::UpdateState),
-    )
-}
-
-// This is 100% not how I should use a stream, but it works for now.
-// If you see this it means I forgot to come back and look at this again
 pub fn run_installer_task(
     java_executable: String,
     wrapper_info: WrapperInfo,
-) -> impl Stream<Item = AppState> {
-    channel(1, move |mut output| async move {
-        let state = match try_run_installer(&java_executable, &wrapper_info) {
-            Ok(ex) => match ex {
-                InstallerExitCode::Success => AppState::Finished,
-                InstallerExitCode::UnknownError => {
-                    error!("Unknown error when running installer!");
-                    AppState::Errored("Unknown error!".to_string())
-                }
-                InstallerExitCode::NoOpenGl => {
-                    error!("No OpenGL found when running installer!");
-                    AppState::Errored("No OpenGL found!".to_string())
-                }
-                InstallerExitCode::UnsupportedPath => {
-                    error!("Launcher found an unsupported path!");
-                    AppState::Errored("Launcher found an unsupported path!".to_string())
-                }
-            },
-            Err(e) => {
-                let error = match e {
-                    InstallerRunError::JavaFailed => "Java test failed!".to_string(),
-                    InstallerRunError::UnknownExitCode(c) => {
-                        format!("Unknown installer exit code: {}", c)
+) -> Task<AppMessage> {
+    Task::perform(
+        async move {
+            let (tx, rx) = oneshot::channel();
+            std::thread::spawn(move || {
+                let state = match try_run_installer(&java_executable, &wrapper_info) {
+                    Ok(ex) => match ex {
+                        InstallerExitCode::Success => AppState::Finished,
+                        InstallerExitCode::UnknownError => {
+                            error!("Unknown error when running installer!");
+                            AppState::Errored("Unknown error!".to_string())
+                        }
+                        InstallerExitCode::NoOpenGl => {
+                            error!("No OpenGL found when running installer!");
+                            AppState::Errored("No OpenGL found!".to_string())
+                        }
+                        InstallerExitCode::UnsupportedPath => {
+                            error!("Launcher found an unsupported path!");
+                            AppState::Errored("Launcher found an unsupported path!".to_string())
+                        }
+                    },
+                    Err(e) => {
+                        let error = match e {
+                            InstallerRunError::JavaFailed => "Java test failed!".to_string(),
+                            InstallerRunError::UnknownExitCode(c) => {
+                                format!("Unknown installer exit code: {}", c)
+                            }
+                            InstallerRunError::Other => "Unknown error!".to_string(),
+                        };
+                        AppState::Errored(error)
                     }
-                    InstallerRunError::Other => "Unknown error!".to_string(),
                 };
-                AppState::Errored(error)
-            }
-        };
-        let _ = output.send(state).await;
-    })
+                let _ = tx.send(state);
+            });
+            let res = rx
+                .await
+                .unwrap_or_else(|_| AppState::Errored("Extraction thread dropped".into()));
+            info!("Result 2: {}", res);
+            res
+        },
+        AppMessage::UpdateState,
+    )
 }
