iOS runtime using uikit.

Cargo.toml

@@ -55,6 +55,7 @@ members = [
     "native",
     "style",
     "web",
+    "ios",
     "wgpu",
     "winit",
     "examples/bezier_tool",
@@ -86,7 +87,7 @@ iced_core = { version = "0.2", path = "core" }
 iced_futures = { version = "0.1", path = "futures" }
 thiserror = "1.0"
 
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+[target.'cfg(all(not(target_arch = "wasm32"), not(target_os = "ios")))'.dependencies]
 iced_winit = { version = "0.1", path = "winit" }
 iced_glutin = { version = "0.1", path = "glutin", optional = true }
 iced_wgpu = { version = "0.2", path = "wgpu", optional = true }
@@ -95,6 +96,9 @@ iced_glow = { version = "0.1", path = "glow", optional = true}
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 iced_web = { version = "0.2", path = "web" }
 
+[target.'cfg(target_os = "ios")'.dependencies]
+iced_ios = { version = "0.1", path = "ios" }
+
 [package.metadata.docs.rs]
 rustdoc-args = ["--cfg", "docsrs"]
 features = ["image", "svg", "canvas"]

ios/.gitignore

@@ -0,0 +1 @@
+Cargo.lock

ios/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "iced_ios"
+version = "0.1.0"
+authors = ["Sebastian Imlay <[email protected]>"]
+edition = "2018"
+description = "iOS backend for iced"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+twox-hash = "1.5"
+raw-window-handle = "^0.3"
+winit = { git = "https://github.com/rust-windowing/winit", branch = "master"}
+objc = "0.2.7"
+log = "0.4"
+num-traits = "0.2"
+uikit-sys = { git = "https://github.com/simlay/uikit-sys", branch = "bindgen-category-and-no-copy" }
+dispatch = "0.2.0"
+
+[dependencies.iced_core]
+version = "0.2"
+path = "../core"
+
+[dependencies.iced_style]
+version = "0.1"
+path = "../style"
+
+[dependencies.iced_futures]
+version = "0.1"
+path = "../futures"
+features = ["thread-pool"]

ios/Makefile

@@ -0,0 +1,18 @@
+.PHONY: test example
+
+example: example-run
+
+example-build:
+	RUST_BACKTRACE=full RUST_LOG=debug cargo bundle --format ios --target x86_64-apple-ios --example ios-example
+
+example-install:  example-build
+	xcrun simctl install booted $(PWD)/../target/x86_64-apple-ios/debug/examples/bundle/ios/ios-example.app/
+
+example-run:  example-install
+	xcrun simctl launch --console booted com.github.iced.simple
+
+test:
+	cargo dinghy --platform auto-ios-x86_64 test
+
+check:
+	cargo check --target x86_64-apple-ios

ios/src/application.rs

@@ -0,0 +1,199 @@
+use crate::{
+    event::{EventHandler, WidgetEvent},
+    widget::{Widget, WidgetNode},
+    Command, Element, Executor, Runtime, Subscription,
+};
+use winit::{
+    event,
+    event_loop::{ControlFlow, EventLoop},
+    platform::ios::{
+        WindowExtIOS
+    },
+    monitor::MonitorHandle,
+    window::{
+        WindowBuilder,
+        Window,
+        Fullscreen,
+    },
+};
+
+use uikit_sys::{
+    self,
+    //CGRect,
+    //CGPoint,
+    //CGSize,
+    id,
+    IUIColor,
+    //IUISwitch,
+    //IUIView,
+    UIColor,
+    //UISwitch,
+    UIView,
+    //UIView_UIViewGeometry,
+    //UIView_UIViewHierarchy,
+    //UIView,
+    //UIViewController,
+    UIView_UIViewRendering,
+};
+
+pub trait Application: Sized {
+    type Executor: Executor;
+
+    /// The type of __messages__ your [`Application`] will produce.
+    ///
+    /// [`Application`]: trait.Application.html
+    type Message: std::fmt::Debug + Send;
+
+    /// The data needed to initialize your [`Application`].
+    ///
+    /// [`Application`]: trait.Application.html
+    type Flags;
+
+    /// Initializes the [`Application`].
+    ///
+    /// Here is where you should return the initial state of your app.
+    ///
+    /// Additionally, you can return a [`Command`](struct.Command.html) if you
+    /// need to perform some async action in the background on startup. This is
+    /// useful if you want to load state from a file, perform an initial HTTP
+    /// request, etc.
+    ///
+    /// [`Application`]: trait.Application.html
+    fn new(flags: Self::Flags) -> (Self, Command<Self::Message>)
+    where
+        Self: Sized;
+
+    /// Returns the current title of the [`Application`].
+    ///
+    /// This title can be dynamic! The runtime will automatically update the
+    /// title of your application when necessary.
+    ///
+    /// [`Application`]: trait.Application.html
+    fn title(&self) -> String;
+
+    /// Handles a __message__ and updates the state of the [`Application`].
+    ///
+    /// This is where you define your __update logic__. All the __messages__,
+    /// produced by either user interactions or commands, will be handled by
+    /// this method.
+    ///
+    /// Any [`Command`] returned will be executed immediately in the background.
+    ///
+    /// [`Application`]: trait.Application.html
+    /// [`Command`]: struct.Command.html
+    fn update(&mut self, message: Self::Message) -> Command<Self::Message>;
+
+    /// Returns the widgets to display in the [`Application`].
+    ///
+    /// These widgets can produce __messages__ based on user interaction.
+    ///
+    /// [`Application`]: trait.Application.html
+    fn view(&mut self) -> Element<'_, Self::Message>;
+
+    /// Returns the event [`Subscription`] for the current state of the
+    /// application.
+    ///
+    /// A [`Subscription`] will be kept alive as long as you keep returning it,
+    /// and the __messages__ produced will be handled by
+    /// [`update`](#tymethod.update).
+    ///
+    /// By default, this method returns an empty [`Subscription`].
+    ///
+    /// [`Subscription`]: struct.Subscription.html
+    fn subscription(&self) -> Subscription<Self::Message> {
+        Subscription::none()
+    }
+
+    /// Runs the [`Application`].
+    ///
+    /// [`Application`]: trait.Application.html
+    fn run(flags: Self::Flags)
+    where
+        Self: 'static + Sized,
+    {
+        let event_loop: EventLoop<WidgetEvent> = EventLoop::with_user_event();
+        let proxy = event_loop.create_proxy();
+        EventHandler::init(proxy.clone());
+        let (sender, _receiver) =
+            iced_futures::futures::channel::mpsc::unbounded();
+
+        let mut runtime = {
+            let executor = Self::Executor::new().expect("Create executor");
+
+            Runtime::new(executor, sender)
+        };
+
+        let (mut app, command) = runtime.enter(|| Self::new(flags));
+        runtime.spawn(command);
+
+        let title = app.title();
+
+        let window = {
+            let mut window_builder = WindowBuilder::new();
+
+            window_builder = window_builder
+                .with_title(title)
+                .with_decorations(true)
+            ;
+            window_builder.build(&event_loop).expect("Open window")
+        };
+
+        let root_view: UIView = UIView(window.ui_view() as id);
+        // TODO: Make this a debug feature
+        unsafe {
+            root_view.setBackgroundColor_(UIColor::redColor());
+        }
+        let mut widget_tree: WidgetNode = WidgetNode::new(0 as id, crate::widget::WidgetType::BaseElement, 0);
+
+        event_loop.run(
+            move |event: winit::event::Event<WidgetEvent>, _, control_flow| {
+                let mut messages: Vec<Self::Message> = Vec::new();
+                match event {
+                    event::Event::MainEventsCleared => {}
+                    event::Event::UserEvent(widget_event) => {
+                        {
+                            let mut element = app.view();
+                            element.widget.on_widget_event(
+                                widget_event,
+                                &mut messages,
+                                &widget_tree,
+                            );
+                            trace!("Root widget before: {:?}", widget_tree);
+                        }
+                        debug!("NEW MESSAGES! {:?}", messages);
+                        for message in messages {
+                            let (command, subscription) = runtime.enter(|| {
+                                let command = app.update(message);
+                                let subscription = app.subscription();
+
+                                (command, subscription)
+                            });
+
+                            runtime.spawn(command);
+                            runtime.track(subscription);
+                        }
+                        let element = app.view();
+
+                        element.update(&mut widget_tree, Some(root_view.clone()));
+                        trace!("Root widget after: {:#?}", widget_tree);
+                    }
+                    event::Event::RedrawRequested(_) => {}
+                    event::Event::WindowEvent {
+                        event: _window_event,
+                        ..
+                    } => {}
+                    event::Event::NewEvents(event::StartCause::Init) => {
+                        trace!("WINDOW INIT!");
+                        let element = app.view();
+                        widget_tree = element.build_uiview(true);
+                        let root_view: UIView = UIView(window.ui_view() as id);
+                        widget_tree.draw(root_view);
+                    }
+                    _ => {
+                        *control_flow = ControlFlow::Wait;
+                    }
+                }
+            },
+        );
+    }
+}

ios/src/event.rs

@@ -0,0 +1,89 @@
+use winit::event_loop::EventLoopProxy;
+use objc::{
+    declare::ClassDecl,
+    runtime::{
+        Object,
+        Class,
+        Sel,
+    },
+};
+
+use uikit_sys::id;
+
+
+
+#[derive(PartialEq, Clone, Debug)]
+pub struct WidgetEvent {
+    pub widget_id: u64,
+    pub id: usize,
+}
+
+#[derive(Debug)]
+pub struct EventHandler {
+    pub id: id,
+    pub widget_id: u64,
+}
+
+static mut PROXY : Option<EventLoopProxy<WidgetEvent>> = None;
+static mut COUNTER: Option<u64> = None;
+impl EventHandler {
+    pub fn init(proxy: EventLoopProxy<WidgetEvent>) {
+        unsafe {
+            COUNTER = Some(0);
+            PROXY = Some(proxy);
+        }
+    }
+    pub fn new(objc_id: id) -> Self
+    {
+        let mut widget_id = 0;
+        // TODO: Figure out how to make this unsafe block much smaller.
+        let obj = unsafe {
+            let obj: id = objc::msg_send![Self::class(), alloc];
+            let obj: id = objc::msg_send![obj, init];
+
+            if let Some(mut counter) = COUNTER {
+                counter += 1;
+                COUNTER = Some(counter);
+                widget_id = counter;
+                (*obj).set_ivar::<u64>("widget_id", widget_id);
+            }
+            (*obj).set_ivar::<id>("objc_id", objc_id);
+            obj
+        };
+        trace!("NEW EVENTHANDLER WITH WIDGET ID :{:?}", widget_id);
+        Self{id: obj, widget_id}
+    }
+    extern "C" fn event(this: &Object, _cmd: objc::runtime::Sel)
+    {
+
+        // TODO: Figure out how to make this unsafe block smaller.
+        unsafe {
+            if let Some(ref proxy) = PROXY {
+                let widget_id = *this.get_ivar::<u64>("widget_id");
+                let id = *this.get_ivar::<id>("objc_id");
+                let _ = proxy.send_event(WidgetEvent { widget_id, id: id as usize} );
+            }
+        }
+    }
+
+    fn class() -> &'static Class
+    {
+        let cls_name = "RustEventHandler";
+        match Class::get(cls_name) {
+            Some(cls) => cls,
+            None => {
+                let superclass = objc::class!(NSObject);
+                let mut decl = ClassDecl::new(cls_name, superclass).unwrap();
+                unsafe {
+                    decl.add_method(
+                        objc::sel!(sendEvent),
+                        Self::event as extern "C" fn(&Object, Sel),
+                    );
+                }
+                decl.add_ivar::<u64>("widget_id");
+                decl.add_ivar::<id>("objc_id");
+                decl.register()
+            }
+        }
+    }
+}

ios/src/keyboard.rs

@@ -0,0 +1,4 @@
+
+pub type Event = ();
+pub type KeyCode = ();
+pub type ModifiersState = ();