Recommended implementation of combining characters implementation.

shell/platform/android/io/flutter/embedding/engine/android/AndroidKeyProcessor.java

@@ -0,0 +1,70 @@
+package io.flutter.embedding.engine.android;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.KeyCharacterMap;
+import android.view.KeyEvent;
+
+import io.flutter.embedding.engine.systemchannels.KeyEventChannel;
+
+public class AndroidKeyProcessor {
+  private final KeyEventChannel keyEventChannel;
+  private int baseCharacter;
+
+  public AndroidKeyProcessor(@NonNull KeyEventChannel keyEventChannel) {
+    this.keyEventChannel = keyEventChannel;
+  }
+
+  public void onKeyUp(@NonNull KeyEvent keyEvent) {
+    Character complexCharacter = applyKeyToBaseCharacter(keyEvent.getUnicodeChar());
+    keyEventChannel.keyUp(
+        new KeyEventChannel.FlutterKeyEvent(keyEvent, complexCharacter)
+    );
+  }
+
+  public void onKeyDown(@NonNull KeyEvent keyEvent) {
+    Character complexCharacter = applyKeyToBaseCharacter(keyEvent.getUnicodeChar());
+    keyEventChannel.keyDown(
+        new KeyEventChannel.FlutterKeyEvent(keyEvent, complexCharacter)
+    );
+  }
+
+  /**
+   * Applies the given unicode character in {@code codePoint} to a previously entered
+   * unicode character and returns the combination of these characters if a combination
+   * exists.
+   *
+   * If the given unicode character is the first to be pressed in a session, or if
+   * the new unicode character cannot be combined with the previous unicode character,
+   * null is returned.
+   *
+   * This method mutates {@link #baseCharacter} over time to combine characters.
+   */
+  @Nullable
+  private Character applyKeyToBaseCharacter(int codePoint) {
+    if (codePoint == 0) {
+      return null;
+    }
+
+    if ((codePoint & KeyCharacterMap.COMBINING_ACCENT) != 0) {
+      // If a combining character was entered before, combine this one with that one.
+      int plainCodePoint = codePoint & KeyCharacterMap.COMBINING_ACCENT_MASK;
+      if (baseCharacter != 0) {
+        baseCharacter = KeyCharacterMap.getDeadChar(baseCharacter, plainCodePoint);
+      } else {
+        baseCharacter = plainCodePoint;
+      }
+    } else {
+      if (baseCharacter != 0) {
+        int combinedChar = KeyCharacterMap.getDeadChar(baseCharacter, codePoint);
+        if (combinedChar > 0) {
+          codePoint = combinedChar;
+        }
+        baseCharacter = 0;
+      }
+      return (char) codePoint;
+    }
+
+    return null;
+  }
+}

shell/platform/android/io/flutter/embedding/engine/systemchannels/KeyEventChannel.java

@@ -5,6 +5,7 @@
 package io.flutter.embedding.engine.systemchannels;
 
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 import android.view.KeyEvent;
 
 import java.util.HashMap;
@@ -26,7 +27,7 @@ public KeyEventChannel(@NonNull DartExecutor dartExecutor) {
     this.channel = new BasicMessageChannel<>(dartExecutor, "flutter/keyevent", JSONMessageCodec.INSTANCE);
   }
 
-  public void keyUp(@NonNull KeyEvent keyEvent) {
+  public void keyUp(@NonNull FlutterKeyEvent keyEvent) {
     Map<String, Object> message = new HashMap<>();
     message.put("type", "keyup");
     message.put("keymap", "android");
@@ -35,7 +36,7 @@ public void keyUp(@NonNull KeyEvent keyEvent) {
     channel.send(message);
   }
 
-  public void keyDown(@NonNull KeyEvent keyEvent) {
+  public void keyDown(@NonNull FlutterKeyEvent keyEvent) {
     Map<String, Object> message = new HashMap<>();
     message.put("type", "keydown");
     message.put("keymap", "android");
@@ -44,11 +45,63 @@ public void keyDown(@NonNull KeyEvent keyEvent) {
     channel.send(message);
   }
 
-  private void encodeKeyEvent(@NonNull KeyEvent event, @NonNull Map<String, Object> message) {
-    message.put("flags", event.getFlags());
-    message.put("codePoint", event.getUnicodeChar());
-    message.put("keyCode", event.getKeyCode());
-    message.put("scanCode", event.getScanCode());
-    message.put("metaState", event.getMetaState());
+  private void encodeKeyEvent(@NonNull FlutterKeyEvent event, @NonNull Map<String, Object> message) {
+    message.put("flags", event.flags);
+    message.put("codePoint", event.codePoint);
+    message.put("keyCode", event.keyCode);
+    message.put("scanCode", event.scanCode);
+    message.put("metaState", event.metaState);
+    if (event.complexCharacter != null) {
+      message.put("character", event.complexCharacter.toString());
+    }
+  }
+
+  /**
+   * Key event as defined by Flutter.
+   */
+  public static class FlutterKeyEvent {
+    public final int flags;
+    public final int codePoint;
+    public final int keyCode;
+    @Nullable
+    public final Character complexCharacter;
+    public final int scanCode;
+    public final int metaState;
+
+    public FlutterKeyEvent(
+        @NonNull KeyEvent androidKeyEvent
+    ) {
+      this(androidKeyEvent, null);
+    }
+
+    public FlutterKeyEvent(
+        @NonNull KeyEvent androidKeyEvent,
+        @Nullable Character complexCharacter
+    ) {
+      this(
+          androidKeyEvent.getFlags(),
+          androidKeyEvent.getUnicodeChar(),
+          androidKeyEvent.getKeyCode(),
+          complexCharacter,
+          androidKeyEvent.getScanCode(),
+          androidKeyEvent.getMetaState()
+      );
+    }
+
+    public FlutterKeyEvent(
+        int flags,
+        int codePoint,
+        int keyCode,
+        @Nullable Character complexCharacter,
+        int scanCode,
+        int metaState
+    ) {
+      this.flags = flags;
+      this.codePoint = codePoint;
+      this.keyCode = keyCode;
+      this.complexCharacter = complexCharacter;
+      this.scanCode = scanCode;
+      this.metaState = metaState;
+    }
   }
 }

shell/platform/android/io/flutter/view/FlutterView.java

@@ -26,6 +26,7 @@
 import android.view.inputmethod.InputConnection;
 import android.view.inputmethod.InputMethodManager;
 import io.flutter.app.FlutterPluginRegistry;
+import io.flutter.embedding.engine.android.AndroidKeyProcessor;
 import io.flutter.embedding.engine.dart.DartExecutor;
 import io.flutter.embedding.engine.systemchannels.KeyEventChannel;
 import io.flutter.embedding.engine.systemchannels.LifecycleChannel;
@@ -93,6 +94,7 @@ static final class ViewportMetrics {
     private final SystemChannel systemChannel;
     private final InputMethodManager mImm;
     private final TextInputPlugin mTextInputPlugin;
+    private final AndroidKeyProcessor androidKeyProcessor;
     private final SurfaceHolder.Callback mSurfaceCallback;
     private final ViewportMetrics mMetrics;
     private final AccessibilityManager mAccessibilityManager;
@@ -172,7 +174,7 @@ public void surfaceDestroyed(SurfaceHolder holder) {
         addActivityLifecycleListener(platformPlugin);
         mImm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
         mTextInputPlugin = new TextInputPlugin(this);
-
+        androidKeyProcessor = new AndroidKeyProcessor(keyEventChannel);
 
         setLocales(getResources().getConfiguration());
         sendUserPlatformSettingsToDart();
@@ -183,7 +185,7 @@ public boolean onKeyUp(int keyCode, KeyEvent event) {
         if (!isAttached()) {
             return super.onKeyUp(keyCode, event);
         }
-        keyEventChannel.keyUp(event);
+        androidKeyProcessor.onKeyUp(event);
         return super.onKeyUp(keyCode, event);
     }
 
@@ -199,7 +201,7 @@ public boolean onKeyDown(int keyCode, KeyEvent event) {
             }
         }
 
-        keyEventChannel.keyDown(event);
+        androidKeyProcessor.onKeyDown(event);
         return super.onKeyDown(keyCode, event);
     }