implement installer as library and use it in gui

installer/src/output.rs

@@ -0,0 +1,112 @@
+//! Output handling for the installer
+//!
+//! This module provides custom print macros that can be intercepted by setting
+//! a callback function. This is essential for FFI usage where stdout/stderr
+//! redirection doesn't work reliably (especially on Android).
+
+use std::io::Write;
+use std::sync::Mutex;
+
+/// Type for the output callback function
+type OutputCallbackFn = Box<dyn Fn(&str) + Send + Sync>;
+
+/// Global output callback storage
+static OUTPUT_CALLBACK: Mutex<Option<OutputCallbackFn>> = Mutex::new(None);
+
+/// Set the global output callback
+///
+/// All output from `println!` and `eprintln!` will be sent to this callback.
+/// If no callback is set, output goes to stdout/stderr as normal.
+///
+/// Returns a guard that when dropped, resets the callback.
+pub(crate) fn set_output_callback<F>(callback: F) -> OutputCallbackGuard
+where
+    F: Fn(&str) + Send + Sync + 'static,
+{
+    *OUTPUT_CALLBACK.lock().unwrap() = Some(Box::new(callback));
+    OutputCallbackGuard
+}
+
+pub struct OutputCallbackGuard;
+
+impl Drop for OutputCallbackGuard {
+    fn drop(&mut self) {
+        clear_output_callback();
+    }
+}
+
+/// Clear the global output callback
+pub(crate) fn clear_output_callback() {
+    *OUTPUT_CALLBACK.lock().unwrap() = None;
+}
+
+/// Write a line to the output (either callback or stdout)
+pub(crate) fn write_output_line(s: &str) {
+    if let Ok(guard) = OUTPUT_CALLBACK.lock()
+        && let Some(ref callback) = *guard
+    {
+        callback(s);
+        callback("\n");
+        return;
+    }
+    // Fallback to stdout if no callback or lock failed
+    std::println!("{}", s);
+    let _ = std::io::stdout().flush();
+}
+
+/// Write an error line to the output (either callback or stderr)
+pub(crate) fn write_error_line(s: &str) {
+    if let Ok(guard) = OUTPUT_CALLBACK.lock()
+        && let Some(ref callback) = *guard
+    {
+        callback(s);
+        callback("\n");
+        return;
+    }
+    // Fallback to stderr if no callback or lock failed
+    std::eprintln!("{}", s);
+    let _ = std::io::stderr().flush();
+}
+
+/// Write raw output without newline (either callback or stdout)
+pub(crate) fn write_output_raw(s: &str) {
+    if let Ok(guard) = OUTPUT_CALLBACK.lock()
+        && let Some(ref callback) = *guard
+    {
+        callback(s);
+        return;
+    }
+    // Fallback to stdout if no callback or lock failed
+    std::print!("{}", s);
+    let _ = std::io::stdout().flush();
+}
+
+/// Shadow println! macro to respect the output callback
+macro_rules! println {
+    () => {
+        $crate::output::write_output_line("")
+    };
+    ($($arg:tt)*) => {{
+        $crate::output::write_output_line(&format!($($arg)*))
+    }};
+}
+pub(crate) use println;
+
+/// Shadow eprintln! macro to respect the output callback
+macro_rules! eprintln {
+    () => {
+        $crate::output::write_error_line("")
+    };
+    ($($arg:tt)*) => {{
+        $crate::output::write_error_line(&format!($($arg)*))
+    }};
+}
+pub(crate) use eprintln;
+
+/// Shadow print! macro to respect the output callback
+macro_rules! print {
+    ($($arg:tt)*) => {{
+        $crate::output::write_output_raw(&format!($($arg)*))
+    }};
+}
+pub(crate) use print;