[Super Keyboard][Android] - Limit keyboard tracking to between onResume and onPause (Resolves #2622) (#2623)

Author: matthew-carroll

super_keyboard/android/build.gradle

@@ -9,7 +9,7 @@ buildscript {
     }
 
     dependencies {
-        classpath("com.android.tools.build:gradle:7.3.0")
+        classpath("com.android.tools.build:gradle:8.1.0")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
     }
 }

super_keyboard/android/src/main/kotlin/com/flutterbountyhunters/superkeyboard/super_keyboard/SuperKeyboardLog.kt

@@ -0,0 +1,27 @@
+package com.flutterbountyhunters.superkeyboard.super_keyboard
+
+import android.util.Log
+
+object SuperKeyboardLog {
+    var isLoggingEnabled: Boolean = false
+
+    fun d(tag: String, message: String) {
+        if (isLoggingEnabled) Log.d(tag, message)
+    }
+
+    fun i(tag: String, message: String) {
+        if (isLoggingEnabled) Log.i(tag, message)
+    }
+
+    fun w(tag: String, message: String) {
+        if (isLoggingEnabled) Log.w(tag, message)
+    }
+
+    fun e(tag: String, message: String, throwable: Throwable? = null) {
+        if (isLoggingEnabled) Log.e(tag, message, throwable)
+    }
+
+    fun v(tag: String, message: String) {
+        if (isLoggingEnabled) Log.v(tag, message)
+    }
+}

super_keyboard/android/src/main/kotlin/com/flutterbountyhunters/superkeyboard/super_keyboard/SuperKeyboardPlugin.kt

@@ -1,16 +1,21 @@
 package com.flutterbountyhunters.superkeyboard.super_keyboard
 
 import android.app.Activity
+import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import android.view.inputmethod.InputMethodManager
 import androidx.core.view.OnApplyWindowInsetsListener
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsAnimationCompat
 import androidx.core.view.WindowInsetsCompat
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
 import io.flutter.embedding.engine.plugins.FlutterPlugin
 import io.flutter.embedding.engine.plugins.activity.ActivityAware
 import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
+import io.flutter.embedding.engine.plugins.lifecycle.FlutterLifecycleAdapter
 import io.flutter.plugin.common.MethodChannel
 
 
@@ -22,9 +27,15 @@ import io.flutter.plugin.common.MethodChannel
  *
  * Android Docs: https://developer.android.com/develop/ui/views/layout/sw-keyboard
  */
-class SuperKeyboardPlugin: FlutterPlugin, ActivityAware, OnApplyWindowInsetsListener {
+class SuperKeyboardPlugin: FlutterPlugin, ActivityAware, DefaultLifecycleObserver, OnApplyWindowInsetsListener {
   private lateinit var channel : MethodChannel
 
+  private var binding: ActivityPluginBinding? = null
+
+  // The Activity's lifecycle, which reports things like when the Android
+  // app comes into the foreground from the background.
+  private var lifecycle: Lifecycle? = null
+
   // The root view within the Android Activity.
   private var mainView: View? = null
 
@@ -35,18 +46,82 @@ class SuperKeyboardPlugin: FlutterPlugin, ActivityAware, OnApplyWindowInsetsList
   private var keyboardState: KeyboardState = KeyboardState.Closed
 
   override fun onAttachedToEngine(flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
+    SuperKeyboardLog.d("super_keyboard", "Attached to Flutter engine")
     channel = MethodChannel(flutterPluginBinding.binaryMessenger, "super_keyboard_android")
+
+    channel.setMethodCallHandler { call, result ->
+      when (call.method) {
+        "startLogging" -> {
+          SuperKeyboardLog.isLoggingEnabled = true
+          result.success(null)
+        }
+        "stopLogging" -> {
+          SuperKeyboardLog.isLoggingEnabled = false
+          result.success(null)
+        }
+        else -> result.notImplemented()
+      }
+    }
   }
 
   override fun onAttachedToActivity(binding: ActivityPluginBinding) {
-    startListeningForKeyboardChanges(binding.activity)
+    SuperKeyboardLog.d("super_keyboard", "Attached to Flutter Activity")
+    this.binding = binding
+    startListeningToActivityLifecycle()
+  }
+
+  override fun onResume(owner: LifecycleOwner) {
+    SuperKeyboardLog.d("super_keyboard", "Activity Resumed - keyboard state: $keyboardState")
+    startListeningForKeyboardChanges(binding!!)
+
+    // Specifically in the case of an app resuming, it's possible that the keyboard
+    // went from open to closed without us getting a chance to report it. Check if we're
+    // closed and if we are, tell the app.
+    val insets = ViewCompat.getRootWindowInsets(mainView!!) ?: return
+    if (insets.getInsets(WindowInsetsCompat.Type.ime()).bottom == 0 && keyboardState != KeyboardState.Closed) {
+      keyboardState = KeyboardState.Closed
+      channel.invokeMethod("keyboardClosed", null)
+    }
+  }
+
+  override fun onPause(owner: LifecycleOwner) {
+    SuperKeyboardLog.d("super_keyboard", "Activity Paused - keyboard state: $keyboardState")
+    stopListeningForKeyboardChanges()
+  }
+
+  override fun onDetachedFromActivityForConfigChanges() {
+    stopListeningToActivityLifecycle()
+    this.binding = null
   }
 
   override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
-    startListeningForKeyboardChanges(binding.activity)
+    startListeningToActivityLifecycle()
+    this.binding = binding
+  }
+
+  override fun onDetachedFromActivity() {
+    SuperKeyboardLog.d("super_keyboard", "Detached from Flutter activity")
+    stopListeningToActivityLifecycle()
+    this.binding = null
+  }
+
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    SuperKeyboardLog.d("super_keyboard", "Detached from Flutter engine")
+    this.binding = null
   }
 
-  private fun startListeningForKeyboardChanges(activity: Activity) {
+  private fun startListeningToActivityLifecycle() {
+    lifecycle = FlutterLifecycleAdapter.getActivityLifecycle(binding!!)
+    lifecycle!!.addObserver(this)
+  }
+
+  private fun stopListeningToActivityLifecycle() {
+    lifecycle!!.removeObserver(this);
+  }
+
+  private fun startListeningForKeyboardChanges(binding: ActivityPluginBinding) {
+    val activity = binding.activity
+
     mainView = activity.findViewById<ViewGroup>(android.R.id.content)
     ime = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
     if (mainView == null) {
@@ -93,8 +168,10 @@ class SuperKeyboardPlugin: FlutterPlugin, ActivityAware, OnApplyWindowInsetsList
         ) {
           // Report whether the keyboard has fully opened or fully closed.
           if (keyboardState == KeyboardState.Opening) {
+            keyboardState = KeyboardState.Open
             channel.invokeMethod("keyboardOpened", null)
           } else if (keyboardState == KeyboardState.Closing) {
+            keyboardState = KeyboardState.Closed
             channel.invokeMethod("keyboardClosed", null)
           }
         }
@@ -103,29 +180,51 @@ class SuperKeyboardPlugin: FlutterPlugin, ActivityAware, OnApplyWindowInsetsList
   }
 
   override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+    SuperKeyboardLog.d("super_keyboard", "onApplyWindowInsets()")
+    if (lifecycle!!.currentState == Lifecycle.State.CREATED) {
+      // For at least Android API 34, we receive conflicting reports about IME visibility
+      // when the app is being backgrounded. First we're told the IME isn't visible, then
+      // we're told that it is. In theory, the IME should never be visible when in the CREATED
+      // state, so we explicitly tell the app that the keyboard is closed here.
+      if (keyboardState != KeyboardState.Closed) {
+        SuperKeyboardLog.d("super_keyboard", "Activity is in CREATED state - telling app that keyboard is closed")
+        keyboardState = KeyboardState.Closed
+        channel.invokeMethod("keyboardClosed", null)
+      }
+
+      return insets
+    }
+
     val imeVisible = insets.isVisible(WindowInsetsCompat.Type.ime())
+    SuperKeyboardLog.d("super_keyboard", "Is IME visible? $imeVisible")
+    SuperKeyboardLog.d("super_keyboard", "Lifecycle state: ${lifecycle!!.currentState}")
+
+    SuperKeyboardLog.d("super_keyboard", "Insets: ${insets.getInsets(WindowInsetsCompat.Type.ime()).bottom}")
 
-    // Note: We only identify opening/closing here. The opened/closed completion
+    // Note: We primarily only identify opening/closing here. The opened/closed completion
     //       is identified by the window insets animation callback.
+    //
+    //       The exception is that when the Activity resumes, the keyboard might jump immediately
+    //       to "closed". We catch that situation by looking for a `0` bottom inset.
     if (imeVisible && keyboardState != KeyboardState.Opening && keyboardState != KeyboardState.Open) {
+      SuperKeyboardLog.d("super_keyboard", "Setting keyboard state to Opening")
       channel.invokeMethod("keyboardOpening", null)
       keyboardState = KeyboardState.Opening
     } else if (!imeVisible && keyboardState != KeyboardState.Closing && keyboardState != KeyboardState.Closed) {
-      channel.invokeMethod("keyboardClosing", null)
-      keyboardState = KeyboardState.Closing
+      if (insets.getInsets(WindowInsetsCompat.Type.ime()).bottom == 0) {
+        SuperKeyboardLog.d("super_keyboard", "Setting keyboard state to Closed")
+        channel.invokeMethod("keyboardClosed", null)
+        keyboardState = KeyboardState.Closed
+      } else {
+        SuperKeyboardLog.d("super_keyboard", "Setting keyboard state to Closing")
+        channel.invokeMethod("keyboardClosing", null)
+        keyboardState = KeyboardState.Closing
+      }
     }
 
     return insets
   }
 
-  override fun onDetachedFromActivityForConfigChanges() {
-    stopListeningForKeyboardChanges()
-  }
-
-  override fun onDetachedFromActivity() {
-    stopListeningForKeyboardChanges()
-  }
-
   private fun stopListeningForKeyboardChanges() {
     if (mainView == null) {
       return;
@@ -136,8 +235,6 @@ class SuperKeyboardPlugin: FlutterPlugin, ActivityAware, OnApplyWindowInsetsList
 
     mainView = null
   }
-
-  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {}
 }
 
 private enum class KeyboardState {

super_keyboard/example/.metadata

@@ -0,0 +1,30 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: "17025dd88227cd9532c33fa78f5250d548d87e9a"
+  channel: "stable"
+
+project_type: app
+
+# Tracks metadata for the flutter migrate command
+migration:
+  platforms:
+    - platform: root
+      create_revision: 17025dd88227cd9532c33fa78f5250d548d87e9a
+      base_revision: 17025dd88227cd9532c33fa78f5250d548d87e9a
+    - platform: android
+      create_revision: 17025dd88227cd9532c33fa78f5250d548d87e9a
+      base_revision: 17025dd88227cd9532c33fa78f5250d548d87e9a
+
+  # User provided section
+
+  # List of Local paths (relative to this file) that should be
+  # ignored by the migrate tool.
+  #
+  # Files that are not part of the templates will be ignored by default.
+  unmanaged_files:
+    - 'lib/main.dart'
+    - 'ios/Runner.xcodeproj/project.pbxproj'

super_keyboard/example/android/build.gradle

@@ -0,0 +1,18 @@
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.buildDir = "../build"
+subprojects {
+    project.buildDir = "${rootProject.buildDir}/${project.name}"
+}
+subprojects {
+    project.evaluationDependsOn(":app")
+}
+
+tasks.register("clean", Delete) {
+    delete rootProject.buildDir
+}

super_keyboard/example/android/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx4G -XX:MaxMetaspaceSize=2G -XX:+HeapDumpOnOutOfMemoryError
+android.useAndroidX=true
+android.enableJetifier=true

super_keyboard/example/android/settings.gradle

@@ -0,0 +1,25 @@
+pluginManagement {
+    def flutterSdkPath = {
+        def properties = new Properties()
+        file("local.properties").withInputStream { properties.load(it) }
+        def flutterSdkPath = properties.getProperty("flutter.sdk")
+        assert flutterSdkPath != null, "flutter.sdk not set in local.properties"
+        return flutterSdkPath
+    }()
+
+    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id "dev.flutter.flutter-plugin-loader" version "1.0.0"
+    id "com.android.application" version "8.2.2" apply false
+    id "org.jetbrains.kotlin.android" version "1.8.22" apply false
+}
+
+include ":app"

super_keyboard/example/ios/Podfile.lock

@@ -20,9 +20,9 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   Flutter: e0871f40cf51350855a761d2e70bf5af5b9b5de7
-  integration_test: 252f60fa39af5e17c3aa9899d35d908a0721b573
-  super_keyboard: 8e7a8c2e2499f32476103eb3be4069f2545fc92a
+  integration_test: 4a889634ef21a45d28d50d622cf412dc6d9f586e
+  super_keyboard: 016de6ce9ab826f9a0b185608209d6a3b556d577
 
 PODFILE CHECKSUM: 819463e6a0290f5a72f145ba7cde16e8b6ef0796
 
-COCOAPODS: 1.14.2
+COCOAPODS: 1.16.2