nyancrimew
/
LatinIME
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add calls to stub for API to consume gesture data. 

Bug: 17400259
Change-Id: Ib3511afffe1d14662e7dd14611f384689516e664
main
David Faden 2014-09-04 13:42:10 -07:00 committed by Jean Chalard
parent 61a1e46dd1
commit c92c883fdf
9 changed files with 306 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
java-overridable/src/com/android/inputmethod/latin/touchinputconsumer/GestureConsumer.java Normal file
View File

@ -0,0 +1,66 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.inputmethod.latin.touchinputconsumer;
import android.view.inputmethod.EditorInfo;
import com.android.inputmethod.keyboard.Keyboard;
import com.android.inputmethod.latin.InputPointers;
import com.android.inputmethod.latin.SuggestedWords;
import com.android.inputmethod.latin.inputlogic.PrivateCommandPerformer;
import java.util.List;
import java.util.Locale;
/**
* Stub for GestureConsumer.
* <br>
* The methods of this class should only be called from a single thread, e.g.,
* the UI Thread.
*/
public class GestureConsumer {
public static final GestureConsumer NULL_GESTURE_CONSUMER =
new GestureConsumer();
public static GestureConsumer newInstance(
final EditorInfo editorInfo, final PrivateCommandPerformer commandPerformer,
final List<Locale> locales, final Keyboard keyboard) {
return GestureConsumer.NULL_GESTURE_CONSUMER;
}
private GestureConsumer() {
}
public boolean willConsume() {
return false;
}
public void onInit(final List<Locale> locales, final Keyboard keyboard) {
}
public void onGestureStarted(final List<Locale> locales, final Keyboard keyboard) {
}
public void onGestureCanceled() {
}
public void onGestureCompleted(final InputPointers inputPointers) {
}
public void onImeSuggestionsProcessed(final SuggestedWords suggestedWords,
final int composingStart, final int composingLength) {
}
}

35
java/src/com/android/inputmethod/latin/LatinIME.java
View File

@ -84,6 +84,7 @@ import com.android.inputmethod.latin.settings.SettingsActivity;
import com.android.inputmethod.latin.settings.SettingsValues;
import com.android.inputmethod.latin.suggestions.SuggestionStripView;
import com.android.inputmethod.latin.suggestions.SuggestionStripViewAccessor;
import com.android.inputmethod.latin.touchinputconsumer.GestureConsumer;
import com.android.inputmethod.latin.utils.ApplicationUtils;
import com.android.inputmethod.latin.utils.CapsModeUtils;
import com.android.inputmethod.latin.utils.CoordinateUtils;
@ -101,6 +102,7 @@ import com.android.inputmethod.latin.utils.ViewLayoutUtils;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.TimeUnit;
@ -176,6 +178,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
private final boolean mIsHardwareAcceleratedDrawingEnabled;
private GestureConsumer mGestureConsumer = GestureConsumer.NULL_GESTURE_CONSUMER;
public final UIHandler mHandler = new UIHandler(this);
public static final class UIHandler extends LeakGuardHandlerWrapper<LatinIME> {
@ -255,9 +259,11 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
latinIme.resetDictionaryFacilitatorIfNecessary();
break;
case MSG_UPDATE_TAIL_BATCH_INPUT_COMPLETED:
final SuggestedWords suggestedWords = (SuggestedWords) msg.obj;
latinIme.mInputLogic.onUpdateTailBatchInputCompleted(
latinIme.mSettings.getCurrent(),
(SuggestedWords) msg.obj, latinIme.mKeyboardSwitcher);
suggestedWords, latinIme.mKeyboardSwitcher);
latinIme.onTailBatchInputResultShown(suggestedWords);
break;
case MSG_RESET_CACHES:
final SettingsValues settingsValues = latinIme.mSettings.getCurrent();
@ -799,6 +805,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
StatsUtils.onFinishInputView();
mHandler.onFinishInputView(finishingInput);
mStatsUtilsManager.onFinishInputView();
mGestureConsumer = GestureConsumer.NULL_GESTURE_CONSUMER;
}
@Override
@ -824,6 +831,9 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
@SuppressWarnings("deprecation")
private void onStartInputViewInternal(final EditorInfo editorInfo, final boolean restarting) {
super.onStartInputView(editorInfo, restarting);
// Switch to the null consumer to handle cases leading to early exit below, for which we
// also wouldn't be consuming gesture data.
mGestureConsumer = GestureConsumer.NULL_GESTURE_CONSUMER;
mRichImm.clearSubtypeCaches();
final KeyboardSwitcher switcher = mKeyboardSwitcher;
switcher.updateKeyboardTheme();
@ -867,6 +877,12 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
return;
}
// Update to a gesture consumer with the current editor and IME state.
mGestureConsumer = GestureConsumer.newInstance(editorInfo,
mInputLogic.getPrivateCommandPerformer(),
Collections.singletonList(mSubtypeSwitcher.getCurrentSubtypeLocale()),
switcher.getKeyboard());
// Forward this event to the accessibility utilities, if enabled.
final AccessibilityUtils accessUtils = AccessibilityUtils.getInstance();
if (accessUtils.isTouchExplorationEnabled()) {
@ -1397,6 +1413,9 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
@Override
public void onStartBatchInput() {
mInputLogic.onStartBatchInput(mSettings.getCurrent(), mKeyboardSwitcher, mHandler);
mGestureConsumer.onGestureStarted(
Collections.singletonList(mSubtypeSwitcher.getCurrentSubtypeLocale()),
mKeyboardSwitcher.getKeyboard());
}
@Override
@ -1407,11 +1426,25 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
@Override
public void onEndBatchInput(final InputPointers batchPointers) {
mInputLogic.onEndBatchInput(batchPointers);
mGestureConsumer.onGestureCompleted(batchPointers);
}
@Override
public void onCancelBatchInput() {
mInputLogic.onCancelBatchInput(mHandler);
mGestureConsumer.onGestureCanceled();
}
/**
* To be called after the InputLogic has gotten a chance to act on the on-device decoding
* for the full gesture, possibly updating the TextView to reflect the first decoding.
* <p>
* This method must be run on the UI Thread.
* @param suggestedWords On-device decoding for the full gesture.
*/
public void onTailBatchInputResultShown(final SuggestedWords suggestedWords) {
mGestureConsumer.onImeSuggestionsProcessed(suggestedWords,
mInputLogic.getComposingStart(), mInputLogic.getComposingLength());
}
// This method must run on the UI Thread.

13
java/src/com/android/inputmethod/latin/RichInputConnection.java
View File

@ -19,6 +19,7 @@ package com.android.inputmethod.latin;
import android.graphics.Color;
import android.inputmethodservice.InputMethodService;
import android.os.Build;
import android.os.Bundle;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.TextUtils;
@ -33,6 +34,7 @@ import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputMethodManager;
import com.android.inputmethod.compat.InputConnectionCompatUtils;
import com.android.inputmethod.latin.inputlogic.PrivateCommandPerformer;
import com.android.inputmethod.latin.settings.SpacingAndPunctuations;
import com.android.inputmethod.latin.utils.CapsModeUtils;
import com.android.inputmethod.latin.utils.DebugLogUtils;
@ -52,7 +54,7 @@ import java.util.Arrays;
* all the time to find out what text is in the buffer, when we need it to determine caps mode
* for example.
*/
public final class RichInputConnection {
public final class RichInputConnection implements PrivateCommandPerformer {
private static final String TAG = RichInputConnection.class.getSimpleName();
private static final boolean DBG = false;
private static final boolean DEBUG_PREVIOUS_TEXT = false;
@ -896,6 +898,15 @@ public final class RichInputConnection {
}
}
@Override
public boolean performPrivateCommand(final String action, final Bundle data) {
mIC = mParent.getCurrentInputConnection();
if (mIC == null) {
return false;
}
return mIC.performPrivateCommand(action, data);
}
public int getExpectedSelectionStart() {
return mExpectedSelStart;
}

3
java/src/com/android/inputmethod/latin/WordComposer.java
View File

@ -128,8 +128,7 @@ public final class WordComposer {
* Number of keystrokes in the composing word.
* @return the number of keystrokes
*/
// This may be made public if need be, but right now it's not used anywhere
/* package for tests */ int size() {
public int size() {
return mCodePointSize;
}

41
java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
View File

@ -2263,6 +2263,47 @@ public final class InputLogic {
mConnection.setComposingText(composingTextToBeSet, newCursorPosition);
}
/**
* Gets an object allowing private IME commands to be sent to the
* underlying editor.
* @return An object for sending private commands to the underlying editor.
*/
public PrivateCommandPerformer getPrivateCommandPerformer() {
return mConnection;
}
/**
* Gets the expected index of the first char of the composing span within the editor's text.
* Returns a negative value in case there appears to be no valid composing span.
*
* @see #getComposingLength()
* @see RichInputConnection#hasSelection()
* @see RichInputConnection#isCursorPositionKnown()
* @see RichInputConnection#getExpectedSelectionStart()
* @see RichInputConnection#getExpectedSelectionEnd()
* @return The expected index in Java chars of the first char of the composing span.
*/
// TODO: try and see if we can get rid of this method. Ideally the users of this class should
// never need to know this.
public int getComposingStart() {
if (!mConnection.isCursorPositionKnown() || mConnection.hasSelection()) {
return -1;
}
return mConnection.getExpectedSelectionStart() - mWordComposer.size();
}
/**
* Gets the expected length in Java chars of the composing span.
* May be 0 if there is no valid composing span.
* @see #getComposingStart()
* @return The expected length of the composing span.
*/
// TODO: try and see if we can get rid of this method. Ideally the users of this class should
// never need to know this.
public int getComposingLength() {
return mWordComposer.size();
}
//////////////////////////////////////////////////////////////////////////////////////////////
// Following methods are tentatively placed in this class for the integration with
// TextDecorator.

40
java/src/com/android/inputmethod/latin/inputlogic/PrivateCommandPerformer.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.inputmethod.latin.inputlogic;
import android.os.Bundle;
/**
* Provides an interface matching
* {@link android.view.inputmethod.InputConnection#performPrivateCommand(String,Bundle)}.
*/
public interface PrivateCommandPerformer {
/**
* API to send private commands from an input method to its connected
* editor. This can be used to provide domain-specific features that are
* only known between certain input methods and their clients.
*
* @param action Name of the command to be performed. This must be a scoped
* name, i.e. prefixed with a package name you own, so that
* different developers will not create conflicting commands.
* @param data Any data to include with the command.
* @return true if the command was sent (regardless of whether the
* associated editor understood it), false if the input connection is no
* longer valid.
*/
boolean performPrivateCommand(String action, Bundle data);
}

10
java/src/com/android/inputmethod/latin/utils/CollectionUtils.java
View File

@ -17,6 +17,7 @@
package com.android.inputmethod.latin.utils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;
@ -40,4 +41,13 @@ public final class CollectionUtils {
}
return list;
}
/**
* Tests whether c contains no elements, true if c is null or c is empty.
* @param c Collection to test.
* @return Whether c contains no elements.
*/
public static boolean isNullOrEmpty(final Collection c) {
return c == null || c.isEmpty();
}
}

47
tests/src/com/android/inputmethod/latin/touchinputconsumer/NullGestureConsumerTests.java Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.inputmethod.latin.touchinputconsumer;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
/**
* Tests for GestureConsumer.NULL_GESTURE_CONSUMER.
*/
@SmallTest
public class NullGestureConsumerTests extends AndroidTestCase {
/**
* Tests that GestureConsumer.NULL_GESTURE_CONSUMER indicates that it won't consume gesture data
* and that its methods don't raise exceptions even for invalid data.
*/
public void testNullGestureConsumer() {
assertFalse(GestureConsumer.NULL_GESTURE_CONSUMER.willConsume());
GestureConsumer.NULL_GESTURE_CONSUMER.onInit(null, null);
GestureConsumer.NULL_GESTURE_CONSUMER.onGestureStarted(null, null);
GestureConsumer.NULL_GESTURE_CONSUMER.onGestureCanceled();
GestureConsumer.NULL_GESTURE_CONSUMER.onGestureCompleted(null);
GestureConsumer.NULL_GESTURE_CONSUMER.onImeSuggestionsProcessed(null, -1, -1);
}
/**
* Tests that newInstance returns NULL_GESTURE_CONSUMER for invalid input.
*/
public void testNewInstanceGivesNullGestureConsumerForInvalidInputs() {
assertSame(GestureConsumer.NULL_GESTURE_CONSUMER,
GestureConsumer.newInstance(null, null, null, null));
}
}

55
tests/src/com/android/inputmethod/latin/utils/CollectionUtilsTests.java Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.inputmethod.latin.utils;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
/**
* Tests for {@link CollectionUtils}.
*/
@SmallTest
public class CollectionUtilsTests extends AndroidTestCase {
/**
* Tests that {@link CollectionUtils#arrayAsList(E[],int,int)} gives the expected
* results for a few valid inputs.
*/
public void testArrayAsList() {
final String[] array = { "0", "1", "2", "3", "4" };
final ArrayList<String> empty = new ArrayList<>();
assertEquals(empty, CollectionUtils.arrayAsList(array, 0, 0));
assertEquals(empty, CollectionUtils.arrayAsList(array, 1, 1));
final ArrayList<String> expected123 = new ArrayList<>(Arrays.asList("1", "2", "3"));
assertEquals(expected123, CollectionUtils.arrayAsList(array, 1, 4));
}
/**
* Tests that {@link CollectionUtils#isEmpty(java.util.Collection)} gives the expected
* results for a few cases.
*/
public void testIsNullOrEmpty() {
assertTrue(CollectionUtils.isNullOrEmpty(null));
assertTrue(CollectionUtils.isNullOrEmpty(new ArrayList()));
assertTrue(CollectionUtils.isNullOrEmpty(Collections.EMPTY_SET));
assertFalse(CollectionUtils.isNullOrEmpty(Collections.singleton("Not empty")));
}
}