use android_activity::AndroidApp;
use platform_core::{
Event, EventHandler, KeyPairing, Platform, PlatformError, SystemPreferences, Window,
WindowConfig,
};
#[cfg(target_os = "android")]
unsafe fn try_set_frame_rate(window: *mut std::ffi::c_void, fps: f32) {
unsafe extern "C" {
fn dlsym(
handle: *mut core::ffi::c_void,
symbol: *const core::ffi::c_char,
) -> *mut core::ffi::c_void;
}
let sym = unsafe {
dlsym(
core::ptr::null_mut(),
c"ANativeWindow_setFrameRate".as_ptr(),
)
};
if sym.is_null() {
return;
}
let f: unsafe extern "C" fn(*mut core::ffi::c_void, f32, i8) -> i32 =
unsafe { core::mem::transmute(sym) };
unsafe { f(window, fps, 0) };
}
#[cfg(target_os = "android")]
mod choreographer {
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
#[repr(C)]
pub struct AChoreographer {
_opaque: [u8; 0],
}
pub type FrameCallbackFn =
unsafe extern "C" fn(frame_time_ns: i64, data: *mut core::ffi::c_void);
unsafe fn instance_fn() -> Option<unsafe extern "C" fn() -> *mut AChoreographer> {
unsafe extern "C" {
fn dlsym(
handle: *mut core::ffi::c_void,
symbol: *const core::ffi::c_char,
) -> *mut core::ffi::c_void;
}
let sym = unsafe {
dlsym(
core::ptr::null_mut(),
c"AChoreographer_getInstance".as_ptr(),
)
};
if sym.is_null() {
None
} else {
Some(unsafe {
core::mem::transmute::<
*mut core::ffi::c_void,
unsafe extern "C" fn() -> *mut AChoreographer,
>(sym)
})
}
}
unsafe fn post_callback_fn()
-> Option<unsafe extern "C" fn(*mut AChoreographer, FrameCallbackFn, *mut core::ffi::c_void)>
{
unsafe extern "C" {
fn dlsym(
handle: *mut core::ffi::c_void,
symbol: *const core::ffi::c_char,
) -> *mut core::ffi::c_void;
}
let sym = unsafe {
dlsym(
core::ptr::null_mut(),
c"AChoreographer_postFrameCallback".as_ptr(),
)
};
if sym.is_null() {
None
} else {
Some(unsafe {
core::mem::transmute::<
*mut core::ffi::c_void,
unsafe extern "C" fn(
*mut AChoreographer,
FrameCallbackFn,
*mut core::ffi::c_void,
),
>(sym)
})
}
}
pub unsafe extern "C" fn frame_callback(_frame_time_ns: i64, data: *mut core::ffi::c_void) {
let cb_data = unsafe { &*(data as *const VsyncCallbackData) };
cb_data.is_pending.store(false, Ordering::Release);
let _ = cb_data.proxy.send_event(());
}
pub struct VsyncCallbackData {
pub is_pending: Arc<AtomicBool>,
pub proxy: winit::event_loop::EventLoopProxy<()>,
}
pub struct Choreographer {
instance: *mut AChoreographer,
pub callback_data: Box<VsyncCallbackData>,
}
unsafe impl Send for Choreographer {}
impl Choreographer {
pub fn new(
proxy: winit::event_loop::EventLoopProxy<()>,
pending: Arc<AtomicBool>,
) -> Option<Self> {
let get_instance = unsafe { instance_fn()? };
let instance = unsafe { get_instance() };
if instance.is_null() {
return None;
}
Some(Self {
instance,
callback_data: Box::new(VsyncCallbackData {
is_pending: pending,
proxy,
}),
})
}
pub fn request_vsync(&self) {
let post = match unsafe { post_callback_fn() } {
Some(f) => f,
None => return,
};
let data_ptr =
self.callback_data.as_ref() as *const VsyncCallbackData as *mut core::ffi::c_void;
unsafe { post(self.instance, frame_callback, data_ptr) };
}
}
}
use winit::application::ApplicationHandler;
use winit::event::{StartCause, WindowEvent};
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
use winit::keyboard::PhysicalKey;
use winit::platform::android::EventLoopBuilderExtAndroid;
use winit::window::{WindowAttributes, WindowId};
use platform_winit::{SurfaceIntent, TouchDrag, map_window_event};
use crate::window::AndroidWindow;
pub struct AndroidPlatform {
event_loop: EventLoop<()>,
app: AndroidApp,
}
const PREFERENCES_POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(500);
#[cfg(target_os = "android")]
const VSYNC_WAIT: std::time::Duration = std::time::Duration::from_nanos(1_000_000_000 / 60);
impl AndroidPlatform {
pub fn try_new(app: AndroidApp) -> Result<Self, PlatformError> {
use tracing_subscriber::filter::LevelFilter;
use tracing_subscriber::prelude::*;
let logcat = paranoid_android::layer("telar").with_filter(LevelFilter::DEBUG);
tracing_subscriber::registry().with(logcat).try_init().ok();
let event_loop = EventLoop::builder()
.with_android_app(app.clone())
.build()
.map_err(|e| PlatformError(e.to_string()))?;
services_core::set_uri_opener(std::sync::Arc::new(crate::intent::AndroidUriOpener::new(
app.clone(),
)));
Ok(Self { event_loop, app })
}
}
struct AndroidRunner<H: EventHandler<AndroidWindow>> {
handler: H,
window: Option<AndroidWindow>,
config: WindowConfig,
scale_factor: f64,
modifiers: platform_core::ModifiersState,
cursor_position: (f64, f64),
touch: TouchDrag,
keys: KeyPairing<PhysicalKey>,
app: AndroidApp,
preferences: Option<SystemPreferences>,
safe_area: Option<geometry_core::Insets>,
last_preferences_poll: Option<std::time::Instant>,
#[cfg(target_os = "android")]
choreographer: Option<choreographer::Choreographer>,
#[cfg(target_os = "android")]
is_animation_pending: std::sync::Arc<std::sync::atomic::AtomicBool>,
}
impl<H: EventHandler<AndroidWindow>> AndroidRunner<H> {
fn reread_safe_area(&mut self, window: &AndroidWindow) {
let Some(insets) = crate::insets::read(&self.app, self.scale_factor) else {
return;
};
if self.safe_area.replace(insets) != Some(insets) {
self.handler
.on_event(Event::SafeAreaChanged { insets }, window);
}
}
fn reread_preferences(&mut self) {
self.last_preferences_poll = Some(std::time::Instant::now());
let Some(window) = self.window.clone() else {
return;
};
self.reread_safe_area(&window);
let preferences = crate::preferences::read(&self.app);
if self.preferences.as_ref() == Some(&preferences) {
return;
}
self.preferences = Some(preferences.clone());
self.handler
.on_event(Event::SystemPreferencesChanged { preferences }, &window);
}
}
impl<H: EventHandler<AndroidWindow>> ApplicationHandler<()> for AndroidRunner<H> {
fn new_events(&mut self, _event_loop: &ActiveEventLoop, _cause: StartCause) {
self.handler.new_events();
if self
.last_preferences_poll
.is_none_or(|at| at.elapsed() >= PREFERENCES_POLL_INTERVAL)
{
self.reread_preferences();
}
}
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
if let Some(_d) = self.handler.about_to_wait() {
#[cfg(target_os = "android")]
{
if _d > VSYNC_WAIT {
event_loop
.set_control_flow(ControlFlow::WaitUntil(std::time::Instant::now() + _d));
return;
}
let already_pending = self
.is_animation_pending
.swap(true, std::sync::atomic::Ordering::AcqRel);
if !already_pending {
if let Some(chore) = &self.choreographer {
chore.request_vsync();
} else if let Some(window) = &self.window {
window.request_redraw();
event_loop.set_control_flow(ControlFlow::WaitUntil(
std::time::Instant::now() + _d,
));
return;
}
}
event_loop.set_control_flow(ControlFlow::Wait);
}
#[cfg(not(target_os = "android"))]
{
event_loop.set_control_flow(ControlFlow::WaitUntil(std::time::Instant::now() + _d));
}
} else {
event_loop.set_control_flow(ControlFlow::Wait);
}
}
fn user_event(&mut self, _event_loop: &ActiveEventLoop, _event: ()) {
if let Some(window) = &self.window {
window.request_redraw();
}
}
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
let attrs = WindowAttributes::default()
.with_title(self.config.title.as_str())
.with_inner_size(winit::dpi::LogicalSize::new(
self.config.width,
self.config.height,
));
use std::sync::Arc;
match event_loop.create_window(attrs) {
Ok(w) => {
self.scale_factor = w.scale_factor();
#[cfg(target_os = "android")]
{
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
if let Ok(handle) = w.window_handle()
&& let RawWindowHandle::AndroidNdk(android_handle) = handle.as_raw()
{
unsafe {
try_set_frame_rate(android_handle.a_native_window.as_ptr(), 60.0);
}
}
}
let window = AndroidWindow::new(Arc::new(w), self.app.clone());
let preferences = crate::preferences::read(&self.app);
self.preferences = Some(preferences.clone());
self.last_preferences_poll = Some(std::time::Instant::now());
self.handler
.on_event(Event::SystemPreferencesChanged { preferences }, &window);
self.safe_area = None;
self.reread_safe_area(&window);
if !self.handler.on_resume(&window) {
event_loop.exit();
return;
}
window.request_redraw();
self.window = Some(window);
}
Err(e) => tracing::error!(error = %e, "failed to create window"),
}
}
fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
self.handler.on_suspend();
self.window = None;
}
fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
let Some(window) = self.window.clone() else {
return;
};
match map_window_event(
event,
&mut self.cursor_position,
&mut self.scale_factor,
&mut self.modifiers,
&mut self.touch,
&mut self.keys,
) {
SurfaceIntent::Event(e) => self.handler.on_event(e, &window),
SurfaceIntent::Dragged(scrolled, moved) => {
self.handler.on_event(scrolled, &window);
self.handler.on_event(moved, &window);
}
SurfaceIntent::Resized(e) => {
self.handler.on_event(e, &window);
self.reread_safe_area(&window);
window.request_redraw();
}
SurfaceIntent::Redraw => self.handler.on_redraw(&window),
SurfaceIntent::Close(e) => {
self.handler.on_event(e, &window);
event_loop.exit();
}
SurfaceIntent::RereadPreferences => self.reread_preferences(),
SurfaceIntent::Back => {
if !self.handler.on_back(&window) {
crate::intent::leave(&self.app);
}
}
SurfaceIntent::Ignore => {}
}
}
}
impl Platform for AndroidPlatform {
type Window = AndroidWindow;
fn location_source(&mut self) -> Option<Box<dyn platform_core::LocationSource>> {
Some(Box::new(crate::intent::IntentLocation::new(
self.app.clone(),
)))
}
fn run<H: EventHandler<Self::Window>>(
self,
config: WindowConfig,
handler: H,
) -> Result<(), PlatformError> {
#[cfg(target_os = "android")]
let animation_pending = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
#[cfg(target_os = "android")]
let choreographer = choreographer::Choreographer::new(
self.event_loop.create_proxy(),
animation_pending.clone(),
);
let mut runner = AndroidRunner {
handler,
window: None,
config,
scale_factor: 1.0,
modifiers: platform_core::ModifiersState::default(),
cursor_position: (0.0, 0.0),
touch: TouchDrag::default(),
keys: KeyPairing::default(),
app: self.app,
preferences: None,
safe_area: None,
last_preferences_poll: None,
#[cfg(target_os = "android")]
choreographer,
#[cfg(target_os = "android")]
is_animation_pending: animation_pending,
};
self.event_loop
.run_app(&mut runner)
.map_err(|e| PlatformError(e.to_string()))
}
}