Second attempt...

RedEpicness · RedEpicness · commit 7ca53a28935f · 2025-09-18T01:27:31.000+02:00
diff --git a/wrapper/src/app.rs b/wrapper/src/app.rs
@@ -13,9 +13,7 @@
  * 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;
+use crate::download::{download_java_and_run_task};
 use crate::java::get_java_executable_in_downloaded_jre;
 use crate::logging::get_logging_file_from_temp_directory;
 use crate::{fonts, WrapperInfo, BRAND};
@@ -43,29 +41,30 @@ pub fn start_app(app: WrapperApp, decorations: bool) {
         WrapperApp::update,
         WrapperApp::view,
     )
-    .window(window::Settings {
-        size: Size {
-            width: 688.,
-            height: 344.,
-        },
-        position: window::Position::Centered,
-        resizable: false,
-        decorations,
-        icon: from_file_data(include_bytes!("../resources/icon.png"), None)
-            .inspect_err(|e| warn!("Error when loading icon: {}", e))
-            .ok(),
-        ..Default::default()
-    })
-    .subscription(WrapperApp::subscription)
-    .theme(move |_| AppTheme::default())
-    .run_with(|| WrapperApp::new(app))
-    .unwrap();
+        .window(window::Settings {
+            size: Size {
+                width: 688.,
+                height: 344.,
+            },
+            position: window::Position::Centered,
+            resizable: false,
+            decorations,
+            icon: from_file_data(include_bytes!("../resources/icon.png"), None)
+                .inspect_err(|e| warn!("Error when loading icon: {}", e))
+                .ok(),
+            ..Default::default()
+        })
+        .subscription(WrapperApp::subscription)
+        .theme(move |_| AppTheme::default())
+        .run_with(|| WrapperApp::new(app))
+        .unwrap();
 }
 
 #[derive(Debug, Default)]
 pub struct WrapperApp {
     pub app_state: AppState,
     pub wrapper_info: WrapperInfo,
+    pub url: String,
 }
 
 #[derive(Debug, Clone, Default)]
@@ -141,26 +140,26 @@ impl WrapperApp {
                 } else {
                     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,
-                    );
-                }
-                if let AppState::ExtractFinished = &mut self.app_state {
-                    self.app_state = if let Some(exec) =
-                        get_java_executable_in_downloaded_jre(&self.wrapper_info.cache_dir)
-                    {
-                        AppState::InstallerRunning(exec)
-                    } else {
-                        AppState::Errored("Couldn't find java after extracting".into())
-                    }
-                }
+                /* 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,
+                     );
+                 }
+                 if let AppState::ExtractFinished = &mut self.app_state {
+                     self.app_state = if let Some(exec) =
+                         get_java_executable_in_downloaded_jre(&self.wrapper_info.cache_dir)
+                     {
+                         AppState::InstallerRunning(exec)
+                     } else {
+                         AppState::Errored("Couldn't find java after extracting".into())
+                     }
+                 }*/
                 debug!("Resulting state: {}", self.app_state);
                 if let AppState::Finished = &mut self.app_state {
                     return iced::exit();
@@ -283,7 +282,7 @@ impl WrapperApp {
             .into()
     }
 
-    fn subscription(&self) -> Subscription<AppMessage> {
+    /*fn subscription(&self) -> Subscription<AppMessage> {
         debug!("Getting subscription {}", self.app_state);
         match &self.app_state {
             AppState::Downloading(url, _) => {
@@ -297,6 +296,24 @@ impl WrapperApp {
             }
             _ => Subscription::none(),
         }
+    }*/
+
+    fn subscription(&self) -> Subscription<AppMessage> {
+        debug!("Getting subscription {}", self.app_state);
+        match &self.app_state {
+            AppState::Errored(e) => Subscription::none(),
+            _ => Subscription::run_with_id(
+                "download-and-run",
+                download_java_and_run_task(self.url.clone(), self.wrapper_info.clone()),
+            ).map(|t| {
+                if let Err(e) = t {
+                    error!("Error when downloading java: {}", e);
+                    AppMessage::UpdateState(AppState::Errored(format!("Error downloading java: {}", e)))
+                } else {
+                    AppMessage::UpdateState(t.unwrap())
+                }
+            }),
+        }
     }
 }
 
diff --git a/wrapper/src/download.rs b/wrapper/src/download.rs
@@ -14,7 +14,7 @@
  */
 
 use crate::app::{AppMessage, AppState};
-use crate::java::get_java_zip_path_from_cache_dir;
+use crate::java::{get_java_executable_in_downloaded_jre, get_java_extract_folder_from_cache_dir, get_java_zip_path_from_cache_dir};
 use crate::util::TaskError;
 use iced::futures::{SinkExt, Stream, StreamExt};
 use iced::stream::try_channel;
@@ -24,8 +24,11 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 use std::{fs, fs::File, io::Write};
+use crate::file::extract_zip;
+use crate::installer::{try_run_installer, InstallerExitCode, InstallerRunError};
+use crate::WrapperInfo;
 
-pub fn download_java<T: ToString>(url: T, cache_dir: PathBuf) -> Subscription<AppMessage> {
+/*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),
@@ -38,9 +41,9 @@ pub fn download_java<T: ToString>(url: T, cache_dir: PathBuf) -> Subscription<Ap
             AppMessage::UpdateState(t.unwrap())
         }
     })
-}
+}*/
 
-pub fn download_java_task(
+/*pub fn download_java_task(
     url: String,
     cache_dir: PathBuf,
 ) -> impl Stream<Item = Result<AppState, TaskError>> {
@@ -105,4 +108,114 @@ pub fn download_java_task(
         info!("Successfully downloaded java!");
         Ok(())
     })
+}*/
+
+pub fn download_java_and_run_task(
+    url: String,
+    wrapper_info: WrapperInfo,
+) -> impl Stream<Item = Result<AppState, TaskError>> {
+    try_channel(100000, move |mut output| async move {
+        info!("Starting download from {}", url);
+        let download_path = get_java_zip_path_from_cache_dir(&wrapper_info.cache_dir);
+        info!("Temporary jre zip file: {}", download_path.display());
+
+        info!("Check if the old file exists");
+        if download_path.try_exists().unwrap_or(false) {
+            info!("Deleting the old file");
+            fs::remove_file(download_path.clone()).map_err(|e| {
+                TaskError::IOError(
+                    "Error when deleting old JRE zip file".to_string(),
+                    Arc::new(e),
+                )
+            })?;
+        }
+
+        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
+            .build()?;
+
+        let response = client.get(url.clone()).send().await?;
+
+        if !response.status().is_success() {
+            warn!("Non-OK status received as response when downloading!");
+            warn!(
+                "Response text: \n{}",
+                response.text().await.unwrap_or_else(|e| { e.to_string() })
+            );
+            return Err(TaskError::UnsuccessfulResponse());
+        }
+
+        let total = response
+            .content_length()
+            .ok_or(TaskError::NoContentLength())?;
+
+        output.send(AppState::Downloading(url.clone(), 0.0)).await?;
+
+        let mut byte_stream = response.bytes_stream();
+        let mut downloaded = 0;
+
+        while let Some(next_bytes) = byte_stream.next().await {
+            let bytes = next_bytes?;
+            downloaded += bytes.len();
+            file.write_all(&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.clone())).await?;
+        info!("Successfully downloaded java! Now extracting...");
+        output.send(AppState::ExtractingJava(download_path.clone())).await?;
+
+        let extract_path = get_java_extract_folder_from_cache_dir(&wrapper_info.cache_dir);
+        info!("Temporary jre folder: {}", extract_path.display());
+
+        extract_zip(download_path, extract_path)?;
+        output.send(AppState::ExtractFinished).await?;
+
+        info!("Extracted! Ruunning installer...");
+
+        let java_executable = get_java_executable_in_downloaded_jre(&wrapper_info.cache_dir)
+            .ok_or(TaskError::UnsuccessfulResponse())?; // TODO error
+
+        output.send(AppState::InstallerRunning(java_executable.clone())).await?;
+        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)
+            }
+        };
+
+        output.send(state).await?;
+        Ok(())
+    })
 }
diff --git a/wrapper/src/file.rs b/wrapper/src/file.rs
@@ -128,7 +128,7 @@ pub fn extract_java_task(
     })
 }*/
 
-pub fn extract_java_task(cache_dir: PathBuf, download_path: PathBuf) -> Task<AppMessage> {
+/*pub fn extract_java_task(cache_dir: PathBuf, download_path: PathBuf) -> Task<AppMessage> {
     Task::perform(
         async move {
             let (tx, rx) = oneshot::channel();
@@ -149,4 +149,4 @@ pub fn extract_java_task(cache_dir: PathBuf, download_path: PathBuf) -> Task<App
         },
         AppMessage::UpdateState,
     )
-}
+}*/
diff --git a/wrapper/src/installer.rs b/wrapper/src/installer.rs
@@ -153,19 +153,19 @@ pub fn get_installer_path(_wrapper_info: &WrapperInfo) -> Option<String> {
     path.into_os_string().into_string().ok()
 }
 
-pub fn run_installer(
+/*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(
+/*pub fn run_installer_task(
     java_executable: String,
     wrapper_info: WrapperInfo,
 ) -> impl Stream<Item = AppState> {
@@ -199,4 +199,4 @@ pub fn run_installer_task(
         };
         let _ = output.send(state).await;
     })
-}
+}*/
diff --git a/wrapper/src/macros.rs b/wrapper/src/macros.rs
@@ -27,6 +27,7 @@ macro_rules! show_error {
             $crate::app::WrapperApp {
                 app_state: $crate::app::AppState::Errored($error.to_string()),
                 wrapper_info: $wrapper_info,
+                url: String::new(),
             },
             true,
         );
diff --git a/wrapper/src/main.rs b/wrapper/src/main.rs
@@ -96,8 +96,9 @@ pub fn main() {
 
     start_app(
         WrapperApp {
-            app_state: AppState::Downloading(url, 0.),
+            app_state: AppState::Downloading(url.clone(), 0.),
             wrapper_info: wrapper_info.clone(),
+            url: url.to_string(),
         },
         false,
     );
