src/ui/bin/text/src/legacy_ime/handler.rs - fuchsia - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 //! This module contains an implementation of `LegacyIme` itself.

 use {
     anyhow::{format_err, Context, Error, Result},
     fidl_fuchsia_ui_input::{self as uii, InputMethodEditorRequest as ImeReq},
     fidl_fuchsia_ui_input3 as ui_input3,
     futures::{lock::Mutex, prelude::*},
     std::{
         collections::{HashMap, HashSet},
         sync::{Arc, Weak},
     },
 };

 use super::{
     state::ImeState, HID_USAGE_KEY_BACKSPACE, HID_USAGE_KEY_DELETE, HID_USAGE_KEY_ENTER,
     HID_USAGE_KEY_LEFT, HID_USAGE_KEY_RIGHT,
 };
 use crate::{index_convert as idx, keyboard::events, text_manager::TextManager};

 /// An input method provides edits and cursor updates to a text field. This Legacy Input Method
 /// provides edits to a text field over the legacy pair of interfaces `InputMethodEditor` and
 /// `InputMethodEditorClient`. It can provide these edits one of two ways:
 ///
 /// 1. If `inject_input()` is called with a `KeyboardEvent`, `LegacyIme` contains an implementation
 /// of a QWERTY latin keyboard input method, and will send the appropriate edits to the text field.
 /// This can also handle arrow keys with modifiers to perform selection/caret movement.
 /// 2. If `bind_text_field()` is called with a `TextFieldRequestStream`, `LegacyIme` can serve the
 /// new `TextField` interface, translating edits or content requests from that into requests for the
 /// `InputMethodEditorClient`.
 #[derive(Clone)]
 pub struct LegacyIme(Arc<Mutex<ImeState>>);

 impl LegacyIme {
     pub fn new<I: 'static + uii::InputMethodEditorClientProxyInterface>(
         keyboard_type: uii::KeyboardType,
         action: uii::InputMethodAction,
         initial_state: uii::TextInputState,
         client: I,
         text_manager: TextManager,
     ) -> LegacyIme {
         let state = ImeState {
             text_state: initial_state,
             client: Box::new(client),
             keyboard_type,
             action,
             text_manager,
             revision: 0,
             next_text_point_id: 0,
             text_points: HashMap::new(),
             keys_pressed: HashSet::new(),
         };
         LegacyIme(Arc::new(Mutex::new(state)))
     }

     pub fn downgrade(&self) -> Weak<Mutex<ImeState>> {
         Arc::downgrade(&self.0)
     }

     pub fn upgrade(weak: &Weak<Mutex<ImeState>>) -> Option<LegacyIme> {
         weak.upgrade().map(|arc| LegacyIme(arc))
     }

     /// Binds a `TextField` to this `LegacyIme`, replacing and unbinding any previous `TextField`.
     /// All requests from the request stream will be translated into requests for
     /// `InputMethodEditorClient`, and for events, vice-versa.
     /// Handles all state updates passed down the `InputMethodEditorRequestStream`.
     pub fn bind_ime(&self, mut stream: uii::InputMethodEditorRequestStream) {
         let self_clone = self.clone();
         let self_clone_2 = self.clone();
         fuchsia_async::Task::spawn(
             async move {
                 while let Some(msg) = stream
                     .try_next()
                     .await
                     .context("error reading value from IME request stream")?
                 {
                     self_clone
                         .handle_ime_message(msg)
                         .await
                         .unwrap_or_else(|e| tracing::warn!("error handling ime message: {:?}", e));
                 }
                 Ok(())
             }
             .unwrap_or_else(|e: anyhow::Error| tracing::error!("{:?}", e))
             .then(|()| {
                 async move {
                     // this runs when IME stream closes
                     // clone to ensure we only hold one lock at a time
                     let text_manager = self_clone_2.0.lock().await.text_manager.clone();
                     text_manager.update_keyboard_visibility_from_ime(&self_clone_2.0, false).await;
                 }
             }),
         )
         .detach();
     }

     /// Handles a request from the legancy IME API, an InputMethodEditorRequest.
     async fn handle_ime_message(&self, msg: uii::InputMethodEditorRequest) -> Result<()> {
         match msg {
             ImeReq::SetKeyboardType { keyboard_type, .. } => {
                 let mut state = self.0.lock().await;
                 state.keyboard_type = keyboard_type;
                 Ok(())
             }
             ImeReq::SetState { state, .. } => {
                 self.set_state(state).await;
                 Ok(())
             }
             ImeReq::InjectInput { .. } => {
                 Err(format_err!("InjectInput is deprecated, use DispatchKey3!"))
             }
             ImeReq::DispatchKey3 { event, responder, .. } => {
                 let key_event = {
                     let state = self.0.lock().await;
                     events::KeyEvent::new(&event, state.keys_pressed.clone())
                         .context("error converting key")?
                 };
                 self.inject_input(key_event).await?;
                 self.update_keys_pressed(&event).await?;
                 // False since legacy API doesn't support input handling.
                 // Handling here depends on the hardcoded order of input processing.
                 // This should be reworked in future IME design.
                 responder.send(false).context("error sending response for DispatchKey3")
             }
             ImeReq::Show { .. } => {
                 // clone to ensure we only hold one lock at a time
                 let text_manager = self.0.lock().await.text_manager.clone();
                 text_manager.show_keyboard().await;
                 Ok(())
             }
             ImeReq::Hide { .. } => {
                 // clone to ensure we only hold one lock at a time
                 let text_manager = self.0.lock().await.text_manager.clone();
                 text_manager.hide_keyboard().await;
                 Ok(())
             }
         }
     }

     /// Sets the internal state. Expects input_state to use codeunits; automatically
     /// converts to byte indices before storing.
     pub async fn set_state(&self, input_state: uii::TextInputState) {
         let mut state = self.0.lock().await;
         state.text_state = idx::text_state_codeunit_to_byte(input_state);
         // the old C++ IME implementation didn't call did_update_state here, so this second argument is false.
         state.increment_revision(false);
     }

     /// Forwards an event to the `InputMethodEditorClient`, by sending a state update that makes no
     /// changes alongside a `KeyboardEvent`. Note that this state update will always have no changes
     /// — if you'd like to send a change, use `inject_input()`.
     pub(crate) async fn forward_event(&self, event: &events::KeyEvent) -> Result<(), Error> {
         let mut state = self.0.lock().await;
         state.forward_event(event.clone())
     }

     /// Uses `ImeState`'s internal latin input method implementation to determine the edit
     /// corresponding to `keyboard_event`, and sends this as a state update to
     /// `InputMethodEditorClient`. This method can handle arrow keys to move selections, even with
     /// modifier keys implemented correctly. However, it does *not* send the actual key event to the
     /// client; for that, you should simultaneously call `forward_event()`.
     pub(crate) async fn inject_input(&self, key_event: events::KeyEvent) -> Result<(), Error> {
         let keyboard_event: uii::KeyboardEvent =
             key_event.try_into().context("error converting key event to keyboard event")?;

         let mut state = self.0.lock().await;

         if keyboard_event.phase == uii::KeyboardEventPhase::Pressed
             || keyboard_event.phase == uii::KeyboardEventPhase::Repeat
         {
             if keyboard_event.code_point != 0 {
                 state.type_keycode(keyboard_event.code_point);
                 state.increment_revision(true);
             } else {
                 match keyboard_event.hid_usage {
                     HID_USAGE_KEY_BACKSPACE => {
                         state.delete_backward();
                         state.increment_revision(true);
                     }
                     HID_USAGE_KEY_DELETE => {
                         state.delete_forward();
                         state.increment_revision(true);
                     }
                     HID_USAGE_KEY_LEFT => {
                         state.cursor_horizontal_move(keyboard_event.modifiers, false);
                         state.increment_revision(true);
                     }
                     HID_USAGE_KEY_RIGHT => {
                         state.cursor_horizontal_move(keyboard_event.modifiers, true);
                         state.increment_revision(true);
                     }
                     HID_USAGE_KEY_ENTER => match state.action {
                         // Pressing "Enter" inserts a newline when the input
                         // method is used to edit multi-line text. For other
                         // input actions, we report back to the
                         // client that it needs to perform some action (move
                         // focus, perform a search etc.).
                         uii::InputMethodAction::Newline => {
                             state.type_keycode('\n' as u32);
                             state.increment_revision(true);
                         }
                         _ => {
                             state
                                 .client
                                 .on_action(state.action)
                                 .context("error sending action to ImeClient")?;
                         }
                     },
                     _ => {
                         // Not an editing key, forward the event to clients.
                         state.increment_revision(true);
                     }
                 }
             }
         }
         Ok(())
     }

     /// Updates currently pressed keys.
     async fn update_keys_pressed(&self, event: &ui_input3::KeyEvent) -> Result<(), Error> {
         let type_ = event.type_.ok_or(format_err!("Expected type to be populated."))?;
         let key = event.key.ok_or(format_err!("Expected key to be populated."))?;
         let keys_pressed = &mut self.0.lock().await.keys_pressed;
         match type_ {
             ui_input3::KeyEventType::Sync | ui_input3::KeyEventType::Pressed => {
                 keys_pressed.insert(key);
             }
             ui_input3::KeyEventType::Cancel | ui_input3::KeyEventType::Released => {
                 keys_pressed.remove(&key);
             }
         };
         Ok(())
     }
 }
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//! This module contains an implementation of `LegacyIme` itself.

	use {
	anyhow::{format_err, Context, Error, Result},
	fidl_fuchsia_ui_input::{self as uii, InputMethodEditorRequest as ImeReq},
	fidl_fuchsia_ui_input3 as ui_input3,
	futures::{lock::Mutex, prelude::*},
	std::{
	collections::{HashMap, HashSet},
	sync::{Arc, Weak},
	},
	};

	use super::{
	state::ImeState, HID_USAGE_KEY_BACKSPACE, HID_USAGE_KEY_DELETE, HID_USAGE_KEY_ENTER,
	HID_USAGE_KEY_LEFT, HID_USAGE_KEY_RIGHT,
	};
	use crate::{index_convert as idx, keyboard::events, text_manager::TextManager};

	/// An input method provides edits and cursor updates to a text field. This Legacy Input Method
	/// provides edits to a text field over the legacy pair of interfaces `InputMethodEditor` and
	/// `InputMethodEditorClient`. It can provide these edits one of two ways:
	///
	/// 1. If `inject_input()` is called with a `KeyboardEvent`, `LegacyIme` contains an implementation
	/// of a QWERTY latin keyboard input method, and will send the appropriate edits to the text field.
	/// This can also handle arrow keys with modifiers to perform selection/caret movement.
	/// 2. If `bind_text_field()` is called with a `TextFieldRequestStream`, `LegacyIme` can serve the
	/// new `TextField` interface, translating edits or content requests from that into requests for the
	/// `InputMethodEditorClient`.
	#[derive(Clone)]
	pub struct LegacyIme(Arc<Mutex<ImeState>>);

	impl LegacyIme {
	pub fn new<I: 'static + uii::InputMethodEditorClientProxyInterface>(
	keyboard_type: uii::KeyboardType,
	action: uii::InputMethodAction,
	initial_state: uii::TextInputState,
	client: I,
	text_manager: TextManager,
	) -> LegacyIme {
	let state = ImeState {
	text_state: initial_state,
	client: Box::new(client),
	keyboard_type,
	action,
	text_manager,
	revision: 0,
	next_text_point_id: 0,
	text_points: HashMap::new(),
	keys_pressed: HashSet::new(),
	};
	LegacyIme(Arc::new(Mutex::new(state)))
	}

	pub fn downgrade(&self) -> Weak<Mutex<ImeState>> {
	Arc::downgrade(&self.0)
	}

	pub fn upgrade(weak: &Weak<Mutex<ImeState>>) -> Option<LegacyIme> {
	weak.upgrade().map(\|arc\| LegacyIme(arc))
	}

	/// Binds a `TextField` to this `LegacyIme`, replacing and unbinding any previous `TextField`.
	/// All requests from the request stream will be translated into requests for
	/// `InputMethodEditorClient`, and for events, vice-versa.
	/// Handles all state updates passed down the `InputMethodEditorRequestStream`.
	pub fn bind_ime(&self, mut stream: uii::InputMethodEditorRequestStream) {
	let self_clone = self.clone();
	let self_clone_2 = self.clone();
	fuchsia_async::Task::spawn(
	async move {
	while let Some(msg) = stream
	.try_next()
	.await
	.context("error reading value from IME request stream")?
	{
	self_clone
	.handle_ime_message(msg)
	.await
	.unwrap_or_else(\|e\| tracing::warn!("error handling ime message: {:?}", e));
	}
	Ok(())
	}
	.unwrap_or_else(\|e: anyhow::Error\| tracing::error!("{:?}", e))
	.then(\|()\| {
	async move {
	// this runs when IME stream closes
	// clone to ensure we only hold one lock at a time
	let text_manager = self_clone_2.0.lock().await.text_manager.clone();
	text_manager.update_keyboard_visibility_from_ime(&self_clone_2.0, false).await;
	}
	}),
	)
	.detach();
	}

	/// Handles a request from the legancy IME API, an InputMethodEditorRequest.
	async fn handle_ime_message(&self, msg: uii::InputMethodEditorRequest) -> Result<()> {
	match msg {
	ImeReq::SetKeyboardType { keyboard_type, .. } => {
	let mut state = self.0.lock().await;
	state.keyboard_type = keyboard_type;
	Ok(())
	}
	ImeReq::SetState { state, .. } => {
	self.set_state(state).await;
	Ok(())
	}
	ImeReq::InjectInput { .. } => {
	Err(format_err!("InjectInput is deprecated, use DispatchKey3!"))
	}
	ImeReq::DispatchKey3 { event, responder, .. } => {
	let key_event = {
	let state = self.0.lock().await;
	events::KeyEvent::new(&event, state.keys_pressed.clone())
	.context("error converting key")?
	};
	self.inject_input(key_event).await?;
	self.update_keys_pressed(&event).await?;
	// False since legacy API doesn't support input handling.
	// Handling here depends on the hardcoded order of input processing.
	// This should be reworked in future IME design.
	responder.send(false).context("error sending response for DispatchKey3")
	}
	ImeReq::Show { .. } => {
	// clone to ensure we only hold one lock at a time
	let text_manager = self.0.lock().await.text_manager.clone();
	text_manager.show_keyboard().await;
	Ok(())
	}
	ImeReq::Hide { .. } => {
	// clone to ensure we only hold one lock at a time
	let text_manager = self.0.lock().await.text_manager.clone();
	text_manager.hide_keyboard().await;
	Ok(())
	}
	}
	}

	/// Sets the internal state. Expects input_state to use codeunits; automatically
	/// converts to byte indices before storing.
	pub async fn set_state(&self, input_state: uii::TextInputState) {
	let mut state = self.0.lock().await;
	state.text_state = idx::text_state_codeunit_to_byte(input_state);
	// the old C++ IME implementation didn't call did_update_state here, so this second argument is false.
	state.increment_revision(false);
	}

	/// Forwards an event to the `InputMethodEditorClient`, by sending a state update that makes no
	/// changes alongside a `KeyboardEvent`. Note that this state update will always have no changes
	/// — if you'd like to send a change, use `inject_input()`.
	pub(crate) async fn forward_event(&self, event: &events::KeyEvent) -> Result<(), Error> {
	let mut state = self.0.lock().await;
	state.forward_event(event.clone())
	}

	/// Uses `ImeState`'s internal latin input method implementation to determine the edit
	/// corresponding to `keyboard_event`, and sends this as a state update to
	/// `InputMethodEditorClient`. This method can handle arrow keys to move selections, even with
	/// modifier keys implemented correctly. However, it does not send the actual key event to the
	/// client; for that, you should simultaneously call `forward_event()`.
	pub(crate) async fn inject_input(&self, key_event: events::KeyEvent) -> Result<(), Error> {
	let keyboard_event: uii::KeyboardEvent =
	key_event.try_into().context("error converting key event to keyboard event")?;

	let mut state = self.0.lock().await;

	if keyboard_event.phase == uii::KeyboardEventPhase::Pressed
	\|\| keyboard_event.phase == uii::KeyboardEventPhase::Repeat
	{
	if keyboard_event.code_point != 0 {
	state.type_keycode(keyboard_event.code_point);
	state.increment_revision(true);
	} else {
	match keyboard_event.hid_usage {
	HID_USAGE_KEY_BACKSPACE => {
	state.delete_backward();
	state.increment_revision(true);
	}
	HID_USAGE_KEY_DELETE => {
	state.delete_forward();
	state.increment_revision(true);
	}
	HID_USAGE_KEY_LEFT => {
	state.cursor_horizontal_move(keyboard_event.modifiers, false);
	state.increment_revision(true);
	}
	HID_USAGE_KEY_RIGHT => {
	state.cursor_horizontal_move(keyboard_event.modifiers, true);
	state.increment_revision(true);
	}
	HID_USAGE_KEY_ENTER => match state.action {
	// Pressing "Enter" inserts a newline when the input
	// method is used to edit multi-line text. For other
	// input actions, we report back to the
	// client that it needs to perform some action (move
	// focus, perform a search etc.).
	uii::InputMethodAction::Newline => {
	state.type_keycode('\n' as u32);
	state.increment_revision(true);
	}
	_ => {
	state
	.client
	.on_action(state.action)
	.context("error sending action to ImeClient")?;
	}
	},
	_ => {
	// Not an editing key, forward the event to clients.
	state.increment_revision(true);
	}
	}
	}
	}
	Ok(())
	}

	/// Updates currently pressed keys.
	async fn update_keys_pressed(&self, event: &ui_input3::KeyEvent) -> Result<(), Error> {
	let type_ = event.type_.ok_or(format_err!("Expected type to be populated."))?;
	let key = event.key.ok_or(format_err!("Expected key to be populated."))?;
	let keys_pressed = &mut self.0.lock().await.keys_pressed;
	match type_ {
	ui_input3::KeyEventType::Sync \| ui_input3::KeyEventType::Pressed => {
	keys_pressed.insert(key);
	}
	ui_input3::KeyEventType::Cancel \| ui_input3::KeyEventType::Released => {
	keys_pressed.remove(&key);
	}
	};
	Ok(())
	}
	}