cli json output, dx bundle fix, dx serve --platform android, race condition, drop ssg platform (#3186)

* clean up logging to avoid random extra trace

* fix race condition with updates

* properly wire up verbose

* fix bundling (macos) and logging

* Add structured output

* clean up clap names

* extract out wire format

* switch structured key to json

* fix random println, fallback to `dioxus/platform`

* clean up logging for run/build

* clean up logging around project

* remove manual exits

* fix tokio runtime for mobile

* rework dog app

* rip out ssg

* Switch dioxus/axum to dioxus/server

* add android template inline

* pre restructure for bundle prep

* add the whole res directory

* Better theme for the app

* remove mobile demo now that most apps work natively

* self-referential android

* only use deep linking for assets

* fix imports for android

* clippy, fixup ios and android

* I'm not boxing compiler message you can't make me

* fix clippy on unix

packages/desktop/src/launch.rs

@@ -75,7 +75,7 @@ pub fn launch_virtual_dom_blocking(virtual_dom: VirtualDom, desktop_config: Conf
                         webview.dom.in_runtime(|| {
                             ScopeId::ROOT.in_runtime(|| {
                                 let e = eval(
-                                    r#" 
+                                    r#"
                                     const xPos = await dioxus.recv();
                                     const yPos = await dioxus.recv();
                                     window.interpreter.handleWindowsDragOver(xPos, yPos)
@@ -121,7 +121,9 @@ pub fn launch_virtual_dom(virtual_dom: VirtualDom, desktop_config: Config) -> !
     }
 
     #[cfg(not(feature = "tokio_runtime"))]
-    launch_virtual_dom_blocking(virtual_dom, desktop_config);
+    {
+        launch_virtual_dom_blocking(virtual_dom, desktop_config);
+    }
 }
 
 /// Launches the WebView and runs the event loop, with configuration and root props.

packages/desktop/src/protocol.rs

@@ -84,6 +84,17 @@ fn serve_asset(request: Request<Vec<u8>>) -> Result<Response<Vec<u8>>> {
             .as_ref(),
     );
 
+    // Attempt to serve from the asset dir on android using its loader
+    #[cfg(target_os = "android")]
+    {
+        if let Some(asset) = to_java_load_asset(request.uri().path()) {
+            return Ok(Response::builder()
+                .header("Content-Type", get_mime_by_ext(&uri_path))
+                .header("Access-Control-Allow-Origin", "*")
+                .body(asset)?);
+        }
+    }
+
     // If the asset doesn't exist, or starts with `/assets/`, then we'll try to serve out of the bundle
     // This lets us handle both absolute and relative paths without being too "special"
     // It just means that our macos bundle is a little "special" because we need to place an `assets`
@@ -261,3 +272,42 @@ fn get_mime_by_ext(trimmed: &Path) -> &'static str {
         None => "application/octet-stream",
     }
 }
+
+#[cfg(target_os = "android")]
+pub(crate) fn to_java_load_asset(filepath: &str) -> Option<Vec<u8>> {
+    use std::{io::Read, ptr::NonNull};
+
+    let ctx = ndk_context::android_context();
+    let vm = unsafe { jni::JavaVM::from_raw(ctx.vm().cast()) }.unwrap();
+    let mut env = vm.attach_current_thread().unwrap();
+
+    // Query the Asset Manager
+    let asset_manager_ptr = env
+        .call_method(
+            unsafe { jni::objects::JObject::from_raw(ctx.context().cast()) },
+            "getAssets",
+            "()Landroid/content/res/AssetManager;",
+            &[],
+        )
+        .expect("Failed to get asset manager")
+        .l()
+        .expect("Failed to get asset manager as object");
+
+    unsafe {
+        let asset_manager =
+            ndk_sys::AAssetManager_fromJava(env.get_native_interface(), *asset_manager_ptr);
+
+        let asset_manager = ndk::asset::AssetManager::from_ptr(
+            NonNull::new(asset_manager).expect("Invalid asset manager"),
+        );
+
+        let normalized = filepath
+            .trim_start_matches("/assets/")
+            .trim_start_matches('/');
+
+        let cstr = std::ffi::CString::new(normalized).unwrap();
+
+        let mut asset = asset_manager.open(&cstr)?;
+        Some(asset.buffer().unwrap().to_vec())
+    }
+}