bubba_core/runtime/

mod.rs

//! # Runtime
//!
//! The Bubba app runtime: lifecycle hooks, built-in actions (`alert`, `log`),
//! async task scheduling, and the Android JNI bridge.

use anyhow::Result;
use std::sync::Arc;
use tokio::runtime::Runtime as TokioRuntime;
use crate::navigation::{global_stack, navigate_to};
use crate::ui::Screen;

/// The Bubba runtime instance. One per application process.
pub struct Runtime {
    tokio: Arc<TokioRuntime>,
}

impl Runtime {
    /// Boot the Bubba runtime.
    pub fn new() -> Result<Self> {
        let tokio = tokio::runtime::Builder::new_multi_thread()
            .worker_threads(2)
            .enable_all()
            .build()?;
        Ok(Self {
            tokio: Arc::new(tokio),
        })
    }

    /// Launch the app with the given root screen.
    pub fn launch(&self, root_name: &'static str, root: fn() -> Screen) {
        log::info!("[Bubba] Runtime launching. Root screen: {}", root_name);
        navigate_to(root_name, root);

        // Platform dispatch
        #[cfg(target_os = "android")]
        self.run_android_loop();

        #[cfg(not(target_os = "android"))]
        self.run_host_loop();
    }

    /// Render the current top-of-stack screen into the native view hierarchy.
    pub fn render_current(&self) {
        if let Some(screen) = global_stack().current() {
            log::debug!("[Bubba] Rendering screen:\n{}", screen.root.debug_render(0));

            // On Android: walk the Element tree and call JNI View constructors.
            // On host (dev/test): print to stdout for visual inspection.
            #[cfg(not(target_os = "android"))]
            println!("{}", screen.root.debug_render(0));
        }
    }

    /// Spawn an async background task.
    ///
    /// ```rust,ignore
    /// spawn(async {
    ///     let data = fetch_user_data().await;
    ///     // update state…
    /// });
    /// ```
    pub fn spawn_task<F>(&self, fut: F)
    where
        F: std::future::Future<Output = ()> + Send + 'static,
    {
        self.tokio.spawn(fut);
    }

    // ── Host dev loop ─────────────────────────────────────────────────────────

    #[cfg(not(target_os = "android"))]
    fn run_host_loop(&self) {
        log::info!("[Bubba] Running in host mode (no Android runtime).");
        self.render_current();
    }

    // ── Android event loop (stub — JNI bridge fills this in) ─────────────────

    #[cfg(target_os = "android")]
    fn run_android_loop(&self) {
        log::info!("[Bubba] Android runtime active.");
        // The actual loop is driven by the JNI callbacks from
        // `BubbaBridge.java` → `bubba_on_event()` below.
    }
}

impl Default for Runtime {
    fn default() -> Self {
        Self::new().expect("Failed to boot Bubba runtime")
    }
}

// ── Built-in actions ─────────────────────────────────────────────────────────

/// Show a native alert dialog.
///
/// ```rust
/// bubba_core::runtime::alert("You tapped the button!");
/// ```
pub fn alert(message: impl Into<String>) {
    let msg = message.into();
    log::info!("[Bubba alert] {}", msg);

    #[cfg(target_os = "android")]
    android_alert(&msg);

    #[cfg(not(target_os = "android"))]
    println!("[ALERT] {}", msg);
}

/// Log a message (maps to `android.util.Log.d` on device).
///
/// ```rust
/// bubba_core::runtime::log_msg("Typing…");
/// ```
pub fn log_msg(message: impl Into<String>) {
    log::debug!("[Bubba log] {}", message.into());
}

/// Spawn a future on the Bubba async executor.
/// This is the free function form used inside event handlers.
pub fn spawn<F>(fut: F)
where
    F: std::future::Future<Output = ()> + Send + 'static,
{
    GLOBAL_RUNTIME.with(|rt| {
        if let Some(r) = rt.borrow().as_ref() {
            r.tokio.spawn(fut);
        }
    });
}

// ── Thread-local runtime handle ───────────────────────────────────────────────

use std::cell::RefCell;

thread_local! {
    static GLOBAL_RUNTIME: RefCell<Option<Arc<Runtime>>> = RefCell::new(None);
}

/// Set the thread-local runtime reference (called by `cargo bubba` bootstrap).
pub fn set_global_runtime(rt: Arc<Runtime>) {
    GLOBAL_RUNTIME.with(|r| {
        *r.borrow_mut() = Some(rt);
    });
}

// ── Android JNI bridge ────────────────────────────────────────────────────────

#[cfg(all(target_os = "android", feature = "android"))]
mod android {
    use jni::JNIEnv;
    use jni::objects::{JClass, JString};

    /// Called from Java: `BubbaBridge.nativeOnEvent(elementId, eventKind, value)`
    #[no_mangle]
    pub extern "system" fn Java_rs_bubba_BubbaBridge_nativeOnEvent(
        env: JNIEnv,
        _class: JClass,
        element_id: JString,
        event_kind: JString,
        value: JString,
    ) {
        let element_id: String = env.get_string(element_id).unwrap().into();
        let event_kind: String = env.get_string(event_kind).unwrap().into();
        let value: String = env.get_string(value).unwrap().into();

        log::debug!("[JNI] event: {} on #{}", event_kind, element_id);

        // Route to Bubba event dispatcher
        // GLOBAL_DISPATCHER.push(element_id, BubbaEvent { kind: &event_kind, value: Some(value), key: None });
    }

    /// Show a native Android AlertDialog from Rust.
    pub fn android_alert(message: &str) {
        // JNI call to `BubbaBridge.showAlert(message)` would go here.
        log::info!("[Android] Alert: {}", message);
    }
}

#[cfg(not(all(target_os = "android", feature = "android")))]
#[allow(dead_code)]
fn android_alert(_msg: &str) {}

// ── Build information ─────────────────────────────────────────────────────────

/// Bubba runtime version.
pub const BUBBA_VERSION: &str = env!("CARGO_PKG_VERSION");

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn runtime_boots() {
        let rt = Runtime::new().expect("runtime should boot");
        // Just verify it didn't panic.
        drop(rt);
    }

    #[test]
    fn alert_does_not_panic() {
        alert("test alert");
    }

    #[test]
    fn log_does_not_panic() {
        log_msg("test log");
    }
}