swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

publish: bump mobile

Browse Source
This commit is contained in:
Jonathan Kelley committed 2022-01-03 13:38:56 -05:00
1 parent 3de776c42a
commit 99d6409f7a
5 files changed
+12 -344
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Cargo.toml
+3 -3
View File
@@ -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
+3 -14
View File
@@ -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
-32
View File
@@ -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
+6 -225
View File
@@ -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
-70
View File
@@ -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
}
}