Android support

README.md

@@ -2,16 +2,20 @@
 
 A platform library for listening to hardware gamepads (game controllers) from Flutter.
 
-**Currently supports iOS only. Android coming soon!**
-
 ## Features
 
 * `FlutterGamepad.gamepads()` returns info about all currently connected gamepads.
-* `FlutterGamepad.eventStream` reports gamepad events.
+* `FlutterGamepad.eventStream` reports gamepad events. (See example)
 * Fractional button values, such as those reported by the left and right trigger buttons on most gamepads, are supported.
 * Supports iOS 13+, as well as older versions of iOS.
+* Supports Android.
 * Supports multiple simultaneous gamepads. Events are tagged with an ID you can tell gamepads apart by.
 
+## Caveats
+
+* On Android, the B button seems to trigger a "back" action. You'll want to have a `WillPopScope` on your game scaffold to prevent this.
+* On Android, "disconnect" events are never fired. "Connect" events are fired initially when listening to the stream, and thereafter on the first input of any new gamepads. This differs from the iOS behavior, where a "connect" event is sent when the connection is established, even if no buttons have been pressed.
+
 ## Example
 
 ```dart

android/build.gradle

@@ -25,7 +25,7 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
 android {
-    compileSdkVersion 28
+    compileSdkVersion 29
 
     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'
@@ -42,3 +42,28 @@ android {
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
 }
+
+afterEvaluate {
+    def containsEmbeddingDependencies = false
+    for (def configuration : configurations.all) {
+        for (def dependency : configuration.dependencies) {
+            if (dependency.group == 'io.flutter' &&
+                    dependency.name.startsWith('flutter_embedding') &&
+                    dependency.isTransitive())
+            {
+                containsEmbeddingDependencies = true
+                break
+            }
+        }
+    }
+    if (!containsEmbeddingDependencies) {
+        android {
+            dependencies {
+                def lifecycle_version = "1.1.1"
+                compileOnly "android.arch.lifecycle:runtime:$lifecycle_version"
+                compileOnly "android.arch.lifecycle:common:$lifecycle_version"
+                compileOnly "android.arch.lifecycle:common-java8:$lifecycle_version"
+            }
+        }
+    }
+}

android/src/main/kotlin/com/example/flutter_gamepad/Button.kt

@@ -0,0 +1,55 @@
+package com.example.flutter_gamepad
+
+import android.view.KeyEvent
+
+/**
+ * The buttons on a gamepad, in flutter_gamepad order. This order matches the one on the Dart side.
+ */
+enum class Button {
+    A,
+    B,
+    X,
+    Y,
+    DpadUp,
+    DpadDown,
+    DpadLeft,
+    DpadRight,
+    Menu,
+    Options,
+    LeftThumbstickButton,
+    RightThumbstickButton,
+    LeftShoulder,
+    RightShoulder,
+    LeftTrigger,
+    RightTrigger,
+}
+
+/**
+ * The thumbsticks on a gamepad, in flutter_gamepad order. This order matches the one on the Dart side.
+ */
+enum class Thumbstick {
+    Left,
+    Right,
+}
+
+/**
+ * A map from Android key-codes to the flutter_gamepad Button enum.
+ */
+val buttonMap = hashMapOf(
+        KeyEvent.KEYCODE_BUTTON_A to Button.A,
+        KeyEvent.KEYCODE_BUTTON_B to Button.B,
+        KeyEvent.KEYCODE_BUTTON_X to Button.X,
+        KeyEvent.KEYCODE_BUTTON_Y to Button.Y,
+        KeyEvent.KEYCODE_DPAD_UP to Button.DpadUp,
+        KeyEvent.KEYCODE_DPAD_DOWN to Button.DpadDown,
+        KeyEvent.KEYCODE_DPAD_LEFT to Button.DpadLeft,
+        KeyEvent.KEYCODE_DPAD_RIGHT to Button.DpadRight,
+        KeyEvent.KEYCODE_BUTTON_START to Button.Menu,
+        KeyEvent.KEYCODE_BUTTON_SELECT to Button.Options,
+        KeyEvent.KEYCODE_BUTTON_THUMBL to Button.LeftThumbstickButton,
+        KeyEvent.KEYCODE_BUTTON_THUMBR to Button.RightThumbstickButton,
+        KeyEvent.KEYCODE_BUTTON_L1 to Button.LeftShoulder,
+        KeyEvent.KEYCODE_BUTTON_R1 to Button.RightShoulder,
+        KeyEvent.KEYCODE_BUTTON_L2 to Button.LeftTrigger,
+        KeyEvent.KEYCODE_BUTTON_R2 to Button.RightTrigger
+)

android/src/main/kotlin/com/example/flutter_gamepad/FlutterGamepadPlugin.kt

@@ -1,25 +1,93 @@
 package com.example.flutter_gamepad
 
+import android.view.KeyEvent
+import android.view.MotionEvent
+import io.flutter.embedding.android.AndroidKeyProcessor
+import io.flutter.embedding.android.AndroidTouchProcessor
+import io.flutter.view.FlutterView
+import io.flutter.embedding.engine.renderer.FlutterRenderer
+import io.flutter.embedding.engine.systemchannels.KeyEventChannel
+import io.flutter.plugin.common.EventChannel
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
 import io.flutter.plugin.common.MethodChannel.MethodCallHandler
 import io.flutter.plugin.common.MethodChannel.Result
 import io.flutter.plugin.common.PluginRegistry.Registrar
+import io.flutter.plugin.editing.TextInputPlugin
+import java.lang.reflect.Field
 
-class FlutterGamepadPlugin: MethodCallHandler {
-  companion object {
-    @JvmStatic
-    fun registerWith(registrar: Registrar) {
-      val channel = MethodChannel(registrar.messenger(), "flutter_gamepad")
-      channel.setMethodCallHandler(FlutterGamepadPlugin())
+/**
+ * An extension of Flutter's AndroidTouchProcessor that delegates MotionEvents to the GamepadStreamHandler.
+ * (On Android, thumbstick events from a gamepad are a kind of MotionEvent.)
+ */
+class GamepadAndroidTouchProcessor(renderer: FlutterRenderer) : AndroidTouchProcessor(renderer) {
+    override fun onGenericMotionEvent(event: MotionEvent): Boolean {
+        return GamepadStreamHandler.processMotionEvent(event) || super.onGenericMotionEvent(event)
+    }
+}
+
+/**
+ * An extension of Flutter's AndroidKeyProcessor that delegates KeyEvents to the GamepadStreamHandler.
+ * (On Android, button events from a gamepad are a kind of KeyEvent.)
+ */
+class GamepadAndroidKeyProcessor(keyEventChannel: KeyEventChannel, textInputPlugin: TextInputPlugin) : AndroidKeyProcessor(keyEventChannel, textInputPlugin) {
+    override fun onKeyDown(keyEvent: KeyEvent) {
+        val handled = GamepadStreamHandler.processKeyDownEvent(keyEvent)
+        if (!handled) {
+            super.onKeyDown(keyEvent)
+        }
+    }
+
+    override fun onKeyUp(keyEvent: KeyEvent) {
+        val handled = GamepadStreamHandler.processKeyUpEvent(keyEvent)
+        if (!handled) {
+            super.onKeyDown(keyEvent)
+        }
+    }
+}
+
+/**
+ * The flutter_gamepad plugin class that is registered with the framework.
+ */
+class FlutterGamepadPlugin : MethodCallHandler {
+    companion object {
+        @JvmStatic
+        fun registerWith(registrar: Registrar) {
+            val methodChannel = MethodChannel(registrar.messenger(), "com.rainway.flutter_gamepad/methods")
+            methodChannel.setMethodCallHandler(FlutterGamepadPlugin())
+            val eventChannel = EventChannel(registrar.messenger(), "com.rainway.flutter_gamepad/events")
+            eventChannel.setStreamHandler(GamepadStreamHandler)
+
+            val view: FlutterView = registrar.view()
+            fun viewField(name: String): Field {
+                val field = FlutterView::class.java.getDeclaredField(name)
+                field.isAccessible = true
+                return field
+            }
+
+            // Hack: swap in a new AndroidTouchProcessor.
+            val touchProcessorField = viewField("androidTouchProcessor")
+            val rendererField = viewField("flutterRenderer")
+            val renderer = rendererField.get(view) as FlutterRenderer
+            val touchProcessor = GamepadAndroidTouchProcessor(renderer)
+            touchProcessorField.set(view, touchProcessor)
+
+            // Hack: swap in a new AndroidKeyProcessor.
+            val keyProcessorField = viewField("androidKeyProcessor")
+            val keyEventChannelField = viewField("keyEventChannel")
+            val textInputPluginField = viewField("mTextInputPlugin")
+            val keyEventChannel = keyEventChannelField.get(view) as KeyEventChannel
+            val textInputPlugin = textInputPluginField.get(view) as TextInputPlugin
+            val keyProcessor = GamepadAndroidKeyProcessor(keyEventChannel, textInputPlugin)
+            keyProcessorField.set(view, keyProcessor)
+        }
     }
-  }
 
-  override fun onMethodCall(call: MethodCall, result: Result) {
-    if (call.method == "getPlatformVersion") {
-      result.success("Android ${android.os.Build.VERSION.RELEASE}")
-    } else {
-      result.notImplemented()
+    override fun onMethodCall(call: MethodCall, result: Result) {
+        if (call.method == "gamepads") {
+            result.success(allGamepadInfoDictionaries())
+        } else {
+            result.notImplemented()
+        }
     }
-  }
 }