am 997cba7d: Start committing hardware events (B4)

* commit '997cba7decce9694b3c2f9487deb9710ebb19595':
  Start committing hardware events (B4)

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

@@ -81,4 +81,12 @@ public class Event {
         mType = EVENT_NOT_HANDLED;
         mCodePoint = NOT_A_CODE_POINT; // Just in case
     }
+
+    public boolean isCommittable() {
+        return EVENT_COMMITTABLE == mType;
+    }
+
+    public int getCodePoint() {
+        return mCodePoint;
+    }
 }

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

@@ -19,6 +19,9 @@ package com.android.inputmethod.event;
 import android.util.SparseArray;
 import android.view.KeyEvent;
 
+import com.android.inputmethod.latin.Constants;
+import com.android.inputmethod.latin.LatinIME;
+
 /**
  * This class implements the logic between receiving events and generating code points.
  *
@@ -36,6 +39,7 @@ public class EventInterpreter {
     final EventDecoderSpec mDecoderSpec;
     final SparseArray<HardwareEventDecoder> mHardwareEventDecoders;
     final SoftwareEventDecoder mSoftwareEventDecoder;
+    final LatinIME mLatinIme;
 
     /**
      * Create a default interpreter.
@@ -43,9 +47,10 @@ public class EventInterpreter {
      * This creates a default interpreter that does nothing. A default interpreter should normally
      * only be used for fallback purposes, when we really don't know what we want to do with input.
      *
+     * @param latinIme a reference to the ime.
      */
-    public EventInterpreter() {
-        this(null);
+    public EventInterpreter(final LatinIME latinIme) {
+        this(null, latinIme);
     }
 
     /**
@@ -61,13 +66,15 @@ public class EventInterpreter {
      * interpreter that does no specific combining, and assumes the most common cases.
      *
      * @param specification the specification for event interpretation. null for default.
+     * @param latinIme a reference to the ime.
      */
-    public EventInterpreter(final EventDecoderSpec specification) {
+    public EventInterpreter(final EventDecoderSpec specification, final LatinIME latinIme) {
         mDecoderSpec = null != specification ? specification : new EventDecoderSpec();
         // For both, we expect to have only one decoder in almost all cases, hence the default
         // capacity of 1.
         mHardwareEventDecoders = new SparseArray<HardwareEventDecoder>(1);
         mSoftwareEventDecoder = new SoftwareKeyboardEventDecoder();
+        mLatinIme = latinIme;
     }
 
     // Helper method to decode a hardware key event into a generic event, and execute any
@@ -99,6 +106,11 @@ public class EventInterpreter {
     }
 
     private boolean onEvent(final Event event) {
+        if (event.isCommittable()) {
+            mLatinIme.onCodeInput(event.getCodePoint(),
+                    Constants.EXTERNAL_KEYBOARD_COORDINATE, Constants.EXTERNAL_KEYBOARD_COORDINATE);
+            return true;
+        }
         // TODO: Classify the event - input or non-input (see design doc)
         // TODO: IF action event
         //          Send decoded action back to LatinIME

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

@@ -19,6 +19,8 @@ package com.android.inputmethod.event;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 
+import com.android.inputmethod.latin.Constants;
+
 /**
  * A hardware event decoder for a hardware qwerty-ish keyboard.
  *
@@ -41,7 +43,16 @@ public class HardwareKeyboardEventDecoder implements HardwareEventDecoder {
         // that includes both the unicode char in the lower 21 bits and flags in the upper bits,
         // hence the name "codePointAndFlags". {@see KeyEvent#getUnicodeChar()} for more info.
         final int codePointAndFlags = keyEvent.getUnicodeChar();
-        if (keyEvent.isPrintingKey()) {
+        // The keyCode is the abstraction used by the KeyEvent to represent different keys that
+        // do not necessarily map to a unicode character. This represents a physical key, like
+        // the key for 'A' or Space, but also Backspace or Ctrl or Caps Lock.
+        final int keyCode = keyEvent.getKeyCode();
+        if (KeyEvent.KEYCODE_DEL == keyCode) {
+            event.setCommittableEvent(Constants.CODE_DELETE);
+            return event;
+        }
+        if (keyEvent.isPrintingKey() || KeyEvent.KEYCODE_SPACE == keyCode
+                || KeyEvent.KEYCODE_ENTER == keyCode) {
             if (0 != (codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT)) {
                 // A dead key.
                 event.setDeadEvent(codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT_MASK);

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

@@ -139,6 +139,7 @@ public final class Constants {
     public static final int NOT_A_COORDINATE = -1;
     public static final int SUGGESTION_STRIP_COORDINATE = -2;
     public static final int SPELL_CHECKER_COORDINATE = -3;
+    public static final int EXTERNAL_KEYBOARD_COORDINATE = -4;
 
     public static boolean isValidCoordinate(final int coordinate) {
         // Detect {@link NOT_A_COORDINATE}, {@link SUGGESTION_STRIP_COORDINATE},

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

@@ -145,7 +145,7 @@ public final class LatinIME extends InputMethodService implements KeyboardAction
     private final SubtypeState mSubtypeState = new SubtypeState();
     // At start, create a default event interpreter that does nothing by passing it no decoder spec.
     // The event interpreter should never be null.
-    private EventInterpreter mEventInterpreter = new EventInterpreter();
+    private EventInterpreter mEventInterpreter = new EventInterpreter(this);
 
     private boolean mIsMainDictionaryAvailable;
     private UserBinaryDictionary mUserDictionary;