Abandon the idea of an Event pool and make Event immutable (B1)

Change-Id: I750a07c0c564a95ceac734afa873ca3da9626a7f

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

@@ -54,39 +54,33 @@ public class Event {
 
     final private static int NOT_A_CODE_POINT = 0;
 
-    private int mType; // The type of event - one of the constants above
+    final private int mType; // The type of event - one of the constants above
     // The code point associated with the event, if relevant. This is a unicode code point, and
     // has nothing to do with other representations of the key. It is only relevant if this event
     // is the right type: COMMITTABLE or DEAD or TOGGLE, but for a mode key like hankaku/zenkaku or
     // ctrl, there is no code point associated so this should be NOT_A_CODE_POINT to avoid
     // unintentional use of its value when it's not relevant.
-    private int mCodePoint;
+    final public int mCodePoint;
 
-    static Event obtainEvent() {
-        // TODO: create an event pool instead
-        return new Event();
-    }
-
-    public void setDeadEvent(final int codePoint) {
-        mType = EVENT_DEAD;
+    // This method is private - to create a new event, use one of the create* utility methods.
+    private Event(final int type, final int codePoint) {
+        mType = type;
         mCodePoint = codePoint;
     }
 
-    public void setCommittableEvent(final int codePoint) {
-        mType = EVENT_COMMITTABLE;
-        mCodePoint = codePoint;
+    public static Event createDeadEvent(final int codePoint) {
+        return new Event(EVENT_DEAD, codePoint);
     }
 
-    public void setNotHandledEvent() {
-        mType = EVENT_NOT_HANDLED;
-        mCodePoint = NOT_A_CODE_POINT; // Just in case
+    public static Event createCommittableEvent(final int codePoint) {
+        return new Event(EVENT_COMMITTABLE, codePoint);
+    }
+
+    public static Event createNotHandledEvent() {
+        return new Event(EVENT_NOT_HANDLED, NOT_A_CODE_POINT);
     }
 
     public boolean isCommittable() {
         return EVENT_COMMITTABLE == mType;
     }
-
-    public int getCodePoint() {
-        return mCodePoint;
-    }
 }

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

@@ -107,7 +107,7 @@ public class EventInterpreter {
 
     private boolean onEvent(final Event event) {
         if (event.isCommittable()) {
-            mLatinIme.onCodeInput(event.getCodePoint(),
+            mLatinIme.onCodeInput(event.mCodePoint,
                     Constants.EXTERNAL_KEYBOARD_COORDINATE, Constants.EXTERNAL_KEYBOARD_COORDINATE);
             return true;
         }

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

@@ -38,7 +38,6 @@ public class HardwareKeyboardEventDecoder implements HardwareEventDecoder {
 
     @Override
     public Event decodeHardwareKey(final KeyEvent keyEvent) {
-        final Event event = Event.obtainEvent();
         // KeyEvent#getUnicodeChar() does not exactly returns a unicode char, but rather a value
         // 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.
@@ -48,22 +47,20 @@ public class HardwareKeyboardEventDecoder implements HardwareEventDecoder {
         // 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;
+            return Event.createCommittableEvent(Constants.CODE_DELETE);
         }
         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);
+                return Event.createDeadEvent(codePointAndFlags & KeyCharacterMap.COMBINING_ACCENT_MASK);
             } else {
                 // A committable character. This should be committed right away, taking into
                 // account the current state.
-                event.setCommittableEvent(codePointAndFlags);
+                return Event.createCommittableEvent(codePointAndFlags);
             }
         } else {
-            event.setNotHandledEvent();
-        }
-        return event;
+            return Event.createNotHandledEvent();
+        }
     }
 }