io.flutter.plugin.editing.TextInputPlugin Class Reference

Inheritance diagram for io.flutter.plugin.editing.TextInputPlugin:

Public Member Functions
	TextInputPlugin ( @NonNull View view, @NonNull TextInputChannel textInputChannel, @NonNull PlatformViewsController platformViewsController)
InputMethodManager	getInputMethodManager ()

Package Functions
Editable	getEditable ()
ImeSyncDeferringInsetsCallback	getImeSyncCallback ()
void	lockPlatformViewInputConnection ()
void	unlockPlatformViewInputConnection ()
void	destroy ()
InputConnection	createInputConnection ( @NonNull View view, @NonNull KeyboardManager keyboardManager, @NonNull EditorInfo outAttrs)
InputConnection	getLastInputConnection ()
void	clearPlatformViewClient (int platformViewId)
void	sendTextInputAppPrivateCommand (@NonNull String action, @NonNull Bundle data)
boolean	handleKeyEvent (@NonNull KeyEvent keyEvent)
void	didChangeEditingState (boolean textChanged, boolean selectionChanged, boolean composingRegionChanged)
void	onProvideAutofillVirtualStructure (@NonNull ViewStructure structure, int flags)
void	autofill (@NonNull SparseArray< AutofillValue > values)
void	showTextInput (View view)
void	setTextInputClient (int client, TextInputChannel.Configuration configuration)
void	setTextInputEditingState (View view, TextInputChannel.TextEditState state)
void	clearTextInputClient ()

Detailed Description

Android implementation of the text input plugin.

Definition at line 39 of file TextInputPlugin.java.

Constructor & Destructor Documentation

TextInputPlugin()

io.flutter.plugin.editing.TextInputPlugin.TextInputPlugin ( @NonNull View  view, @NonNull TextInputChannel  textInputChannel, @NonNull PlatformViewsController  platformViewsController  )

inline

Definition at line 66 of file TextInputPlugin.java.

                                                                {
    mView = view;
    // Create a default object.
    mEditable = new ListenableEditingState(null, mView);
    mImm = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
    if (Build.VERSION.SDK_INT >= API_LEVELS.API_26) {
      afm = view.getContext().getSystemService(AutofillManager.class);
    } else {
      afm = null;
    }
 
    // Sets up syncing ime insets with the framework, allowing
    // the Flutter view to grow and shrink to accommodate Android
    // controlled keyboard animations.
    if (Build.VERSION.SDK_INT >= API_LEVELS.API_30) {
      imeSyncCallback = new ImeSyncDeferringInsetsCallback(view);
      imeSyncCallback.install();
    }
 
    this.textInputChannel = textInputChannel;
    textInputChannel.setTextInputMethodHandler(
        new TextInputChannel.TextInputMethodHandler() {
          @Override
          public void show() {
            showTextInput(mView);
          }
 
          @Override
          public void hide() {
            if (inputTarget.type == InputTarget.Type.PHYSICAL_DISPLAY_PLATFORM_VIEW) {
              notifyViewExited();
            } else {
              hideTextInput(mView);
            }
          }
 
          @Override
          public void requestAutofill() {
            notifyViewEntered();
          }
 
          @Override
          public void finishAutofillContext(boolean shouldSave) {
            if (Build.VERSION.SDK_INT < API_LEVELS.API_26 || afm == null) {
              return;
            }
            if (shouldSave) {
              afm.commit();
            } else {
              afm.cancel();
            }
          }
 
          @Override
          public void setClient(
              int textInputClientId, TextInputChannel.Configuration configuration) {
            setTextInputClient(textInputClientId, configuration);
          }
 
          @Override
          public void setPlatformViewClient(int platformViewId, boolean usesVirtualDisplay) {
            setPlatformViewTextInputClient(platformViewId, usesVirtualDisplay);
          }
 
          @Override
          public void setEditingState(TextInputChannel.TextEditState editingState) {
            setTextInputEditingState(mView, editingState);
          }
 
          @Override
          public void setEditableSizeAndTransform(double width, double height, double[] transform) {
            saveEditableSizeAndTransform(width, height, transform);
          }
 
          @Override
          public void clearClient() {
            clearTextInputClient();
          }
 
          @Override
          public void sendAppPrivateCommand(String action, Bundle data) {
            sendTextInputAppPrivateCommand(action, data);
          }
        });
 
    textInputChannel.requestExistingInputState();
 
    this.platformViewsController = platformViewsController;
    this.platformViewsController.attachTextInputPlugin(this);
  }

Member Function Documentation

autofill()

void io.flutter.plugin.editing.TextInputPlugin.autofill ( @NonNull SparseArray< AutofillValue >  values )

inline

Definition at line 793 of file TextInputPlugin.java.

                                                                   {
    if (Build.VERSION.SDK_INT < API_LEVELS.API_26) {
      return;
    }
 
    if (configuration == null || autofillConfiguration == null || configuration.autofill == null) {
      return;
    }
 
    final TextInputChannel.Configuration.Autofill currentAutofill = configuration.autofill;
    final HashMap<String, TextInputChannel.TextEditState> editingValues = new HashMap<>();
    for (int i = 0; i < values.size(); i++) {
      int virtualId = values.keyAt(i);
 
      final TextInputChannel.Configuration config = autofillConfiguration.get(virtualId);
      if (config == null || config.autofill == null) {
        continue;
      }
 
      final TextInputChannel.Configuration.Autofill autofill = config.autofill;
      final String value = values.valueAt(i).getTextValue().toString();
      final TextInputChannel.TextEditState newState =
          new TextInputChannel.TextEditState(value, value.length(), value.length(), -1, -1);
 
      if (autofill.uniqueIdentifier.equals(currentAutofill.uniqueIdentifier)) {
        // Autofilling the current client is the same as handling user input
        // from the virtual keyboard. Setting the editable to newState and an
        // update will be sent to the framework.
        mEditable.setEditingState(newState);
      } else {
        editingValues.put(autofill.uniqueIdentifier, newState);
      }
    }
    textInputChannel.updateEditingStateWithTag(inputTarget.id, editingValues);
  }

clearPlatformViewClient()

void io.flutter.plugin.editing.TextInputPlugin.clearPlatformViewClient ( int  platformViewId )

inline

Clears a platform view text input client if it is the current input target.

This is called when a platform view is disposed to make sure we're not hanging to a stale input connection.

Definition at line 365 of file TextInputPlugin.java.

                                                          {
    if ((inputTarget.type == InputTarget.Type.VIRTUAL_DISPLAY_PLATFORM_VIEW
            || inputTarget.type == InputTarget.Type.PHYSICAL_DISPLAY_PLATFORM_VIEW)
        && inputTarget.id == platformViewId) {
      inputTarget = new InputTarget(InputTarget.Type.NO_TARGET, 0);
      notifyViewExited();
      mImm.hideSoftInputFromWindow(mView.getApplicationWindowToken(), 0);
      mImm.restartInput(mView);
      mRestartInputPending = false;
    }
  }

clearTextInputClient()

void io.flutter.plugin.editing.TextInputPlugin.clearTextInputClient ( )

inlinepackage

Definition at line 529 of file TextInputPlugin.java.

                              {
    if (inputTarget.type == InputTarget.Type.VIRTUAL_DISPLAY_PLATFORM_VIEW) {
      // This only applies to platform views that use a virtual display.
      // Focus changes in the framework tree have no guarantees on the order focus nodes are
      // notified. A node that lost focus may be notified before or after a node that gained focus.
      // When moving the focus from a Flutter text field to an AndroidView, it is possible that the
      // Flutter text field's focus node will be notified that it lost focus after the AndroidView
      // was notified that it gained focus. When this happens the text field will send a
      // clearTextInput command which we ignore.
      // By doing this we prevent the framework from clearing a platform view input client (the only
      // way to do so is to set a new framework text client). I don't see an obvious use case for
      // "clearing" a platform view's text input client, and it may be error prone as we don't know
      // how the platform view manages the input connection and we probably shouldn't interfere.
      // If we ever want to allow the framework to clear a platform view text client we should
      // probably consider changing the focus manager such that focus nodes that lost focus are
      // notified before focus nodes that gained focus as part of the same focus event.
      return;
    }
    mEditable.removeEditingStateListener(this);
    notifyViewExited();
    configuration = null;
    updateAutofillConfigurationIfNeeded(null);
    inputTarget = new InputTarget(InputTarget.Type.NO_TARGET, 0);
    unlockPlatformViewInputConnection();
    lastClientRect = null;
 
    // Call restartInput to reset IME internal states. Otherwise some IMEs (Gboard for instance)
    // keep reacting based on the previous input configuration until a new configuration is set.
    mImm.restartInput(mView);
  }

createInputConnection()

InputConnection io.flutter.plugin.editing.TextInputPlugin.createInputConnection ( @NonNull View  view, @NonNull KeyboardManager  keyboardManager, @NonNull EditorInfo  outAttrs  )

inline

Definition at line 285 of file TextInputPlugin.java.

                                                                                                  {
    if (inputTarget.type == InputTarget.Type.NO_TARGET) {
      lastInputConnection = null;
      return null;
    }
 
    if (inputTarget.type == InputTarget.Type.PHYSICAL_DISPLAY_PLATFORM_VIEW) {
      return null;
    }
 
    if (inputTarget.type == InputTarget.Type.VIRTUAL_DISPLAY_PLATFORM_VIEW) {
      if (isInputConnectionLocked) {
        return lastInputConnection;
      }
      lastInputConnection =
          platformViewsController
              .getPlatformViewById(inputTarget.id)
              .onCreateInputConnection(outAttrs);
      return lastInputConnection;
    }
 
    outAttrs.inputType =
        inputTypeFromTextInputType(
            configuration.inputType,
            configuration.obscureText,
            configuration.autocorrect,
            configuration.enableSuggestions,
            configuration.enableIMEPersonalizedLearning,
            configuration.textCapitalization);
    outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN;
 
    if (Build.VERSION.SDK_INT >= API_LEVELS.API_26
        && !configuration.enableIMEPersonalizedLearning) {
      outAttrs.imeOptions |= EditorInfo.IME_FLAG_NO_PERSONALIZED_LEARNING;
    }
 
    int enterAction;
    if (configuration.inputAction == null) {
      // If an explicit input action isn't set, then default to none for multi-line fields
      // and done for single line fields.
      enterAction =
          (InputType.TYPE_TEXT_FLAG_MULTI_LINE & outAttrs.inputType) != 0
              ? EditorInfo.IME_ACTION_NONE
              : EditorInfo.IME_ACTION_DONE;
    } else {
      enterAction = configuration.inputAction;
    }
    if (configuration.actionLabel != null) {
      outAttrs.actionLabel = configuration.actionLabel;
      outAttrs.actionId = enterAction;
    }
    outAttrs.imeOptions |= enterAction;
 
    if (configuration.contentCommitMimeTypes != null) {
      String[] imgTypeString = configuration.contentCommitMimeTypes;
      EditorInfoCompat.setContentMimeTypes(outAttrs, imgTypeString);
    }
 
    InputConnectionAdaptor connection =
        new InputConnectionAdaptor(
            view, inputTarget.id, textInputChannel, keyboardManager, mEditable, outAttrs);
    outAttrs.initialSelStart = mEditable.getSelectionStart();
    outAttrs.initialSelEnd = mEditable.getSelectionEnd();
 
    lastInputConnection = connection;
    return lastInputConnection;
  }

destroy()

void io.flutter.plugin.editing.TextInputPlugin.destroy ( )

inline

Detaches the text input plugin from the platform views controller.

The TextInputPlugin instance should not be used after calling this.

Definition at line 211 of file TextInputPlugin.java.

                        {
    platformViewsController.detachTextInputPlugin();
    textInputChannel.setTextInputMethodHandler(null);
    notifyViewExited();
    mEditable.removeEditingStateListener(this);
    if (imeSyncCallback != null) {
      imeSyncCallback.remove();
    }
  }

didChangeEditingState()

void io.flutter.plugin.editing.TextInputPlugin.didChangeEditingState ( boolean  textChanged, boolean  selectionChanged, boolean  composingRegionChanged  )

inline

Implements io.flutter.plugin.editing.ListenableEditingState.EditingStateWatcher.

Definition at line 607 of file TextInputPlugin.java.

                                                                                     {
    if (textChanged) {
      // Notify the autofill manager of the value change.
      notifyValueChanged(mEditable.toString());
    }
 
    final int selectionStart = mEditable.getSelectionStart();
    final int selectionEnd = mEditable.getSelectionEnd();
    final int composingStart = mEditable.getComposingStart();
    final int composingEnd = mEditable.getComposingEnd();
 
    final ArrayList<TextEditingDelta> batchTextEditingDeltas =
        mEditable.extractBatchTextEditingDeltas();
    final boolean skipFrameworkUpdate =
        // The framework needs to send its editing state first.
        mLastKnownFrameworkTextEditingState == null
            || (mEditable.toString().equals(mLastKnownFrameworkTextEditingState.text)
                && selectionStart == mLastKnownFrameworkTextEditingState.selectionStart
                && selectionEnd == mLastKnownFrameworkTextEditingState.selectionEnd
                && composingStart == mLastKnownFrameworkTextEditingState.composingStart
                && composingEnd == mLastKnownFrameworkTextEditingState.composingEnd);
    if (!skipFrameworkUpdate) {
      Log.v(TAG, "send EditingState to flutter: " + mEditable.toString());
 
      if (configuration.enableDeltaModel) {
        textInputChannel.updateEditingStateWithDeltas(inputTarget.id, batchTextEditingDeltas);
        mEditable.clearBatchDeltas();
      } else {
        textInputChannel.updateEditingState(
            inputTarget.id,
            mEditable.toString(),
            selectionStart,
            selectionEnd,
            composingStart,
            composingEnd);
      }
      mLastKnownFrameworkTextEditingState =
          new TextEditState(
              mEditable.toString(), selectionStart, selectionEnd, composingStart, composingEnd);
    } else {
      // Don't accumulate deltas if they are not sent to the framework.
      mEditable.clearBatchDeltas();
    }
  }

getEditable()

Editable io.flutter.plugin.editing.TextInputPlugin.getEditable ( )

inlinepackage

Definition at line 166 of file TextInputPlugin.java.

                         {
    return mEditable;
  }

getImeSyncCallback()

ImeSyncDeferringInsetsCallback io.flutter.plugin.editing.TextInputPlugin.getImeSyncCallback ( )

inlinepackage

Definition at line 171 of file TextInputPlugin.java.

                                                      {
    return imeSyncCallback;
  }

getInputMethodManager()

InputMethodManager io.flutter.plugin.editing.TextInputPlugin.getInputMethodManager ( )

inline

Definition at line 161 of file TextInputPlugin.java.

                                                    {
    return mImm;
  }

getLastInputConnection()

InputConnection io.flutter.plugin.editing.TextInputPlugin.getLastInputConnection ( )

inline

Definition at line 355 of file TextInputPlugin.java.

                                                  {
    return lastInputConnection;
  }

handleKeyEvent()

boolean io.flutter.plugin.editing.TextInputPlugin.handleKeyEvent ( @NonNull KeyEvent  keyEvent )

inline

Definition at line 588 of file TextInputPlugin.java.

                                                            {
    if (!getInputMethodManager().isAcceptingText() || lastInputConnection == null) {
      return false;
    }
 
    // Send the KeyEvent as an IME KeyEvent. If the input connection is an
    // InputConnectionAdaptor then call its handleKeyEvent method (because
    // this method will be called by the keyboard manager, and
    // InputConnectionAdaptor#sendKeyEvent forwards the key event back to the
    // keyboard manager).
    return (lastInputConnection instanceof InputConnectionAdaptor)
        ? ((InputConnectionAdaptor) lastInputConnection).handleKeyEvent(keyEvent)
        : lastInputConnection.sendKeyEvent(keyEvent);
  }

lockPlatformViewInputConnection()

void io.flutter.plugin.editing.TextInputPlugin.lockPlatformViewInputConnection ( )

inline

Use the current platform view input connection until unlockPlatformViewInputConnection is called.

The current input connection instance is cached and any following call tolink createInputConnection} returns the cached connection until unlockPlatformViewInputConnection is called.

This is a no-op if the current input target isn't a platform view.

This is used to preserve an input connection when moving a platform view from one virtual display to another.

Definition at line 188 of file TextInputPlugin.java.

                                                {
    if (inputTarget.type == InputTarget.Type.VIRTUAL_DISPLAY_PLATFORM_VIEW) {
      isInputConnectionLocked = true;
    }
  }

onProvideAutofillVirtualStructure()

void io.flutter.plugin.editing.TextInputPlugin.onProvideAutofillVirtualStructure ( @NonNull ViewStructure  structure, int  flags  )

inline

Definition at line 745 of file TextInputPlugin.java.

                                                                                             {
    if (Build.VERSION.SDK_INT < API_LEVELS.API_26 || !needsAutofill()) {
      return;
    }
 
    final String triggerIdentifier = configuration.autofill.uniqueIdentifier;
    final AutofillId parentId = structure.getAutofillId();
    for (int i = 0; i < autofillConfiguration.size(); i++) {
      final int autofillId = autofillConfiguration.keyAt(i);
      final TextInputChannel.Configuration config = autofillConfiguration.valueAt(i);
      final TextInputChannel.Configuration.Autofill autofill = config.autofill;
      if (autofill == null) {
        continue;
      }
 
      structure.addChildCount(1);
      final ViewStructure child = structure.newChild(i);
      child.setAutofillId(parentId, autofillId);
      // Don't set hints when there's none.
      // See https://github.com/flutter/flutter/issues/98505.
      if (autofill.hints.length > 0) {
        child.setAutofillHints(autofill.hints);
      }
      child.setAutofillType(View.AUTOFILL_TYPE_TEXT);
      child.setVisibility(View.VISIBLE);
      if (autofill.hintText != null) {
        child.setHint(autofill.hintText);
      }
 
      // For some autofill services, only visible input fields are eligible for autofill.
      // Reports the real size of the child if it's the current client, or 1x1 if we don't
      // know the real dimensions of the child.
      if (triggerIdentifier.hashCode() == autofillId && lastClientRect != null) {
        child.setDimens(
            lastClientRect.left,
            lastClientRect.top,
            0,
            0,
            lastClientRect.width(),
            lastClientRect.height());
        child.setAutofillValue(AutofillValue.forText(mEditable));
      } else {
        child.setDimens(0, 0, 0, 0, 1, 1);
        child.setAutofillValue(AutofillValue.forText(autofill.editState.text));
      }
    }
  }

sendTextInputAppPrivateCommand()

void io.flutter.plugin.editing.TextInputPlugin.sendTextInputAppPrivateCommand ( @NonNull String  action, @NonNull Bundle  data  )

inline

Definition at line 377 of file TextInputPlugin.java.

                                                                                           {
    mImm.sendAppPrivateCommand(mView, action, data);
  }

setTextInputClient()

void io.flutter.plugin.editing.TextInputPlugin.setTextInputClient ( int  client, TextInputChannel.Configuration  configuration  )

inlinepackage

Definition at line 405 of file TextInputPlugin.java.

                                                                                    {
    // Call notifyViewExited on the previous field.
    notifyViewExited();
    this.configuration = configuration;
    inputTarget = new InputTarget(InputTarget.Type.FRAMEWORK_CLIENT, client);
 
    mEditable.removeEditingStateListener(this);
    mEditable =
        new ListenableEditingState(
            configuration.autofill != null ? configuration.autofill.editState : null, mView);
    updateAutofillConfigurationIfNeeded(configuration);
 
    // setTextInputClient will be followed by a call to setTextInputEditingState.
    // Do a restartInput at that time.
    mRestartInputPending = true;
    unlockPlatformViewInputConnection();
    lastClientRect = null;
    mEditable.addEditingStateListener(this);
  }

setTextInputEditingState()

void io.flutter.plugin.editing.TextInputPlugin.setTextInputEditingState ( View  view, TextInputChannel.TextEditState  state  )

inlinepackage

Definition at line 460 of file TextInputPlugin.java.

                                                                                 {
    if (!mRestartInputPending
        && mLastKnownFrameworkTextEditingState != null
        && mLastKnownFrameworkTextEditingState.hasComposing()) {
      // Also restart input if the framework (or the developer) decides to
      // change the composing region by itself (which is discouraged). Many IMEs
      // don't expect editors to commit composing text, so a restart is needed
      // to reset their internal states.
      mRestartInputPending = composingChanged(mLastKnownFrameworkTextEditingState, state);
      if (mRestartInputPending) {
        Log.i(TAG, "Composing region changed by the framework. Restarting the input method.");
      }
    }
 
    mLastKnownFrameworkTextEditingState = state;
    mEditable.setEditingState(state);
 
    // Restart if needed. Restarting will also update the selection.
    if (mRestartInputPending) {
      mImm.restartInput(view);
      mRestartInputPending = false;
    }
  }

showTextInput()

void io.flutter.plugin.editing.TextInputPlugin.showTextInput ( View  view )

inlinepackage

Definition at line 382 of file TextInputPlugin.java.

                                {
    if (configuration == null
        || configuration.inputType == null
        || configuration.inputType.type != TextInputChannel.TextInputType.NONE) {
      view.requestFocus();
      mImm.showSoftInput(view, 0);
    } else {
      hideTextInput(view);
    }
  }

unlockPlatformViewInputConnection()

void io.flutter.plugin.editing.TextInputPlugin.unlockPlatformViewInputConnection ( )

inline

Unlocks the input connection.

See also:link lockPlatformViewInputConnection}.

Definition at line 199 of file TextInputPlugin.java.

                                                  {
    if (inputTarget.type == InputTarget.Type.VIRTUAL_DISPLAY_PLATFORM_VIEW) {
      isInputConnectionLocked = false;
    }
  }

---

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

• shell/platform/android/io/flutter/plugin/editing/TextInputPlugin.java