From 1ece2ad87dfad98df87466deca25defa3f3b0550 Mon Sep 17 00:00:00 2001
From: Robert Bragg <robert@sixbynine.org>
Date: Tue, 18 Oct 2022 19:38:22 +0100
Subject: [PATCH] Update README.md

Update example (copy from na-mainloop)
---
 README.md | 122 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 67 insertions(+), 55 deletions(-)

diff --git a/README.md b/README.md
index 0fd7b23..d369fb3 100644
--- a/README.md
+++ b/README.md
@@ -176,75 +176,87 @@ automatically release the blocked Java thread once it has delivered the correspo
 
 For example:
 ```rust
-use native_activity::{PollEvent, MainEvent};
+use android_activity::{AndroidApp, MainEvent, PollEvent, InputStatus};
 use log::info;
 
 #[no_mangle]
-extern "C" fn android_main() {
-    android_logger::init_once(
-        android_logger::Config::default().with_min_level(log::Level::Info)
-    );
+fn android_main(app: AndroidApp) {
+    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Info));
 
     let mut quit = false;
     let mut redraw_pending = true;
     let mut render_state: Option<()> = Default::default();
 
-    let app = native_activity::android_app();
     while !quit {
-        app.poll_events(Some(std::time::Duration::from_millis(500)) /* timeout */, |event| {
-            match event {
-                PollEvent::Wake => { info!("Early wake up"); },
-                PollEvent::Timeout => {
-                    info!("Timed out");
-                    // Real app would probably rely on vblank sync via graphics API...
-                    redraw_pending = true;
-                },
-                PollEvent::Main(main_event) => {
-                    info!("Main event: {:?}", main_event);
-                    match main_event {
-                        MainEvent::SaveState { saver, .. } => {
-                            saver.store("foo://bar".as_bytes());
-                        },
-                        MainEvent::Pause => {},
-                        MainEvent::Resume { loader, .. } => {
-                            if let Some(state) = loader.load() {
-                                if let Ok(uri) = String::from_utf8(state) {
-                                    info!("Resumed with saved state = {uri:#?}");
+        app.poll_events(
+            Some(std::time::Duration::from_secs(1)), /* timeout */
+            |event| {
+                match event {
+                    PollEvent::Wake => {
+                        info!("Early wake up");
+                    }
+                    PollEvent::Timeout => {
+                        info!("Timed out");
+                        // Real app would probably rely on vblank sync via graphics API...
+                        redraw_pending = true;
+                    }
+                    PollEvent::Main(main_event) => {
+                        info!("Main event: {:?}", main_event);
+                        match main_event {
+                            MainEvent::SaveState { saver, .. } => {
+                                saver.store("foo://bar".as_bytes());
+                            }
+                            MainEvent::Pause => {}
+                            MainEvent::Resume { loader, .. } => {
+                                if let Some(state) = loader.load() {
+                                    if let Ok(uri) = String::from_utf8(state) {
+                                        info!("Resumed with saved state = {uri:#?}");
+                                    }
                                 }
                             }
-                        },
-                        MainEvent::InitWindow { .. } => {
-                            render_state = Some(());
-                            redraw_pending = true;
-                        },
-                        MainEvent::TerminateWindow { .. } => {
-                            render_state = None;
+                            MainEvent::InitWindow { .. } => {
+                                render_state = Some(());
+                                redraw_pending = true;
+                            }
+                            MainEvent::TerminateWindow { .. } => {
+                                render_state = None;
+                            }
+                            MainEvent::WindowResized { .. } => {
+                                redraw_pending = true;
+                            }
+                            MainEvent::RedrawNeeded { .. } => {
+                                redraw_pending = true;
+                            }
+                            MainEvent::InputAvailable { .. } => {
+                                redraw_pending = true;
+                            }
+                            MainEvent::ConfigChanged { .. } => {
+                                info!("Config Changed: {:#?}", app.config());
+                            }
+                            MainEvent::LowMemory => {}
+
+                            MainEvent::Destroy => quit = true,
+                            _ => { /* ... */ }
                         }
-                        MainEvent::WindowResized { .. } => { redraw_pending = true; },
-                        MainEvent::RedrawNeeded { ..} => { redraw_pending = true; },
-                        MainEvent::LowMemory => {},
-
-                        MainEvent::Destroy => { quit = true },
-                        _ => { /* ... */}
                     }
-                },
-                _ => {}
-            }
-
-            if redraw_pending {
-                if let Some(_rs) = render_state {
-                    redraw_pending = false;
-
-                    // Handle input
-                    app.input_events(|event| {
-                        info!("Input Event: {event:?}");
-
-                    });
-
-                    info!("Render...");
+                    _ => {}
                 }
-            }
-        });
+
+                if redraw_pending {
+                    if let Some(_rs) = render_state {
+                        redraw_pending = false;
+
+                        // Handle input
+                        app.input_events(|event| {
+                            info!("Input Event: {event:?}");
+                            InputStatus::Unhandled
+                        });
+
+                        info!("Render...");
+                    }
+                }
+            },
+        );
     }
 }
 ```