io.flutter.plugin.editing.ListenableEditingState Class Reference

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

Classes
interface	EditingStateWatcher

Public Member Functions
	ListenableEditingState ( @Nullable TextInputChannel.TextEditState initialState, @NonNull View view)
ArrayList< TextEditingDelta >	extractBatchTextEditingDeltas ()
void	clearBatchDeltas ()
void	beginBatchEdit ()
void	endBatchEdit ()
void	setComposingRange (int composingStart, int composingEnd)
void	setEditingState (TextInputChannel.TextEditState newState)
void	addEditingStateListener (EditingStateWatcher listener)
void	removeEditingStateListener (EditingStateWatcher listener)
SpannableStringBuilder	replace (int start, int end, CharSequence tb, int tbstart, int tbend)
final int	getSelectionStart ()
final int	getSelectionEnd ()
final int	getComposingStart ()
final int	getComposingEnd ()
void	setSpan (Object what, int start, int end, int flags)
String	toString ()

Detailed Description

The current editing state (text, selection range, composing range) the text input plugin holds.

As the name implies, this class also notifies its listeners when the editing state changes. When there're ongoing batch edits, change notifications will be deferred until all batch edits end (i.e. when the outermost batch edit ends). Listeners added during a batch edit will always be notified when all batch edits end, even if there's no real change.

Adding/removing listeners or changing the editing state in a didChangeEditingState callback may cause unexpected behavior.

Definition at line 30 of file ListenableEditingState.java.

Constructor & Destructor Documentation

ListenableEditingState()

io.flutter.plugin.editing.ListenableEditingState.ListenableEditingState ( @Nullable TextInputChannel.TextEditState  initialState, @NonNull View  view  )

inline

Definition at line 60 of file ListenableEditingState.java.

                                                                                 {
    super();
 
    Editable self = this;
    mDummyConnection =
        new BaseInputConnection(view, true) {
          @Override
          public Editable getEditable() {
            return self;
          }
        };
 
    if (initialState != null) {
      setEditingState(initialState);
    }
  }

Member Function Documentation

addEditingStateListener()

void io.flutter.plugin.editing.ListenableEditingState.addEditingStateListener ( EditingStateWatcher  listener )

inline

Definition at line 171 of file ListenableEditingState.java.

                                                                    {
    if (mChangeNotificationDepth > 0) {
      Log.e(TAG, "adding a listener " + listener.toString() + " in a listener callback");
    }
    // It is possible for a listener to get added during a batch edit. When that happens we always
    // notify the new listeners.
    // This does not check if the listener is already in the list of existing listeners.
    if (mBatchEditNestDepth > 0) {
      Log.w(TAG, "a listener was added to EditingState while a batch edit was in progress");
      mPendingListeners.add(listener);
    } else {
      mListeners.add(listener);
    }
  }

beginBatchEdit()

void io.flutter.plugin.editing.ListenableEditingState.beginBatchEdit ( )

inline

Starts a new batch edit during which change notifications will be put on hold until all batch edits end.

Batch edits nest.

Definition at line 93 of file ListenableEditingState.java.

                               {
    mBatchEditNestDepth++;
    if (mChangeNotificationDepth > 0) {
      Log.e(TAG, "editing state should not be changed in a listener callback");
    }
    if (mBatchEditNestDepth == 1 && !mListeners.isEmpty()) {
      mTextWhenBeginBatchEdit = toString();
      mSelectionStartWhenBeginBatchEdit = getSelectionStart();
      mSelectionEndWhenBeginBatchEdit = getSelectionEnd();
      mComposingStartWhenBeginBatchEdit = getComposingStart();
      mComposingEndWhenBeginBatchEdit = getComposingEnd();
    }
  }

clearBatchDeltas()

void io.flutter.plugin.editing.ListenableEditingState.clearBatchDeltas ( )

inline

Definition at line 85 of file ListenableEditingState.java.

                                 {
    mBatchTextEditingDeltas.clear();
  }

endBatchEdit()

void io.flutter.plugin.editing.ListenableEditingState.endBatchEdit ( )

inline

Ends the current batch edit and flush pending change notifications if the current batch edit is not nested (i.e. it is the last ongoing batch edit).

Definition at line 109 of file ListenableEditingState.java.

                             {
    if (mBatchEditNestDepth == 0) {
      Log.e(TAG, "endBatchEdit called without a matching beginBatchEdit");
      return;
    }
    if (mBatchEditNestDepth == 1) {
      for (final EditingStateWatcher listener : mPendingListeners) {
        notifyListener(listener, true, true, true);
      }
 
      if (!mListeners.isEmpty()) {
        Log.v(TAG, "didFinishBatchEdit with " + String.valueOf(mListeners.size()) + " listener(s)");
        final boolean textChanged = !toString().equals(mTextWhenBeginBatchEdit);
        final boolean selectionChanged =
            mSelectionStartWhenBeginBatchEdit != getSelectionStart()
                || mSelectionEndWhenBeginBatchEdit != getSelectionEnd();
        final boolean composingRegionChanged =
            mComposingStartWhenBeginBatchEdit != getComposingStart()
                || mComposingEndWhenBeginBatchEdit != getComposingEnd();
 
        notifyListenersIfNeeded(textChanged, selectionChanged, composingRegionChanged);
      }
    }
 
    mListeners.addAll(mPendingListeners);
    mPendingListeners.clear();
    mBatchEditNestDepth--;
  }

extractBatchTextEditingDeltas()

ArrayList< TextEditingDelta > io.flutter.plugin.editing.ListenableEditingState.extractBatchTextEditingDeltas ( )

inline

Definition at line 78 of file ListenableEditingState.java.

                                                                     {
    ArrayList<TextEditingDelta> currentBatchDeltas =
        new ArrayList<TextEditingDelta>(mBatchTextEditingDeltas);
    mBatchTextEditingDeltas.clear();
    return currentBatchDeltas;
  }

getComposingEnd()

final int io.flutter.plugin.editing.ListenableEditingState.getComposingEnd ( )

inline

Definition at line 274 of file ListenableEditingState.java.

                                     {
    return BaseInputConnection.getComposingSpanEnd(this);
  }

getComposingStart()

final int io.flutter.plugin.editing.ListenableEditingState.getComposingStart ( )

inline

Definition at line 270 of file ListenableEditingState.java.

                                       {
    return BaseInputConnection.getComposingSpanStart(this);
  }

getSelectionEnd()

final int io.flutter.plugin.editing.ListenableEditingState.getSelectionEnd ( )

inline

Definition at line 266 of file ListenableEditingState.java.

                                     {
    return Selection.getSelectionEnd(this);
  }

getSelectionStart()

final int io.flutter.plugin.editing.ListenableEditingState.getSelectionStart ( )

inline

Definition at line 262 of file ListenableEditingState.java.

                                       {
    return Selection.getSelectionStart(this);
  }

removeEditingStateListener()

void io.flutter.plugin.editing.ListenableEditingState.removeEditingStateListener ( EditingStateWatcher  listener )

inline

Definition at line 186 of file ListenableEditingState.java.

                                                                       {
    if (mChangeNotificationDepth > 0) {
      Log.e(TAG, "removing a listener " + listener.toString() + " in a listener callback");
    }
    mListeners.remove(listener);
    if (mBatchEditNestDepth > 0) {
      mPendingListeners.remove(listener);
    }
  }

replace()

SpannableStringBuilder io.flutter.plugin.editing.ListenableEditingState.replace ( int  start, int  end, CharSequence  tb, int  tbstart, int  tbend  )

inline

Definition at line 197 of file ListenableEditingState.java.

                                                                   {
 
    if (mChangeNotificationDepth > 0) {
      Log.e(TAG, "editing state should not be changed in a listener callback");
    }
 
    final CharSequence oldText = toString();
 
    boolean textChanged = end - start != tbend - tbstart;
    for (int i = 0; i < end - start && !textChanged; i++) {
      textChanged |= charAt(start + i) != tb.charAt(tbstart + i);
    }
    if (textChanged) {
      mToStringCache = null;
    }
 
    final int selectionStart = getSelectionStart();
    final int selectionEnd = getSelectionEnd();
    final int composingStart = getComposingStart();
    final int composingEnd = getComposingEnd();
 
    final SpannableStringBuilder editable = super.replace(start, end, tb, tbstart, tbend);
    mBatchTextEditingDeltas.add(
        new TextEditingDelta(
            oldText,
            start,
            end,
            tb,
            getSelectionStart(),
            getSelectionEnd(),
            getComposingStart(),
            getComposingEnd()));
 
    if (mBatchEditNestDepth > 0) {
      return editable;
    }
 
    final boolean selectionChanged =
        getSelectionStart() != selectionStart || getSelectionEnd() != selectionEnd;
    final boolean composingRegionChanged =
        getComposingStart() != composingStart || getComposingEnd() != composingEnd;
    notifyListenersIfNeeded(textChanged, selectionChanged, composingRegionChanged);
    return editable;
  }

setComposingRange()

void io.flutter.plugin.editing.ListenableEditingState.setComposingRange ( int  composingStart, int  composingEnd  )

inline

Update the composing region of the current editing state.

If the range is invalid or empty, the current composing region will be removed.

Definition at line 141 of file ListenableEditingState.java.

                                                                      {
    if (composingStart < 0 || composingStart >= composingEnd) {
      BaseInputConnection.removeComposingSpans(this);
    } else {
      mDummyConnection.setComposingRegion(composingStart, composingEnd);
    }
  }

setEditingState()

void io.flutter.plugin.editing.ListenableEditingState.setEditingState ( TextInputChannel.TextEditState  newState )

inline

Called when the framework sends updates to the text input plugin.

This method will also update the composing region if it has changed.

Definition at line 152 of file ListenableEditingState.java.

                                                                       {
    beginBatchEdit();
    replace(0, length(), newState.text);
 
    if (newState.hasSelection()) {
      Selection.setSelection(this, newState.selectionStart, newState.selectionEnd);
    } else {
      Selection.removeSelection(this);
    }
 
    setComposingRange(newState.composingStart, newState.composingEnd);
 
    // Updates from the framework should not have a delta created for it as they have already been
    // applied on the framework side.
    clearBatchDeltas();
 
    endBatchEdit();
  }

setSpan()

void io.flutter.plugin.editing.ListenableEditingState.setSpan ( Object  what, int  start, int  end, int  flags  )

inline

Definition at line 279 of file ListenableEditingState.java.

                                                                  {
    super.setSpan(what, start, end, flags);
    // Setting a span does not involve mutating the text value in the editing state. Here we create
    // a non text update delta with any updated selection and composing regions.
    mBatchTextEditingDeltas.add(
        new TextEditingDelta(
            toString(),
            getSelectionStart(),
            getSelectionEnd(),
            getComposingStart(),
            getComposingEnd()));
  }

toString()

String io.flutter.plugin.editing.ListenableEditingState.toString ( )

inline

Definition at line 293 of file ListenableEditingState.java.

                           {
    return mToStringCache != null ? mToStringCache : (mToStringCache = super.toString());
  }

---

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

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