Merge "Passing options to native suggestion method."

java/src/com/android/inputmethod/latin/BinaryDictionary.java

@@ -45,7 +45,7 @@ public final class BinaryDictionary extends Dictionary {
     private final int[] mOutputScores = new int[MAX_RESULTS];
     private final int[] mOutputTypes = new int[MAX_RESULTS];
 
-    private final boolean mUseFullEditDistance;
+    private final NativeSuggestOptions mNativeSuggestOptions = new NativeSuggestOptions();
 
     private final SparseArray<DicTraverseSession> mDicTraverseSessions =
             CollectionUtils.newSparseArray();
@@ -79,7 +79,7 @@ public final class BinaryDictionary extends Dictionary {
             final boolean useFullEditDistance, final Locale locale, final String dictType) {
         super(dictType);
         mLocale = locale;
-        mUseFullEditDistance = useFullEditDistance;
+        mNativeSuggestOptions.setUseFullEditDistance(useFullEditDistance);
         loadDictionary(filename, offset, length);
     }
 
@@ -94,7 +94,7 @@ public final class BinaryDictionary extends Dictionary {
     private static native int getSuggestionsNative(long dict, long proximityInfo,
             long traverseSession, int[] xCoordinates, int[] yCoordinates, int[] times,
             int[] pointerIds, int[] inputCodePoints, int inputSize, int commitPoint,
-            boolean isGesture, int[] prevWordCodePointArray, boolean useFullEditDistance,
+            int[] suggestOptions, int[] prevWordCodePointArray,
             int[] outputCodePoints, int[] outputScores, int[] outputIndices, int[] outputTypes);
     private static native float calcNormalizedScoreNative(int[] before, int[] after, int score);
     private static native int editDistanceNative(int[] before, int[] after);
@@ -135,12 +135,13 @@ public final class BinaryDictionary extends Dictionary {
 
         final InputPointers ips = composer.getInputPointers();
         final int inputSize = isGesture ? ips.getPointerSize() : composerSize;
+        mNativeSuggestOptions.setIsGesture(isGesture);
         // proximityInfo and/or prevWordForBigrams may not be null.
         final int count = getSuggestionsNative(mNativeDict, proximityInfo.getNativeProximityInfo(),
                 getTraverseSession(sessionId).getSession(), ips.getXCoordinates(),
                 ips.getYCoordinates(), ips.getTimes(), ips.getPointerIds(), mInputCodePoints,
-                inputSize, 0 /* commitPoint */, isGesture, prevWordCodePointArray,
+                inputSize, 0 /* commitPoint */, mNativeSuggestOptions.getOptions(),
-                mUseFullEditDistance, mOutputCodePoints, mOutputScores, mSpaceIndices,
+                prevWordCodePointArray, mOutputCodePoints, mOutputScores, mSpaceIndices,
                 mOutputTypes);
         final ArrayList<SuggestedWordInfo> suggestions = CollectionUtils.newArrayList();
         for (int j = 0; j < count; ++j) {

java/src/com/android/inputmethod/latin/NativeSuggestOptions.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2013 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;
+
+public class NativeSuggestOptions {
+    // Need to update suggest_options.h when you add, remove or reorder options.
+    private static final int IS_GESTURE = 0;
+    private static final int USE_FULL_EDIT_DISTANCE = 1;
+    private static final int OPTIONS_SIZE = 2;
+
+    private final int[] mOptions = new int[OPTIONS_SIZE];
+
+    public void setIsGesture(final boolean value) {
+        setBooleanOption(IS_GESTURE, value);
+    }
+
+    public void setUseFullEditDistance(final boolean value) {
+        setBooleanOption(USE_FULL_EDIT_DISTANCE, value);
+    }
+
+    public int[] getOptions() {
+        return mOptions;
+    }
+
+    private void setBooleanOption(final int key, final boolean value) {
+        mOptions[key] = value ? 1 : 0;
+    }
+}

native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp

@@ -35,6 +35,7 @@
 #include "dictionary.h"
 #include "jni.h"
 #include "jni_common.h"
+#include "suggest_options.h"
 
 namespace latinime {
 
@@ -128,10 +129,9 @@ static jlong latinime_BinaryDictionary_open(JNIEnv *env, jclass clazz, jstring s
 static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jclass clazz, jlong dict,
         jlong proximityInfo, jlong dicTraverseSession, jintArray xCoordinatesArray,
         jintArray yCoordinatesArray, jintArray timesArray, jintArray pointerIdsArray,
-        jintArray inputCodePointsArray, jint inputSize, jint commitPoint, jboolean isGesture,
+        jintArray inputCodePointsArray, jint inputSize, jint commitPoint, jintArray suggestOptions,
-        jintArray prevWordCodePointsForBigrams, jboolean useFullEditDistance,
+        jintArray prevWordCodePointsForBigrams, jintArray outputCodePointsArray,
-        jintArray outputCodePointsArray, jintArray scoresArray, jintArray spaceIndicesArray,
+        jintArray scoresArray, jintArray spaceIndicesArray, jintArray outputTypesArray) {
-        jintArray outputTypesArray) {
     Dictionary *dictionary = reinterpret_cast<Dictionary *>(dict);
     if (!dictionary) return 0;
     ProximityInfo *pInfo = reinterpret_cast<ProximityInfo *>(proximityInfo);
@@ -159,6 +159,11 @@ static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jclass clazz, j
         prevWordCodePoints = prevWordCodePointsInternal;
     }
 
+    const jsize numberOfOptions = env->GetArrayLength(suggestOptions);
+    int options[numberOfOptions];
+    env->GetIntArrayRegion(suggestOptions, 0, numberOfOptions, options);
+    SuggestOptions givenOptions(options, numberOfOptions);
+
     // Output values
     /* By the way, let's check the output array length here to make sure */
     const jsize outputCodePointsLength = env->GetArrayLength(outputCodePointsArray);
@@ -185,11 +190,12 @@ static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jclass clazz, j
     memset(outputTypes, 0, sizeof(outputTypes));
 
     int count;
-    if (isGesture || inputSize > 0) {
+    if (givenOptions.isGesture() || inputSize > 0) {
         count = dictionary->getSuggestions(pInfo, traverseSession, xCoordinates, yCoordinates,
                 times, pointerIds, inputCodePoints, inputSize, prevWordCodePoints,
-                prevWordCodePointsLength, commitPoint, isGesture, useFullEditDistance,
+                prevWordCodePointsLength, commitPoint, givenOptions.isGesture(),
-                outputCodePoints, scores, spaceIndices, outputTypes);
+                givenOptions.useFullEditDistance(), outputCodePoints, scores,
+                spaceIndices, outputTypes);
     } else {
         count = dictionary->getBigrams(prevWordCodePoints, prevWordCodePointsLength,
                 inputCodePoints, inputSize, outputCodePoints, scores, outputTypes);
@@ -288,7 +294,7 @@ static JNINativeMethod sMethods[] = {
      const_cast<char *>("(J)V"),
      reinterpret_cast<void *>(latinime_BinaryDictionary_close)},
     {const_cast<char *>("getSuggestionsNative"),
-     const_cast<char *>("(JJJ[I[I[I[I[IIIZ[IZ[I[I[I[I)I"),
+     const_cast<char *>("(JJJ[I[I[I[I[III[I[I[I[I[I[I)I"),
      reinterpret_cast<void *>(latinime_BinaryDictionary_getSuggestions)},
     {const_cast<char *>("getProbabilityNative"),
      const_cast<char *>("(J[I)I"),

native/jni/src/suggest_options.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#ifndef LATINIME_SUGGEST_OPTIONS_H
+#define LATINIME_SUGGEST_OPTIONS_H
+
+#include "defines.h"
+
+namespace latinime {
+
+class SuggestOptions{
+ public:
+    AK_FORCE_INLINE bool isGesture() const {
+        return getBoolOption(IS_GESTURE);
+    }
+
+    AK_FORCE_INLINE bool useFullEditDistance() const {
+        return getBoolOption(USE_FULL_EDIT_DISTANCE);
+    }
+
+    SuggestOptions(const int *const options, const int length)
+            : mOptions(options), mLength(length) {}
+
+ private:
+    // Need to update com.android.inputmethod.latin.NativeSuggestOptions when you add, remove or
+    // reorder options.
+    static const int IS_GESTURE = 0;
+    static const int USE_FULL_EDIT_DISTANCE = 1;
+
+    const int *const mOptions;
+    const int mLength;
+
+    AK_FORCE_INLINE bool isValidKey(const int key) const {
+        return 0 <= key && key < mLength;
+    }
+
+    AK_FORCE_INLINE bool getBoolOption(const int key) const {
+        if (isValidKey(key)) {
+            return mOptions[key] != 0;
+        }
+        return false;
+    }
+
+    AK_FORCE_INLINE int getIntOption(const int key) const {
+        if (isValidKey(key)) {
+            return mOptions[key];
+        }
+        return 0;
+    }
+};
+} // namespace latinime
+#endif // LATINIME_SUGGEST_OPTIONS_H