Add basic IME support for Android

This adds basic support for Ime events to the Android backend.

Note that this will only work when running with the game-activity
backend, which uses AGDK GameText to forward Android IME events:

https://developer.android.com/games/agdk/add-support-for-text-input

Normally on Android, input methods track three things:
- Surrounding text
- A compose region
- A selection

Since Winit (0.30) doesn't track surrounding text and therefore also
wouldn't be able to handle orthogonal compose + selection regions within
some surrounding text, we can treat the whole text region that we edit
as the "preedit" string, and we can then treat the compose region as the
optional selection within the preedit string.

I've tested this with Egui 0.33

I've seem some quirky cases when testing with Egui (such as if you try
and move the cursor in the Egui widget while you're in the middle of
entering text via a soft keyboard) but I think those are related to
general shortcomings of the winit 0.30 IME API and Egui's support for
IMEs (there's no way for Egui to notify through Winit that the cursor
position has changed).

Author: rib

src/changelog/v0.30.md

@@ -1,3 +1,10 @@
+
+## 0.30.13
+
+### Added
+
+- On Android, added support for Ime events, for soft keyboard input.
+
 ## 0.30.12
 
 ### Fixed

src/event.rs

@@ -227,7 +227,7 @@ pub enum WindowEvent {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / Orbital:** Unsupported.
+    /// - **iOS / Web / Orbital:** Unsupported.
     Ime(Ime),
 
     /// The cursor has moved on the window.

src/platform_impl/android/mod.rs

@@ -6,7 +6,9 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{mpsc, Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
+use android_activity::input::{
+    InputEvent, KeyAction, Keycode, MotionAction, TextInputState, TextSpan,
+};
 use android_activity::{
     AndroidApp, AndroidAppWaker, ConfigurationRef, InputStatus, MainEvent, Rect,
 };
@@ -466,6 +468,31 @@ impl<T: 'static> EventLoop<T> {
                     },
                 }
             },
+            InputEvent::TextEvent(ime_state) => {
+                // Note: Winit does not support surrounding text or tracking a selection/cursor that
+                // may span within the surrounding text and the preedit text.
+                //
+                // Since there's no API to specify surrounding text, set_ime_allowed() will reset
+                // the text to an empty string and we will treat all the text as preedit text.
+                //
+                // We map Android's composing region to winit's preedit selection region.
+                //
+                // This seems a little odd, since Android's notion of a "composing region" would
+                // normally be equated with winit's "preedit" text but conceptually we're mapping
+                // Android's surrounding text + composing region into winit's preedit text +
+                // selection region.
+                //
+                // We ignore the separate selection region that Android supports.
+                let event = event::Event::WindowEvent {
+                    window_id: window::WindowId(WindowId),
+                    event: event::WindowEvent::Ime(event::Ime::Preedit(
+                        ime_state.text.clone(),
+                        ime_state.compose_region.map(|span| (span.start, span.end)),
+                    )),
+                };
+
+                callback(event, self.window_target());
+            },
             _ => {
                 warn!("Unknown android_activity input event {event:?}")
             },
@@ -770,6 +797,7 @@ pub struct PlatformSpecificWindowAttributes;
 pub(crate) struct Window {
     app: AndroidApp,
     redraw_requester: RedrawRequester,
+    ime_allowed: AtomicBool,
 }
 
 impl Window {
@@ -779,7 +807,11 @@ impl Window {
     ) -> Result<Self, error::OsError> {
         // FIXME this ignores requested window attributes
 
-        Ok(Self { app: el.app.clone(), redraw_requester: el.redraw_requester.clone() })
+        Ok(Self {
+            app: el.app.clone(),
+            redraw_requester: el.redraw_requester.clone(),
+            ime_allowed: AtomicBool::new(false),
+        })
     }
 
     pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Self) + Send + 'static) {
@@ -909,11 +941,24 @@ impl Window {
     pub fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
 
     pub fn set_ime_allowed(&self, allowed: bool) {
+        // Request a show/hide regardless of whether the state has changed, since
+        // the keyboard may have been dismissed by the user manually while in the
+        // middle of text input
         if allowed {
             self.app.show_soft_input(true);
         } else {
             self.app.hide_soft_input(true);
         }
+
+        if self.ime_allowed.swap(allowed, Ordering::SeqCst) == allowed {
+            return;
+        }
+
+        self.app.set_text_input_state(TextInputState {
+            text: String::new(),
+            selection: TextSpan { start: 0, end: 0 },
+            compose_region: None,
+        });
     }
 
     pub fn set_ime_purpose(&self, _purpose: ImePurpose) {}