am ae4c8199: Merge "Initial implementation for dead keys (B3)"

* commit 'ae4c81993c201f501791520b8cd3697ff1f29649':
  Initial implementation for dead keys (B3)

java/src/com/android/inputmethod/event/Combiner.java

@@ -0,0 +1,29 @@
+/*
+ * 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.event;
+
+/**
+ * A generic interface for combiners.
+ */
+public interface Combiner {
+    /**
+     * Combine an event with the existing state and return the new event.
+     * @param event the event to combine with the existing state.
+     * @return the resulting event.
+     */
+    Event combine(Event event);
+}

java/src/com/android/inputmethod/event/DeadKeyCombiner.java

@@ -0,0 +1,61 @@
+/*
+ * 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.event;
+
+import android.text.TextUtils;
+import android.view.KeyCharacterMap;
+
+import com.android.inputmethod.latin.Constants;
+
+/**
+ * A combiner that handles dead keys.
+ */
+public class DeadKeyCombiner implements Combiner {
+    final StringBuilder mDeadSequence = new StringBuilder();
+
+    @Override
+    public Event combine(final Event event) {
+        if (null == event) return null; // Just in case some combiner is broken
+        if (TextUtils.isEmpty(mDeadSequence)) {
+            if (event.isDead()) {
+                mDeadSequence.appendCodePoint(event.mCodePoint);
+            }
+            return event;
+        } else {
+            // TODO: Allow combining for several dead chars rather than only the first one.
+            // The framework doesn't know how to do this now.
+            final int deadCodePoint = mDeadSequence.codePointAt(0);
+            mDeadSequence.setLength(0);
+            final int resultingCodePoint =
+                    KeyCharacterMap.getDeadChar(deadCodePoint, event.mCodePoint);
+            if (0 == resultingCodePoint) {
+                // We can't combine both characters. We need to commit the dead key as a committable
+                // character, and the next char too unless it's a space (because as a special case,
+                // dead key + space should result in only the dead key being committed - that's
+                // how dead keys work).
+                // If the event is a space, we should commit the dead char alone, but if it's
+                // not, we need to commit both.
+                return Event.createCommittableEvent(deadCodePoint,
+                        Constants.CODE_SPACE == event.mCodePoint ? null : event /* next */);
+            } else {
+                // We could combine the characters.
+                return Event.createCommittableEvent(resultingCodePoint, null /* next */);
+            }
+        }
+    }
+
+}

java/src/com/android/inputmethod/event/Event.java

@@ -86,4 +86,8 @@ public class Event {
     public boolean isCommittable() {
         return EVENT_COMMITTABLE == mType;
     }
+
+    public boolean isDead() {
+        return EVENT_DEAD == mType;
+    }
 }

java/src/com/android/inputmethod/event/EventInterpreter.java

@@ -19,9 +19,12 @@ package com.android.inputmethod.event;
 import android.util.SparseArray;
 import android.view.KeyEvent;
 
+import com.android.inputmethod.latin.CollectionUtils;
 import com.android.inputmethod.latin.Constants;
 import com.android.inputmethod.latin.LatinIME;
 
+import java.util.ArrayList;
+
 /**
  * This class implements the logic between receiving events and generating code points.
  *
@@ -40,6 +43,7 @@ public class EventInterpreter {
     final SparseArray<HardwareEventDecoder> mHardwareEventDecoders;
     final SoftwareEventDecoder mSoftwareEventDecoder;
     final LatinIME mLatinIme;
+    final ArrayList<Combiner> mCombiners;
 
     /**
      * Create a default interpreter.
@@ -74,6 +78,8 @@ public class EventInterpreter {
         // capacity of 1.
         mHardwareEventDecoders = new SparseArray<HardwareEventDecoder>(1);
         mSoftwareEventDecoder = new SoftwareKeyboardEventDecoder();
+        mCombiners = CollectionUtils.newArrayList();
+        mCombiners.add(new DeadKeyCombiner());
         mLatinIme = latinIme;
     }
 
@@ -108,12 +114,17 @@ public class EventInterpreter {
     private boolean onEvent(final Event event) {
         Event currentlyProcessingEvent = event;
         boolean processed = false;
+        for (int i = 0; i < mCombiners.size(); ++i) {
+            currentlyProcessingEvent = mCombiners.get(i).combine(event);
+        }
         while (null != currentlyProcessingEvent) {
             if (currentlyProcessingEvent.isCommittable()) {
                 mLatinIme.onCodeInput(currentlyProcessingEvent.mCodePoint,
                         Constants.EXTERNAL_KEYBOARD_COORDINATE,
                         Constants.EXTERNAL_KEYBOARD_COORDINATE);
                 processed = true;
+            } else if (event.isDead()) {
+                processed = true;
             }
             currentlyProcessingEvent = currentlyProcessingEvent.mNextEvent;
         }