Move some implementations around

src/platform/android/ffi.rs

@@ -0,0 +1,108 @@
+#![allow(dead_code)]
+#![allow(non_snake_case)]
+#![allow(non_camel_case_types)]
+#![allow(non_upper_case_globals)]
+
+use libc;
+use std::os::raw;
+
+#[link(name = "android")]
+#[link(name = "EGL")]
+#[link(name = "GLESv2")]
+extern {}
+
+/**
+ * asset_manager.h
+ */
+pub type AAssetManager = raw::c_void;
+
+/**
+ * native_window.h
+ */
+pub type ANativeWindow = raw::c_void;
+
+extern {
+    pub fn ANativeWindow_getHeight(window: *const ANativeWindow) -> libc::int32_t;
+    pub fn ANativeWindow_getWidth(window: *const ANativeWindow) -> libc::int32_t;
+}
+
+/**
+ * native_activity.h
+ */
+pub type JavaVM = ();
+pub type JNIEnv = ();
+pub type jobject = *const libc::c_void;
+
+pub type AInputQueue = ();  // FIXME: wrong
+pub type ARect = ();  // FIXME: wrong
+
+#[repr(C)]
+pub struct ANativeActivity {
+    pub callbacks: *mut ANativeActivityCallbacks,
+    pub vm: *mut JavaVM,
+    pub env: *mut JNIEnv,
+    pub clazz: jobject,
+    pub internalDataPath: *const libc::c_char,
+    pub externalDataPath: *const libc::c_char,
+    pub sdkVersion: libc::int32_t,
+    pub instance: *mut libc::c_void,
+    pub assetManager: *mut AAssetManager,
+    pub obbPath: *const libc::c_char,
+}
+
+#[repr(C)]
+pub struct ANativeActivityCallbacks {
+    pub onStart: extern fn(*mut ANativeActivity),
+    pub onResume: extern fn(*mut ANativeActivity),
+    pub onSaveInstanceState: extern fn(*mut ANativeActivity, *mut libc::size_t),
+    pub onPause: extern fn(*mut ANativeActivity),
+    pub onStop: extern fn(*mut ANativeActivity),
+    pub onDestroy: extern fn(*mut ANativeActivity),
+    pub onWindowFocusChanged: extern fn(*mut ANativeActivity, libc::c_int),
+    pub onNativeWindowCreated: extern fn(*mut ANativeActivity, *const ANativeWindow),
+    pub onNativeWindowResized: extern fn(*mut ANativeActivity, *const ANativeWindow),
+    pub onNativeWindowRedrawNeeded: extern fn(*mut ANativeActivity, *const ANativeWindow),
+    pub onNativeWindowDestroyed: extern fn(*mut ANativeActivity, *const ANativeWindow),
+    pub onInputQueueCreated: extern fn(*mut ANativeActivity, *mut AInputQueue),
+    pub onInputQueueDestroyed: extern fn(*mut ANativeActivity, *mut AInputQueue),
+    pub onContentRectChanged: extern fn(*mut ANativeActivity, *const ARect),
+    pub onConfigurationChanged: extern fn(*mut ANativeActivity),
+    pub onLowMemory: extern fn(*mut ANativeActivity),
+}
+
+/**
+ * looper.h
+ */
+pub type ALooper = ();
+
+#[link(name = "android")]
+extern {
+    pub fn ALooper_forThread() -> *const ALooper;
+    pub fn ALooper_acquire(looper: *const ALooper);
+    pub fn ALooper_release(looper: *const ALooper);
+    pub fn ALooper_prepare(opts: libc::c_int) -> *const ALooper;
+    pub fn ALooper_pollOnce(timeoutMillis: libc::c_int, outFd: *mut libc::c_int,
+        outEvents: *mut libc::c_int, outData: *mut *mut libc::c_void) -> libc::c_int;
+    pub fn ALooper_pollAll(timeoutMillis: libc::c_int, outFd: *mut libc::c_int,
+        outEvents: *mut libc::c_int, outData: *mut *mut libc::c_void) -> libc::c_int;
+    pub fn ALooper_wake(looper: *const ALooper);
+    pub fn ALooper_addFd(looper: *const ALooper, fd: libc::c_int, ident: libc::c_int,
+        events: libc::c_int, callback: ALooper_callbackFunc, data: *mut libc::c_void)
+        -> libc::c_int;
+    pub fn ALooper_removeFd(looper: *const ALooper, fd: libc::c_int) -> libc::c_int;
+}
+
+pub const ALOOPER_PREPARE_ALLOW_NON_CALLBACKS: libc::c_int = 1 << 0;
+
+pub const ALOOPER_POLL_WAKE: libc::c_int = -1;
+pub const ALOOPER_POLL_CALLBACK: libc::c_int = -2;
+pub const ALOOPER_POLL_TIMEOUT: libc::c_int = -3;
+pub const ALOOPER_POLL_ERROR: libc::c_int = -4;
+
+pub const ALOOPER_EVENT_INPUT: libc::c_int = 1 << 0;
+pub const ALOOPER_EVENT_OUTPUT: libc::c_int = 1 << 1;
+pub const ALOOPER_EVENT_ERROR: libc::c_int = 1 << 2;
+pub const ALOOPER_EVENT_HANGUP: libc::c_int = 1 << 3;
+pub const ALOOPER_EVENT_INVALID: libc::c_int = 1 << 4;
+
+pub type ALooper_callbackFunc = extern fn(libc::c_int, libc::c_int, *mut libc::c_void) -> libc::c_int;

src/platform/android/mod.rs

@@ -1,3 +1,256 @@
 #![cfg(target_os = "android")]
 
-pub use api::android::*;
+extern crate android_glue;
+
+use libc;
+use std::ffi::{CString};
+use std::sync::mpsc::{Receiver, channel};
+use std::os::raw::c_void;
+use {CreationError, Event, MouseCursor};
+use CreationError::OsError;
+use events::ElementState::{Pressed, Released};
+use events::{Touch, TouchPhase};
+
+use std::collections::VecDeque;
+
+use CursorState;
+use WindowAttributes;
+use native_monitor::NativeMonitorId;
+
+pub struct Window {
+    native_window: *const c_void,
+    event_rx: Receiver<android_glue::Event>,
+}
+
+#[derive(Clone)]
+pub struct MonitorId;
+
+mod ffi;
+
+#[inline]
+pub fn get_available_monitors() -> VecDeque<MonitorId> {
+    let mut rb = VecDeque::new();
+    rb.push_back(MonitorId);
+    rb
+}
+
+#[inline]
+pub fn get_primary_monitor() -> MonitorId {
+    MonitorId
+}
+
+impl MonitorId {
+    #[inline]
+    pub fn get_name(&self) -> Option<String> {
+        Some("Primary".to_string())
+    }
+
+    #[inline]
+    pub fn get_native_identifier(&self) -> NativeMonitorId {
+        NativeMonitorId::Unavailable
+    }
+
+    #[inline]
+    pub fn get_dimensions(&self) -> (u32, u32) {
+        unimplemented!()
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct PlatformSpecificWindowBuilderAttributes;
+#[derive(Clone, Default)]
+pub struct PlatformSpecificHeadlessBuilderAttributes;
+
+pub struct PollEventsIterator<'a> {
+    window: &'a Window,
+}
+
+impl<'a> Iterator for PollEventsIterator<'a> {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Event> {
+        match self.window.event_rx.try_recv() {
+            Ok(android_glue::Event::EventMotion(motion)) => {
+                Some(Event::Touch(Touch {
+                    phase: match motion.action {
+                        android_glue::MotionAction::Down => TouchPhase::Started,
+                        android_glue::MotionAction::Move => TouchPhase::Moved,
+                        android_glue::MotionAction::Up => TouchPhase::Ended,
+                        android_glue::MotionAction::Cancel => TouchPhase::Cancelled,
+                    },
+                    location: (motion.x as f64, motion.y as f64),
+                    id: motion.pointer_id as u64,
+                }))
+            }
+            _ => {
+                None
+            }
+        }
+    }
+}
+
+pub struct WaitEventsIterator<'a> {
+    window: &'a Window,
+}
+
+impl<'a> Iterator for WaitEventsIterator<'a> {
+    type Item = Event;
+
+    #[inline]
+    fn next(&mut self) -> Option<Event> {
+        loop {
+            // calling poll_events()
+            if let Some(ev) = self.window.poll_events().next() {
+                return Some(ev);
+            }
+
+            // TODO: Implement a proper way of sleeping on the event queue
+            // timer::sleep(Duration::milliseconds(16));
+        }
+    }
+}
+
+impl Window {
+    pub fn new(win_attribs: &WindowAttributes, _: &PlatformSpecificWindowBuilderAttributes)
+               -> Result<Window, CreationError>
+    {
+        use std::{mem, ptr};
+
+        // not implemented
+        assert!(win_attribs.min_dimensions.is_none());
+        assert!(win_attribs.max_dimensions.is_none());
+
+        let native_window = unsafe { android_glue::get_native_window() };
+        if native_window.is_null() {
+            return Err(OsError(format!("Android's native window is null")));
+        }
+
+        let (tx, rx) = channel();
+        android_glue::add_sender(tx);
+        android_glue::set_multitouch(win_attribs.multitouch);
+
+        Ok(Window {
+            native_window: native_window as *const _,
+            event_rx: rx,
+        })
+    }
+
+    #[inline]
+    pub fn get_native_window(&self) -> *const c_void {
+        self.native_window
+    }
+
+    #[inline]
+    pub fn is_closed(&self) -> bool {
+        false
+    }
+
+    #[inline]
+    pub fn set_title(&self, _: &str) {
+    }
+
+    #[inline]
+    pub fn show(&self) {
+    }
+
+    #[inline]
+    pub fn hide(&self) {
+    }
+
+    #[inline]
+    pub fn get_position(&self) -> Option<(i32, i32)> {
+        None
+    }
+
+    #[inline]
+    pub fn set_position(&self, _x: i32, _y: i32) {
+    }
+
+    #[inline]
+    pub fn get_inner_size(&self) -> Option<(u32, u32)> {
+        let native_window = unsafe { android_glue::get_native_window() };
+
+        if native_window.is_null() {
+            None
+        } else {
+            Some((
+                unsafe { ffi::ANativeWindow_getWidth(native_window as *const _) } as u32,
+                unsafe { ffi::ANativeWindow_getHeight(native_window as *const _) } as u32
+            ))
+        }
+    }
+
+    #[inline]
+    pub fn get_outer_size(&self) -> Option<(u32, u32)> {
+        self.get_inner_size()
+    }
+
+    #[inline]
+    pub fn set_inner_size(&self, _x: u32, _y: u32) {
+    }
+
+    #[inline]
+    pub fn create_window_proxy(&self) -> WindowProxy {
+        WindowProxy
+    }
+
+    #[inline]
+    pub fn poll_events(&self) -> PollEventsIterator {
+        PollEventsIterator {
+            window: self
+        }
+    }
+
+    #[inline]
+    pub fn wait_events(&self) -> WaitEventsIterator {
+        WaitEventsIterator {
+            window: self
+        }
+    }
+
+    #[inline]
+    pub fn platform_display(&self) -> *mut libc::c_void {
+        unimplemented!();
+    }
+
+    #[inline]
+    pub fn platform_window(&self) -> *mut libc::c_void {
+        unimplemented!()
+    }
+
+    #[inline]
+    pub fn set_window_resize_callback(&mut self, _: Option<fn(u32, u32)>) {
+    }
+
+    #[inline]
+    pub fn set_cursor(&self, _: MouseCursor) {
+    }
+
+    #[inline]
+    pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
+        Ok(())
+    }
+
+    #[inline]
+    pub fn hidpi_factor(&self) -> f32 {
+        1.0
+    }
+
+    #[inline]
+    pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
+        unimplemented!();
+    }
+}
+
+unsafe impl Send for Window {}
+unsafe impl Sync for Window {}
+
+#[derive(Clone)]
+pub struct WindowProxy;
+
+impl WindowProxy {
+    #[inline]
+    pub fn wakeup_event_loop(&self) {
+        unimplemented!()
+    }
+}