The Tor Browser: comparison mobile/android/base/toolbar/ToolbarEditText.java

--1:000000000000
+:c16fb8a76082
+/* -*- Mode: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*-
+* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+package org.mozilla.gecko.toolbar;
+import org.mozilla.gecko.R;
+import org.mozilla.gecko.toolbar.BrowserToolbar.OnCommitListener;
+import org.mozilla.gecko.toolbar.BrowserToolbar.OnDismissListener;
+import org.mozilla.gecko.toolbar.BrowserToolbar.OnFilterListener;
+import org.mozilla.gecko.CustomEditText;
+import org.mozilla.gecko.CustomEditText.OnKeyPreImeListener;
+import org.mozilla.gecko.InputMethods;
+import org.mozilla.gecko.util.GamepadUtils;
+import org.mozilla.gecko.util.StringUtils;
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Editable;
+import android.text.InputType;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnKeyListener;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputMethodManager;
+/**
+* {@code ToolbarEditText} is the text entry used when the toolbar
+* is in edit state. It handles all the necessary input method machinery
+* as well as the tracking of different text types (empty, search, or url).
+* It's meant to be owned by {@code ToolbarEditLayout}.
+*/
+public class ToolbarEditText extends CustomEditText
+implements AutocompleteHandler {
+private static final String LOGTAG = "GeckoToolbarEditText";
+// Used to track the current type of content in the
+// text entry so that ToolbarEditLayout can update its
+// state accordingly.
+enum TextType {
+EMPTY,
+SEARCH_QUERY,
+URL
+}
+interface OnTextTypeChangeListener {
+public void onTextTypeChange(ToolbarEditText editText, TextType textType);
+}
+private final Context mContext;
+// Type of the URL bar go/search button
+private TextType mToolbarTextType;
+// Type of the keyboard go/search button (cannot be EMPTY)
+private TextType mKeyboardTextType;
+private OnCommitListener mCommitListener;
+private OnDismissListener mDismissListener;
+private OnFilterListener mFilterListener;
+private OnTextTypeChangeListener mTextTypeListener;
+// The previous autocomplete result returned to us
+private String mAutoCompleteResult = "";
+// The user typed part of the autocomplete result
+private String mAutoCompletePrefix = null;
+private boolean mDelayRestartInput;
+public ToolbarEditText(Context context, AttributeSet attrs) {
+super(context, attrs);
+mContext = context;
+mToolbarTextType = TextType.EMPTY;
+mKeyboardTextType = TextType.URL;
+}
+void setOnCommitListener(OnCommitListener listener) {
+mCommitListener = listener;
+}
+void setOnDismissListener(OnDismissListener listener) {
+mDismissListener = listener;
+}
+void setOnFilterListener(OnFilterListener listener) {
+mFilterListener = listener;
+}
+void setOnTextTypeChangeListener(OnTextTypeChangeListener listener) {
+mTextTypeListener = listener;
+}
+@Override
+public void onAttachedToWindow() {
+setOnKeyListener(new KeyListener());
+setOnKeyPreImeListener(new KeyPreImeListener());
+addTextChangedListener(new TextChangeListener());
+}
+@Override
+public void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
+super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+if (gainFocus) {
+resetAutocompleteState();
+return;
+}
+InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
+try {
+imm.hideSoftInputFromWindow(getWindowToken(), 0);
+} catch (NullPointerException e) {
+Log.e(LOGTAG, "InputMethodManagerService, why are you throwing"
++ " a NullPointerException? See bug 782096", e);
+}
+}
+// Return early if we're backspacing through the string, or
+// have no autocomplete results
+@Override
+public final void onAutocomplete(final String result) {
+if (!isEnabled()) {
+return;
+}
+final String text = getText().toString();
+if (result == null) {
+mAutoCompleteResult = "";
+return;
+}
+if (!result.startsWith(text) || text.equals(result)) {
+return;
+}
+mAutoCompleteResult = result;
+getText().append(result.substring(text.length()));
+setSelection(text.length(), result.length());
+}
+@Override
+public void setEnabled(boolean enabled) {
+super.setEnabled(enabled);
+updateTextTypeFromText(getText().toString());
+}
+private void resetAutocompleteState() {
+mAutoCompleteResult = "";
+mAutoCompletePrefix = null;
+}
+private void updateKeyboardInputType() {
+// If the user enters a space, then we know they are entering
+// search terms, not a URL. We can then switch to text mode so,
+//   1) the IME auto-inserts spaces between words
+//   2) the IME doesn't reset input keyboard to Latin keyboard.
+final String text = getText().toString();
+final int currentInputType = getInputType();
+final int newInputType = StringUtils.isSearchQuery(text, false)
+? (currentInputType & ~InputType.TYPE_TEXT_VARIATION_URI) // Text mode
+: (currentInputType | InputType.TYPE_TEXT_VARIATION_URI); // URL mode
+if (newInputType != currentInputType) {
+setRawInputType(newInputType);
+}
+}
+private static boolean hasCompositionString(Editable content) {
+Object[] spans = content.getSpans(0, content.length(), Object.class);
+if (spans != null) {
+for (Object span : spans) {
+if ((content.getSpanFlags(span) & Spanned.SPAN_COMPOSING) != 0) {
+// Found composition string.
+return true;
+}
+}
+}
+return false;
+}
+private void setTextType(TextType textType) {
+mToolbarTextType = textType;
+if (textType != TextType.EMPTY) {
+mKeyboardTextType = textType;
+}
+if (mTextTypeListener != null) {
+mTextTypeListener.onTextTypeChange(this, textType);
+}
+}
+private void updateTextTypeFromText(String text) {
+if (text.length() == 0) {
+setTextType(TextType.EMPTY);
+return;
+}
+if (InputMethods.shouldDisableUrlBarUpdate(mContext)) {
+// Set button type to match the previous keyboard type
+setTextType(mKeyboardTextType);
+return;
+}
+final int actionBits = getImeOptions() & EditorInfo.IME_MASK_ACTION;
+final int imeAction;
+if (StringUtils.isSearchQuery(text, actionBits == EditorInfo.IME_ACTION_SEARCH)) {
+imeAction = EditorInfo.IME_ACTION_SEARCH;
+} else {
+imeAction = EditorInfo.IME_ACTION_GO;
+}
+InputMethodManager imm = InputMethods.getInputMethodManager(mContext);
+if (imm == null) {
+return;
+}
+boolean restartInput = false;
+if (actionBits != imeAction) {
+int optionBits = getImeOptions() & ~EditorInfo.IME_MASK_ACTION;
+setImeOptions(optionBits | imeAction);
+mDelayRestartInput = (imeAction == EditorInfo.IME_ACTION_GO) &&
+(InputMethods.shouldDelayUrlBarUpdate(mContext));
+if (!mDelayRestartInput) {
+restartInput = true;
+}
+} else if (mDelayRestartInput) {
+// Only call delayed restartInput when actionBits == imeAction
+// so if there are two restarts in a row, the first restarts will
+// be discarded and the second restart will be properly delayed
+mDelayRestartInput = false;
+restartInput = true;
+}
+if (!restartInput) {
+// If the text content was previously empty, the toolbar text type
+// is empty as well. Since the keyboard text type cannot be empty,
+// the two text types are now inconsistent. Reset the toolbar text
+// type here to the keyboard text type to ensure consistency.
+setTextType(mKeyboardTextType);
+return;
+}
+updateKeyboardInputType();
+imm.restartInput(ToolbarEditText.this);
+setTextType(imeAction == EditorInfo.IME_ACTION_GO ?
+TextType.URL : TextType.SEARCH_QUERY);
+}
+private class TextChangeListener implements TextWatcher {
+@Override
+public void afterTextChanged(final Editable s) {
+if (!isEnabled()) {
+return;
+}
+final String text = s.toString();
+boolean useHandler = false;
+boolean reuseAutocomplete = false;
+if (!hasCompositionString(s) && !StringUtils.isSearchQuery(text, false)) {
+useHandler = true;
+// If you're hitting backspace (the string is getting smaller
+// or is unchanged), don't autocomplete.
+if (mAutoCompletePrefix != null && (mAutoCompletePrefix.length() >= text.length())) {
+useHandler = false;
+} else if (mAutoCompleteResult != null && mAutoCompleteResult.startsWith(text)) {
+// If this text already matches our autocomplete text, autocomplete likely
+// won't change. Just reuse the old autocomplete value.
+useHandler = false;
+reuseAutocomplete = true;
+}
+}
+// If this is the autocomplete text being set, don't run the filter.
+if (TextUtils.isEmpty(mAutoCompleteResult) || !mAutoCompleteResult.equals(text)) {
+if (mFilterListener != null) {
+mFilterListener.onFilter(text, useHandler ? ToolbarEditText.this : null);
+}
+mAutoCompletePrefix = text;
+if (reuseAutocomplete) {
+onAutocomplete(mAutoCompleteResult);
+}
+}
+// If the edit text has a composition string, don't call updateGoButton().
+// That method resets IME and composition state will be broken.
+if (!hasCompositionString(s) || InputMethods.isGestureKeyboard(mContext)) {
+updateTextTypeFromText(text);
+}
+}
+@Override
+public void beforeTextChanged(CharSequence s, int start, int count,
+int after) {
+// do nothing
+}
+@Override
+public void onTextChanged(CharSequence s, int start, int before,
+int count) {
+// do nothing
+}
+}
+private class KeyPreImeListener implements OnKeyPreImeListener {
+@Override
+public boolean onKeyPreIme(View v, int keyCode, KeyEvent event) {
+// We only want to process one event per tap
+if (event.getAction() != KeyEvent.ACTION_DOWN) {
+return false;
+}
+if (keyCode == KeyEvent.KEYCODE_ENTER) {
+// If the edit text has a composition string, don't submit the text yet.
+// ENTER is needed to commit the composition string.
+final Editable content = getText();
+if (!hasCompositionString(content)) {
+if (mCommitListener != null) {
+mCommitListener.onCommit();
+}
+return true;
+}
+}
+if (keyCode == KeyEvent.KEYCODE_BACK) {
+// Drop the virtual keyboard.
+clearFocus();
+return true;
+}
+return false;
+}
+}
+private class KeyListener implements View.OnKeyListener {
+@Override
+public boolean onKey(View v, int keyCode, KeyEvent event) {
+if (keyCode == KeyEvent.KEYCODE_ENTER || GamepadUtils.isActionKey(event)) {
+if (event.getAction() != KeyEvent.ACTION_DOWN) {
+return true;
+}
+if (mCommitListener != null) {
+mCommitListener.onCommit();
+}
+return true;
+} else if (GamepadUtils.isBackKey(event)) {
+if (mDismissListener != null) {
+mDismissListener.onDismiss();
+}
+return true;
+}
+return false;
+}
+}
+}

The Tor Browser / file comparison

comparison: mobile/android/base/toolbar/ToolbarEditText.java

mobile/android/base/toolbar/ToolbarEditText.java