final 0.7 fixes: xcode 15/16 hybrid, auto openssldir for android, include_*! tracking hotpatch, fix /assets/ brick at high opt levels, windows linker file, etc (#4376)

* wip: openssl autodetection * add voltaile read inside of asset fn * support xcode 15 for --device * vendor openssl on android * Smaller width TUI * switch to anyhow for the entire CLI * add backtrace and print double printing of cargo_metadata errors * add some padding to multi-line anyhow error * check semvers * don't open if not interactive * set the tailwind current_dir so it doesn't twitch * get the oboe demo working * copy the c++ library on android * cleanup env vars * add depinfo watcher * fix stale hotpatches and crate count * add musl support * remove outdated autofmt test * update scanner app * add hotdog app and bundle to ci * upload dx on every branch * collapse mobile into desktop * `dx doctor` command * windows command files * no pipe on doctor * fix ci? * fix links * fix ci * use main instead of nightly * bump node * build cli for host * cargo doc * prep dog_app for bundle * package hotdog * no bundle or nightly cli * comment out nightly cli * add quotes to linker files
2025-07-14 12:54:15 -07:00
1 parent 97947b169b
commit 727752a965
@@ -18,6 +18,7 @@ mod file_upload;
 mod hooks;
 mod ipc;
 mod menubar;
+mod mobile;
 mod protocol;
 mod query;
 mod shortcut;
@@ -0,0 +1,65 @@
+/// Expose the `Java_dev_dioxus_main_WryActivity_create` function to the JNI layer.
+/// We hardcode these to have a single trampoline for host Java code to call into.
+///
+/// This saves us from having to plumb the top-level package name all the way down into
+/// this file. This is better for modularity (ie just call dioxus' main to run the app) as
+/// well as cache thrashing since this crate doesn't rely on external env vars.
+///
+/// The CLI is expecting to find `dev.dioxus.main` in the final library. If you find a need to
+/// change this, you'll need to change the CLI as well.
+#[cfg(target_os = "android")]
+#[no_mangle]
+#[inline(never)]
+pub extern "C" fn start_app() {
+    use crate::Config;
+    use dioxus_core::{Element, VirtualDom};
+    use std::any::Any;
+
+    tao::android_binding!(dev_dioxus, main, WryActivity, wry::android_setup, root, tao);
+    wry::android_binding!(dev_dioxus, main, wry);
+
+    #[cfg(target_os = "android")]
+    fn root() {
+        fn stop_unwind<F: FnOnce() -> T, T>(f: F) -> T {
+            match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {
+                Ok(t) => t,
+                Err(err) => {
+                    eprintln!("attempt to unwind out of `rust` with err: {:?}", err);
+                    std::process::abort()
+                }
+            }
+        }
+
+        stop_unwind(|| unsafe {
+            let mut main_fn_ptr = libc::dlsym(libc::RTLD_DEFAULT, b"main\0".as_ptr() as _);
+
+            if main_fn_ptr.is_null() {
+                main_fn_ptr = libc::dlsym(libc::RTLD_DEFAULT, b"_main\0".as_ptr() as _);
+            }
+
+            if main_fn_ptr.is_null() {
+                panic!("Failed to find main symbol");
+            }
+
+            // Set the env vars that rust code might expect, passed off to us by the android app
+            // Doing this before main emulates the behavior of a regular executable
+            if cfg!(target_os = "android") && cfg!(debug_assertions) {
+                // Load the env file from the session cache if we're in debug mode and on android
+                //
+                // This is a slightly hacky way of being able to use std::env::var code in android apps without
+                // going through their custom java-based system.
+                let env_file = dioxus_cli_config::android_session_cache_dir().join(".env");
+                if let Ok(env_file) = std::fs::read_to_string(&env_file) {
+                    for line in env_file.lines() {
+                        if let Some((key, value)) = line.trim().split_once('=') {
+                            std::env::set_var(key, value);
+                        }
+                    }
+                }
+            }
+
+            let main_fn: extern "C" fn() = std::mem::transmute(main_fn_ptr);
+            main_fn();
+        });
+    }
+}