publish: bump mobile

Cargo.toml

@@ -20,8 +20,8 @@ dioxus-web = { path = "./packages/web", version = "^0.0.2", optional = true }
 dioxus-desktop = { path = "./packages/desktop", version = "^0.1.1", optional = true }
 dioxus-ssr = { path = "./packages/ssr", version = "0.1.1", optional = true }
 
-dioxus-router = { path = "./packages/router", optional = true }
-dioxus-mobile = { path = "./packages/mobile", optional = true }
+# dioxus-router = { path = "./packages/router", optional = true }
+dioxus-mobile = { path = "./packages/mobile", version = "0.0.1", optional = true }
 # dioxus-liveview = { path = "./packages/liveview", optional = true }
 
 [features]
@@ -33,7 +33,7 @@ html = ["dioxus-html"]
 ssr = ["dioxus-ssr"]
 web = ["dioxus-web"]
 desktop = ["dioxus-desktop"]
-router = ["dioxus-router"]
+# router = ["dioxus-router"]
 
 # "dioxus-router/web"
 # "dioxus-router/desktop"

packages/mobile/Cargo.toml

@@ -1,25 +1,14 @@
 [package]
 name = "dioxus-mobile"
-version = "0.0.0"
+version = "0.0.1"
 authors = ["Jonathan Kelley"]
 edition = "2018"
 repository = "https://github.com/DioxusLabs/dioxus/"
 homepage = "https://dioxuslabs.com"
 documentation = "https://dioxuslabs.com"
 keywords = ["dom", "ui", "gui", "react", "wasm"]
+license = "MIT/Apache-2.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1.0"
-# cacao = { git = "https://github.com/ryanmcgrath/cacao" }
-dioxus-core = { path = "../core", version = "^0.1.3" }
-log = "0.4.14"
-serde = "1.0.126"
-serde_json = "1.0.64"
-wry = "0.12.2"
-
-
-[target.'cfg(target_os = "android")'.dependencies]
-android_logger = "0.9.0"
-log = "0.4.11"
-ndk-glue = "0.2.1"
+dioxus-desktop = { path = "../desktop", version = "0.1.1" }

packages/mobile/src/dom.rs

@@ -1,32 +0,0 @@
-//! webview dom
-
-use dioxus_core::{DomEdit, ElementId, ScopeId};
-use DomEdit::*;
-
-pub struct WebviewRegistry {}
-
-impl WebviewRegistry {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-pub struct WebviewDom<'bump> {
-    pub edits: Vec<DomEdit<'bump>>,
-    pub node_counter: u64,
-    pub registry: WebviewRegistry,
-}
-impl WebviewDom<'_> {
-    pub fn new(registry: WebviewRegistry) -> Self {
-        Self {
-            edits: Vec::new(),
-            node_counter: 0,
-            registry,
-        }
-    }
-
-    // Finish using the dom (for its edit list) and give back the node and event registry
-    pub fn consume(self) -> WebviewRegistry {
-        self.registry
-    }
-}

packages/mobile/src/lib.rs

@@ -1,226 +1,7 @@
-use dioxus_core::*;
-use std::{
-    collections::HashMap,
-    sync::{Arc, RwLock},
-};
-use wry::application::event::{Event, WindowEvent};
-use wry::application::event_loop::{ControlFlow, EventLoop};
-use wry::application::window::Fullscreen;
-use wry::application::{
-    dpi::LogicalSize,
-    event::StartCause,
-    // platform::ios::{ScreenEdge, WindowBuilderExtIOS, WindowExtIOS},
-    // platform::ios::{ScreenEdge, WindowBuilderExtIOS, WindowExtIOS},
-};
-use wry::webview::WebViewBuilder;
-use wry::{
-    application::window::{Window, WindowBuilder},
-    webview::{RpcRequest, RpcResponse},
-};
-mod dom;
-use dom::*;
+//! Dioxus Mobile
+//!
+//! This crate is work-in-progress and is currently just a wrapper over `dioxus-desktop.
+//!
+//! Eventually we'll have platform-specific hooks and a more robust API.
 
-static HTML_CONTENT: &'static str = include_str!("../../desktop/src/index.html");
-
-pub fn launch(root: Component, builder: fn(WindowBuilder) -> WindowBuilder) -> anyhow::Result<()> {
-    launch_with_props(root, (), builder)
-}
-pub fn launch_with_props<P: 'static + Send>(
-    root: Component<P>,
-    props: P,
-    builder: fn(WindowBuilder) -> WindowBuilder,
-) -> anyhow::Result<()> {
-    WebviewRenderer::run(root, props, builder)
-}
-
-/// The `WebviewRenderer` provides a way of rendering a Dioxus Virtual DOM through a bridge to a Webview instance.
-/// Components used in WebviewRenderer instances can directly use system libraries, access the filesystem, and multithread with ease.
-pub struct WebviewRenderer<T> {
-    /// The root component used to render the Webview
-    root: Component<T>,
-}
-enum RpcEvent<'a> {
-    Initialize {
-        //
-        edits: Vec<DomEdit<'a>>,
-    },
-}
-
-impl<T: 'static + Send> WebviewRenderer<T> {
-    pub fn run(
-        root: Component<T>,
-        props: T,
-        user_builder: fn(WindowBuilder) -> WindowBuilder,
-    ) -> anyhow::Result<()> {
-        Self::run_with_edits(root, props, user_builder, None)
-    }
-
-    pub fn run_with_edits(
-        root: Component<T>,
-        props: T,
-        user_builder: fn(WindowBuilder) -> WindowBuilder,
-        redits: Option<Vec<DomEdit<'static>>>,
-    ) -> anyhow::Result<()> {
-        // pub fn run_with_edits(
-        //     root: Component<T>,
-        //     props: T,
-        //     user_builder: fn(WindowBuilder) -> WindowBuilder,
-        //     redits: Option<Vec<DomEdit<'static>>>,
-        // ) -> anyhow::Result<()> {
-        let mut weviews = HashMap::new();
-
-        let vir = VirtualDom::new_with_props(root, props);
-
-        let vdom = Arc::new(RwLock::new(vir));
-
-        let event_loop = EventLoop::new();
-        event_loop.run(move |event, event_loop, control_flow| {
-            *control_flow = ControlFlow::Wait;
-
-            match event {
-                Event::NewEvents(StartCause::Init) => {
-                    println!("Init");
-
-                    let window = user_builder(WindowBuilder::new())
-                        .build(&event_loop)
-                        .unwrap();
-
-                    let registry = Arc::new(RwLock::new(Some(WebviewRegistry::new())));
-
-                    let window = WindowBuilder::new().build(&event_loop).unwrap();
-                    let window_id = window.id();
-
-                    let vdom = vdom.clone();
-                    let weview = WebViewBuilder::new(window)
-                        .unwrap()
-                        // .with_visible(false)
-                        // .with_transparent(true)
-                        .with_url(&format!("data:text/html,{}", HTML_CONTENT))
-                        .unwrap()
-                        .with_rpc_handler(move |_window: &Window, mut req: RpcRequest| {
-                            match req.method.as_str() {
-                                "initiate" => {
-                                    // let edits = if let Some(edits) = &redits {
-                                    //     serde_json::to_value(edits).unwrap()
-                                    // } else
-                                    let edits = {
-                                        let mut lock = vdom.write().unwrap();
-                                        let mut reg_lock = registry.write().unwrap();
-
-                                        // Create the thin wrapper around the registry to collect the edits into
-                                        let mut real =
-                                            dom::WebviewDom::new(reg_lock.take().unwrap());
-
-                                        // Serialize the edit stream
-                                        let edits = {
-                                            let mut edits = Vec::<DomEdit>::new();
-                                            // lock.rebuild(&mut edits).unwrap();
-                                            serde_json::to_value(edits).unwrap()
-                                        };
-
-                                        // Give back the registry into its slot
-                                        *reg_lock = Some(real.consume());
-                                        edits
-                                    };
-
-                                    // Return the edits into the webview runtime
-                                    Some(RpcResponse::new_result(req.id.take(), Some(edits)))
-                                }
-                                "user_event" => {
-                                    let mut lock = vdom.write().unwrap();
-                                    let mut reg_lock = registry.write().unwrap();
-
-                                    // Create the thin wrapper around the registry to collect the edits into
-                                    let mut real = dom::WebviewDom::new(reg_lock.take().unwrap());
-
-                                    // Serialize the edit stream
-                                    let edits = {
-                                        let mut edits = Vec::<DomEdit>::new();
-                                        // lock.rebuild(&mut edits).unwrap();
-                                        serde_json::to_value(edits).unwrap()
-                                    };
-
-                                    // Give back the registry into its slot
-                                    *reg_lock = Some(real.consume());
-
-                                    // Return the edits into the webview runtime
-                                    Some(RpcResponse::new_result(req.id.take(), Some(edits)))
-                                }
-                                _ => todo!("this message failed"),
-                            }
-                        })
-                        .build()
-                        .unwrap();
-
-                    // let weview = WebViewBuilder::new(window)
-                    //     .unwrap()
-                    //     .with_url("https://tauri.studio")
-                    //     .unwrap()
-                    //     .build()
-                    //     .unwrap();
-                    weviews.insert(window_id, weview);
-                }
-                Event::Resumed => {
-                    println!("applicationDidBecomeActive");
-                }
-                Event::Suspended => {
-                    println!("applicationWillResignActive");
-                }
-                Event::LoopDestroyed => {
-                    println!("applicationWillTerminate");
-                }
-                Event::WindowEvent {
-                    window_id,
-                    event: WindowEvent::Touch(touch),
-                    ..
-                } => {
-                    println!("touch on {:?} {:?}", window_id, touch);
-                }
-                _ => {}
-            }
-        });
-    }
-}
-
-fn main() {
-    let event_loop = EventLoop::new();
-
-    let mut weviews = HashMap::new();
-
-    event_loop.run(move |event, event_loop, control_flow| {
-        *control_flow = ControlFlow::Wait;
-        match event {
-            Event::NewEvents(StartCause::Init) => {
-                println!("Init");
-
-                let window = WindowBuilder::new().build(&event_loop).unwrap();
-                let window_id = window.id();
-
-                let weview = WebViewBuilder::new(window)
-                    .unwrap()
-                    .with_url("https://tauri.studio")
-                    .unwrap()
-                    .build()
-                    .unwrap();
-                weviews.insert(window_id, weview);
-            }
-            Event::Resumed => {
-                println!("applicationDidBecomeActive");
-            }
-            Event::Suspended => {
-                println!("applicationWillResignActive");
-            }
-            Event::LoopDestroyed => {
-                println!("applicationWillTerminate");
-            }
-            Event::WindowEvent {
-                window_id,
-                event: WindowEvent::Touch(touch),
-                ..
-            } => {
-                println!("touch on {:?} {:?}", window_id, touch);
-            }
-            _ => {}
-        }
-    });
-}
+pub use dioxus_desktop::*;

packages/mobile/src/oldlib.rs

@@ -1,70 +0,0 @@
-use dioxus::virtual_dom::VirtualDom;
-pub use dioxus_core as dioxus;
-use dioxus_core::{events::EventTrigger, prelude::FC};
-
-pub struct IosRenderer {
-    internal_dom: VirtualDom,
-}
-
-impl IosRenderer {
-    pub async fn run(&mut self) -> dioxus_core::error::Result<()> {
-        let (sender, mut receiver) = async_channel::unbounded::<EventTrigger>();
-
-        // let body_element = prepare_websys_dom();
-
-        let mut patch_machine = interpreter::PatchMachine::new(body_element.clone(), move |ev| {
-            log::debug!("Event trigger! {:#?}", ev);
-            let mut c = sender.clone();
-            // wasm_bindgen_futures::spawn_local(async move {
-            //     c.send(ev).await.unwrap();
-            // });
-        });
-        let root_node = body_element.first_child().unwrap();
-        patch_machine.stack.push(root_node.clone());
-
-        // todo: initialize the event registry properly on the root
-
-        let edits = self.internal_dom.rebuild()?;
-        log::debug!("Received edits: {:#?}", edits);
-        edits.iter().for_each(|edit| {
-            log::debug!("patching with  {:?}", edit);
-            patch_machine.handle_edit(edit);
-        });
-
-        patch_machine.reset();
-        let root_node = body_element.first_child().unwrap();
-        patch_machine.stack.push(root_node.clone());
-
-        // log::debug!("patch stack size {:?}", patch_machine.stack);
-
-        // Event loop waits for the receiver to finish up
-        // TODO! Connect the sender to the virtual dom's suspense system
-        // Suspense is basically an external event that can force renders to specific nodes
-        while let Ok(event) = receiver.recv().await {
-            log::debug!("Stack before entrance {:#?}", patch_machine.stack.top());
-            // log::debug!("patch stack size before {:#?}", patch_machine.stack);
-            // patch_machine.reset();
-            // patch_machine.stack.push(root_node.clone());
-            let edits = self.internal_dom.progress_with_event(event)?;
-            log::debug!("Received edits: {:#?}", edits);
-
-            for edit in &edits {
-                log::debug!("edit stream {:?}", edit);
-                // log::debug!("Stream stack {:#?}", patch_machine.stack.top());
-                patch_machine.handle_edit(edit);
-            }
-
-            // log::debug!("patch stack size after {:#?}", patch_machine.stack);
-            patch_machine.reset();
-            // our root node reference gets invalidated
-            // not sure why
-            // for now, just select the first child again.
-            // eventually, we'll just make our own root element instead of using body
-            // or just use body directly IDEK
-            let root_node = body_element.first_child().unwrap();
-            patch_machine.stack.push(root_node.clone());
-        }
-
-        Ok(()) // should actually never return from this, should be an error, rustc just cant see it
-    }
-}