Package io.flutter.embedding.android

# Class KeyboardManager

java.lang.Object
io.flutter.embedding.android.KeyboardManager

All Implemented Interfaces:
  `KeyboardChannel.KeyboardMethodHandler`, `InputConnectionAdaptor.KeyboardDelegate`

public class KeyboardManager extends Object implements InputConnectionAdaptor.KeyboardDelegate, KeyboardChannel.KeyboardMethodHandler
Processes keyboard events and cooperate with `TextInputPlugin`.

Flutter uses asynchronous event handling to avoid blocking the UI thread, but Android requires that events are handled synchronously. So when the Android system sends new @{link KeyEvent} to Flutter, Flutter responds synchronously that the key has been handled so that it won't propagate to other components. It then uses "delayed event synthesis", where it sends the event to the framework, and if the framework responds that it has not handled the event, then this class synthesizes a new event to send to Android, without handling it this time.

Flutter processes an Android `KeyEvent` with several components, each can choose whether to handled the event, and only unhandled events can move to the next section.

- Keyboard: Dispatch to the `KeyboardManager.Responder`s simultaneously. After all responders have responded (asynchronously), the event is considered handled if any responders decide to handle.
- Text input: Events are sent to `TextInputPlugin`, processed synchronously with a result of whether it is handled.
- "Redispatch": If there's no currently focused text field in `TextInputPlugin`, or the text field does not handle the `KeyEvent` either, the `KeyEvent` will be sent back to the top of the activity's view hierachy, allowing it to be "redispatched". The `KeyboardManager` will remember this event and skip the identical event at the next encounter.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static class`
  `KeyboardManager.CharacterCombiner`
  Applies the given Unicode character from `KeyEvent.getUnicodeChar()` to a previously entered Unicode combining character and returns the combination of these characters if a combination exists.
  `static interface`
  `KeyboardManager.Responder`
  The interface for responding to a `KeyEvent` asynchronously.
  `static interface`
  `KeyboardManager.ViewDelegate`
  A set of interfaces that the `KeyboardManager` needs to interact with other components and the platform, and is typically implements by `FlutterView`.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected final KeyboardManager.Responder[]`
  `responders`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `KeyboardManager(KeyboardManager.ViewDelegate viewDelegate)`
  Construct a `KeyboardManager`.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `destroy()`
  `Map<Long,Long>`
  `getKeyboardState()`
  Returns an unmodifiable view of the pressed state.
  `boolean`
  `handleEvent(KeyEvent keyEvent)`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### responders

    protected final KeyboardManager.Responder[] responders

- ## Constructor Details

  - ### KeyboardManager

    public KeyboardManager(@NonNull KeyboardManager.ViewDelegate viewDelegate)
    Construct a `KeyboardManager`.
    Parameters:
      `viewDelegate` - provides a set of interfaces that the keyboard manager needs to interact with other components and the platform, and is typically implements by `FlutterView`.

- ## Method Details

  - ### handleEvent

    public boolean handleEvent(@NonNull KeyEvent keyEvent)
    Specified by:
      `handleEvent` in interface `InputConnectionAdaptor.KeyboardDelegate`

  - ### destroy

    public void destroy()

  - ### getKeyboardState

    public Map<Long,Long> getKeyboardState()
    Returns an unmodifiable view of the pressed state.
    Specified by:
      `getKeyboardState` in interface `KeyboardChannel.KeyboardMethodHandler`
    Returns:
      A map whose keys are physical keyboard key IDs and values are the corresponding logical keyboard key IDs.