io.flutter.embedding.android.KeyEmbedderResponder Class Reference

Inheritance diagram for io.flutter.embedding.android.KeyEmbedderResponder:

Public Member Functions
	KeyEmbedderResponder (BinaryMessenger messenger)
void	handleEvent ( @NonNull KeyEvent event, @NonNull OnKeyEventHandledCallback onKeyEventHandledCallback)
Map< Long, Long >	getPressedState ()
void	handleEvent ( @NonNull KeyEvent keyEvent, @NonNull OnKeyEventHandledCallback onKeyEventHandledCallback)

Package Functions
void	updatePressingState (@NonNull Long physicalKey, @Nullable Long logicalKey)
void	synchronizePressingKey (PressingGoal goal, boolean truePressed, long eventLogicalKey, long eventPhysicalKey, KeyEvent event, ArrayList< Runnable > postSynchronize)
void	synchronizeTogglingKey (TogglingGoal goal, boolean trueEnabled, long eventLogicalKey, KeyEvent event)

Detailed Description

A KeyboardManager.Responder of KeyboardManager that handles events by sending processed information in KeyData.

This class corresponds to the HardwareKeyboard API in the framework.

Definition at line 26 of file KeyEmbedderResponder.java.

Constructor & Destructor Documentation

KeyEmbedderResponder()

io.flutter.embedding.android.KeyEmbedderResponder.KeyEmbedderResponder ( BinaryMessenger  messenger )

inline

Definition at line 59 of file KeyEmbedderResponder.java.

                                                         {
    this.messenger = messenger;
    for (final TogglingGoal goal : KeyboardMap.getTogglingGoals()) {
      togglingGoals.put(goal.logicalKey, goal);
    }
  }

Member Function Documentation

getPressedState()

Map< Long, Long > io.flutter.embedding.android.KeyEmbedderResponder.getPressedState ( )

inline

Returns an unmodifiable view of the pressed state.

Returns

A map whose keys are physical keyboard key IDs and values are the corresponding logical keyboard key IDs.

Definition at line 445 of file KeyEmbedderResponder.java.

                                           {
    return Collections.unmodifiableMap(pressingRecords);
  }

handleEvent()

void io.flutter.embedding.android.KeyEmbedderResponder.handleEvent ( @NonNull KeyEvent  event, @NonNull OnKeyEventHandledCallback  onKeyEventHandledCallback  )

inline

Parses an Android key event, performs synchronization, and dispatches Flutter events through the messenger to the framework with the given callback.

At least one event will be dispatched. If there are no others, an empty event with 0 physical key and 0 logical key will be synthesized.

Parameters

event	The Android key event to be handled.
onKeyEventHandledCallback	the method to call when the framework has decided whether to handle this event. This callback will always be called once and only once. If there are no non-synthesized out of this event, this callback will be called during this method with true.

Implements io.flutter.embedding.android.KeyboardManager.Responder.

Definition at line 430 of file KeyEmbedderResponder.java.

                                                                                             {
    final boolean sentAny = handleEventImpl(event, onKeyEventHandledCallback);
    if (!sentAny) {
      synthesizeEvent(true, 0L, 0L, 0L);
      onKeyEventHandledCallback.onKeyEventHandled(true);
    }
  }

synchronizePressingKey()

void io.flutter.embedding.android.KeyEmbedderResponder.synchronizePressingKey ( PressingGoal  goal, boolean  truePressed, long  eventLogicalKey, long  eventPhysicalKey, KeyEvent  event, ArrayList< Runnable >  postSynchronize  )

inlinepackage

Definition at line 136 of file KeyEmbedderResponder.java.

                                           {
    // During an incoming event, there might be a synthesized Flutter event for each key of each
    // pressing goal, followed by an eventual main Flutter event.
    //
    //    NowState ---------------->  PreEventState --------------> -------------->TrueState
    //              PreSynchronize                       Event      PostSynchronize
    //
    // The goal of the synchronization algorithm is to derive a pre-event state that can satisfy the
    // true state (`truePressed`) after the event, and that requires as few synthesized events based
    // on the current state (`nowStates`) as possible.
    final boolean[] nowStates = new boolean[goal.keys.length];
    final Boolean[] preEventStates = new Boolean[goal.keys.length];
    boolean postEventAnyPressed = false;
    // 1. Find the current states of all keys.
    // 2. Derive the pre-event state of the event key (if applicable.)
    for (int keyIdx = 0; keyIdx < goal.keys.length; keyIdx += 1) {
      final KeyboardMap.KeyPair key = goal.keys[keyIdx];
      nowStates[keyIdx] = pressingRecords.containsKey(key.physicalKey);
      if (key.logicalKey == eventLogicalKey) {
        switch (getEventType(event)) {
          case kDown:
            preEventStates[keyIdx] = false;
            postEventAnyPressed = true;
            if (!truePressed) {
              postSynchronize.add(
                  () ->
                      synthesizeEvent(
                          false, key.logicalKey, eventPhysicalKey, event.getEventTime()));
            }
            break;
          case kUp:
            // Incoming event is an up. Although the previous state should be pressed, don't
            // synthesize a down event even if it's not. The later code will handle such cases by
            // skipping abrupt up events. Obviously don't synthesize up events either.
            preEventStates[keyIdx] = nowStates[keyIdx];
            break;
          case kRepeat:
            // Incoming event is repeat. The previous state can be either pressed or released. Don't
            // synthesize a down event here, or there will be a down event *and* a repeat event,
            // both of which have printable characters. Obviously don't synthesize up events either.
            if (!truePressed) {
              postSynchronize.add(
                  () ->
                      synthesizeEvent(
                          false, key.logicalKey, key.physicalKey, event.getEventTime()));
            }
            preEventStates[keyIdx] = nowStates[keyIdx];
            postEventAnyPressed = true;
            break;
        }
      } else {
        postEventAnyPressed = postEventAnyPressed || nowStates[keyIdx];
      }
    }
 
    // Fill the rest of the pre-event states to match the true state.
    if (truePressed) {
      // It is required that at least one key is pressed.
      for (int keyIdx = 0; keyIdx < goal.keys.length; keyIdx += 1) {
        if (preEventStates[keyIdx] != null) {
          continue;
        }
        if (postEventAnyPressed) {
          preEventStates[keyIdx] = nowStates[keyIdx];
        } else {
          preEventStates[keyIdx] = true;
          postEventAnyPressed = true;
        }
      }
      if (!postEventAnyPressed) {
        preEventStates[0] = true;
      }
    } else {
      for (int keyIdx = 0; keyIdx < goal.keys.length; keyIdx += 1) {
        if (preEventStates[keyIdx] != null) {
          continue;
        }
        preEventStates[keyIdx] = false;
      }
    }
 
    // Dispatch synthesized events for state differences.
    for (int keyIdx = 0; keyIdx < goal.keys.length; keyIdx += 1) {
      if (nowStates[keyIdx] != preEventStates[keyIdx]) {
        final KeyboardMap.KeyPair key = goal.keys[keyIdx];
        synthesizeEvent(
            preEventStates[keyIdx], key.logicalKey, key.physicalKey, event.getEventTime());
      }
    }
  }

synchronizeTogglingKey()

void io.flutter.embedding.android.KeyEmbedderResponder.synchronizeTogglingKey ( TogglingGoal  goal, boolean  trueEnabled, long  eventLogicalKey, KeyEvent  event  )

inlinepackage

Definition at line 246 of file KeyEmbedderResponder.java.

                                                                                    {
    if (goal.logicalKey == eventLogicalKey) {
      // Don't synthesize for self events, because the self events have weird metaStates on
      // ChromeOS.
      return;
    }
    if (goal.enabled != trueEnabled) {
      final boolean firstIsDown = !pressingRecords.containsKey(goal.physicalKey);
      if (firstIsDown) {
        goal.enabled = !goal.enabled;
      }
      synthesizeEvent(firstIsDown, goal.logicalKey, goal.physicalKey, event.getEventTime());
      if (!firstIsDown) {
        goal.enabled = !goal.enabled;
      }
      synthesizeEvent(!firstIsDown, goal.logicalKey, goal.physicalKey, event.getEventTime());
    }
  }

updatePressingState()

void io.flutter.embedding.android.KeyEmbedderResponder.updatePressingState ( @NonNull Long  physicalKey, @Nullable Long  logicalKey  )

inlinepackage

Definition at line 107 of file KeyEmbedderResponder.java.

                                                                                 {
    if (logicalKey != null) {
      final Long previousValue = pressingRecords.put(physicalKey, logicalKey);
      if (previousValue != null) {
        throw new AssertionError("The key was not empty");
      }
    } else {
      final Long previousValue = pressingRecords.remove(physicalKey);
      if (previousValue == null) {
        throw new AssertionError("The key was empty");
      }
    }
  }

---

The documentation for this class was generated from the following file:

• shell/platform/android/io/flutter/embedding/android/KeyEmbedderResponder.java