react-native-universal-keyboard-aware-scrollview 1.0.0

package/android/src/main/java/com/universalkeyboard/UniversalKeyboardModule.kt

@@ -0,0 +1,349 @@
+package com.universalkeyboard
+
+import android.app.Activity
+import android.graphics.Rect
+import android.os.Build
+import android.util.DisplayMetrics
+import android.view.View
+import android.view.ViewTreeObserver
+import android.view.WindowInsets
+import android.view.WindowManager
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.lang.ref.WeakReference
+
+/**
+ * UniversalKeyboardModule - Native Android module for detecting keyboard height changes.
+ * 
+ * This module provides reliable keyboard detection that works in:
+ * - Normal React Native screens
+ * - React Native Modal components
+ * - BottomSheet components
+ * - Any overlay/dialog scenarios
+ * 
+ * It uses the GlobalLayoutListener approach which is the most reliable method
+ * for detecting keyboard visibility on Android, as it measures the actual
+ * visible window frame.
+ */
+class UniversalKeyboardModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+
+    companion object {
+        const val MODULE_NAME = "UniversalKeyboard"
+        const val EVENT_KEYBOARD_DID_SHOW = "keyboardDidShow"
+        const val EVENT_KEYBOARD_DID_HIDE = "keyboardDidHide"
+        const val EVENT_KEYBOARD_HEIGHT_CHANGED = "keyboardHeightChanged"
+        
+        // Threshold for keyboard detection (200dp is a reasonable minimum keyboard height)
+        private const val KEYBOARD_MIN_HEIGHT_DP = 100
+    }
+    
+    private var globalLayoutListener: ViewTreeObserver.OnGlobalLayoutListener? = null
+    private var rootView: WeakReference<View>? = null
+    private var lastKeyboardHeight = 0
+    private var isKeyboardVisible = false
+    private var hasListeners = false
+    private var screenHeight = 0
+    
+    override fun getName(): String = MODULE_NAME
+    
+    override fun initialize() {
+        super.initialize()
+        reactContext.addLifecycleEventListener(this)
+    }
+    
+    override fun invalidate() {
+        removeKeyboardListener()
+        reactContext.removeLifecycleEventListener(this)
+        super.invalidate()
+    }
+    
+    // Lifecycle events
+    override fun onHostResume() {
+        if (hasListeners) {
+            setupKeyboardListener()
+        }
+    }
+    
+    override fun onHostPause() {
+        // Keep listener active during pause for modals
+    }
+    
+    override fun onHostDestroy() {
+        removeKeyboardListener()
+    }
+    
+    /**
+     * Start listening for keyboard events.
+     * This method MUST be called from JS before keyboard events will be emitted.
+     */
+    @ReactMethod
+    fun startListening(promise: Promise) {
+        hasListeners = true
+        
+        UiThreadUtil.runOnUiThread {
+            try {
+                setupKeyboardListener()
+                promise.resolve(true)
+            } catch (e: Exception) {
+                promise.reject("ERROR", "Failed to start keyboard listener: ${e.message}")
+            }
+        }
+    }
+    
+    /**
+     * Stop listening for keyboard events.
+     * Call this when the component unmounts to prevent memory leaks.
+     */
+    @ReactMethod
+    fun stopListening(promise: Promise) {
+        hasListeners = false
+        
+        UiThreadUtil.runOnUiThread {
+            try {
+                removeKeyboardListener()
+                promise.resolve(true)
+            } catch (e: Exception) {
+                promise.reject("ERROR", "Failed to stop keyboard listener: ${e.message}")
+            }
+        }
+    }
+    
+    /**
+     * Get the current keyboard height synchronously.
+     */
+    @ReactMethod
+    fun getKeyboardHeight(promise: Promise) {
+        promise.resolve(lastKeyboardHeight.toDouble() / getScreenDensity())
+    }
+    
+    /**
+     * Check if the keyboard is currently visible.
+     */
+    @ReactMethod
+    fun isKeyboardVisible(promise: Promise) {
+        promise.resolve(isKeyboardVisible)
+    }
+    
+    /**
+     * Force dismiss the keyboard.
+     */
+    @ReactMethod
+    fun dismissKeyboard(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                val activity = currentActivity
+                if (activity != null) {
+                    val view = activity.currentFocus
+                    if (view != null) {
+                        val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as android.view.inputmethod.InputMethodManager
+                        imm.hideSoftInputFromWindow(view.windowToken, 0)
+                    }
+                }
+                promise.resolve(true)
+            } catch (e: Exception) {
+                promise.reject("ERROR", "Failed to dismiss keyboard: ${e.message}")
+            }
+        }
+    }
+    
+    /**
+     * Get the screen density for converting pixels to density-independent pixels.
+     */
+    private fun getScreenDensity(): Float {
+        return reactContext.resources.displayMetrics.density
+    }
+    
+    /**
+     * Get the minimum keyboard height in pixels based on screen density.
+     */
+    private fun getMinKeyboardHeightPx(): Int {
+        return (KEYBOARD_MIN_HEIGHT_DP * getScreenDensity()).toInt()
+    }
+    
+    /**
+     * Sets up the global layout listener to detect keyboard visibility changes.
+     * This is the core mechanism for reliable keyboard detection on Android.
+     */
+    private fun setupKeyboardListener() {
+        val activity = currentActivity ?: return
+        
+        // Get the root decorView
+        val decorView = activity.window.decorView
+        val contentView = decorView.findViewById<View>(android.R.id.content) ?: return
+        
+        rootView = WeakReference(contentView)
+        
+        // Store the full screen height
+        val displayMetrics = DisplayMetrics()
+        @Suppress("DEPRECATION")
+        activity.windowManager.defaultDisplay.getMetrics(displayMetrics)
+        screenHeight = displayMetrics.heightPixels
+        
+        // Remove any existing listener
+        removeKeyboardListener()
+        
+        globalLayoutListener = ViewTreeObserver.OnGlobalLayoutListener {
+            measureKeyboardHeight()
+        }
+        
+        contentView.viewTreeObserver.addOnGlobalLayoutListener(globalLayoutListener)
+    }
+    
+    /**
+     * Measures the keyboard height by comparing the visible window frame
+     * with the root view's height.
+     */
+    private fun measureKeyboardHeight() {
+        val view = rootView?.get() ?: return
+        val activity = currentActivity ?: return
+        
+        val visibleFrame = Rect()
+        view.getWindowVisibleDisplayFrame(visibleFrame)
+        
+        val keyboardHeight: Int
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            // Android 11+ uses WindowInsets for more accurate keyboard detection
+            val rootWindowInsets = view.rootWindowInsets
+            if (rootWindowInsets != null) {
+                val imeInsets = rootWindowInsets.getInsets(WindowInsets.Type.ime())
+                val navigationBarInsets = rootWindowInsets.getInsets(WindowInsets.Type.navigationBars())
+                
+                // The keyboard height is the IME inset minus the navigation bar
+                // because IME insets include the navigation bar
+                keyboardHeight = imeInsets.bottom - if (imeInsets.bottom > 0) 0 else navigationBarInsets.bottom
+            } else {
+                keyboardHeight = calculateKeyboardHeightLegacy(view, visibleFrame)
+            }
+        } else {
+            keyboardHeight = calculateKeyboardHeightLegacy(view, visibleFrame)
+        }
+        
+        handleKeyboardHeightChange(keyboardHeight)
+    }
+    
+    /**
+     * Legacy method for calculating keyboard height on Android < 11.
+     */
+    private fun calculateKeyboardHeightLegacy(view: View, visibleFrame: Rect): Int {
+        val activity = currentActivity ?: return 0
+        
+        // Get the screen height including system bars
+        val displayMetrics = DisplayMetrics()
+        @Suppress("DEPRECATION")
+        activity.windowManager.defaultDisplay.getRealMetrics(displayMetrics)
+        val screenHeight = displayMetrics.heightPixels
+        
+        // The keyboard height is the difference between screen height and visible frame bottom
+        // We need to account for the navigation bar as well
+        val navBarHeight = getNavigationBarHeight()
+        
+        // Calculate content height difference
+        val heightDiff = screenHeight - visibleFrame.bottom
+        
+        // If the difference is greater than our threshold, keyboard is visible
+        return if (heightDiff > getMinKeyboardHeightPx()) {
+            heightDiff - navBarHeight
+        } else {
+            0
+        }
+    }
+    
+    /**
+     * Get the navigation bar height for proper keyboard height calculation.
+     */
+    private fun getNavigationBarHeight(): Int {
+        val activity = currentActivity ?: return 0
+        
+        val resourceId = reactContext.resources.getIdentifier(
+            "navigation_bar_height",
+            "dimen",
+            "android"
+        )
+        
+        return if (resourceId > 0) {
+            reactContext.resources.getDimensionPixelSize(resourceId)
+        } else {
+            0
+        }
+    }
+    
+    /**
+     * Handles keyboard height changes and emits appropriate events.
+     */
+    private fun handleKeyboardHeightChange(keyboardHeightPx: Int) {
+        val density = getScreenDensity()
+        val keyboardHeightDp = (keyboardHeightPx / density).toInt()
+        
+        val minHeight = KEYBOARD_MIN_HEIGHT_DP
+        val keyboardNowVisible = keyboardHeightDp >= minHeight
+        
+        // Always emit height change if it's different
+        if (keyboardHeightPx != lastKeyboardHeight) {
+            lastKeyboardHeight = keyboardHeightPx
+            sendEvent(EVENT_KEYBOARD_HEIGHT_CHANGED, createKeyboardEventData(keyboardHeightDp))
+        }
+        
+        // Emit show/hide events
+        if (keyboardNowVisible && !isKeyboardVisible) {
+            isKeyboardVisible = true
+            sendEvent(EVENT_KEYBOARD_DID_SHOW, createKeyboardEventData(keyboardHeightDp))
+        } else if (!keyboardNowVisible && isKeyboardVisible) {
+            isKeyboardVisible = false
+            lastKeyboardHeight = 0
+            sendEvent(EVENT_KEYBOARD_DID_HIDE, createKeyboardEventData(0))
+        }
+    }
+    
+    /**
+     * Creates the event data payload for keyboard events.
+     */
+    private fun createKeyboardEventData(keyboardHeight: Int): WritableMap {
+        val params = Arguments.createMap()
+        params.putDouble("height", keyboardHeight.toDouble())
+        params.putBoolean("isVisible", keyboardHeight > 0)
+        params.putDouble("screenHeight", screenHeight / getScreenDensity().toDouble())
+        params.putDouble("timestamp", System.currentTimeMillis().toDouble())
+        return params
+    }
+    
+    /**
+     * Sends an event to JavaScript.
+     */
+    private fun sendEvent(eventName: String, params: WritableMap) {
+        if (!hasListeners) return
+        
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            ?.emit(eventName, params)
+    }
+    
+    /**
+     * Removes the global layout listener to prevent memory leaks.
+     */
+    private fun removeKeyboardListener() {
+        globalLayoutListener?.let { listener ->
+            rootView?.get()?.viewTreeObserver?.let { observer ->
+                if (observer.isAlive) {
+                    observer.removeOnGlobalLayoutListener(listener)
+                }
+            }
+        }
+        globalLayoutListener = null
+        rootView = null
+    }
+    
+    /**
+     * Required for TurboModule support - indicates this module requires main queue setup.
+     */
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for RN built-in event emitter
+    }
+    
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for RN built-in event emitter
+    }
+}

package/android/src/main/java/com/universalkeyboard/UniversalKeyboardPackage.kt

@@ -0,0 +1,21 @@
+package com.universalkeyboard
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native Package that registers the UniversalKeyboard native module.
+ * This package is automatically linked by React Native's autolinking feature.
+ */
+class UniversalKeyboardPackage : ReactPackage {
+    
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(UniversalKeyboardModule(reactContext))
+    }
+    
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/ios/.xcode.env

@@ -0,0 +1,11 @@
+# This `.xcode.env` file is versioned and is used to source the environment
+# used when running script phases inside Xcode.
+# To customize your local environment, you can create an `.xcode.env.local`
+# file that is not versioned.
+
+# NODE_BINARY variable contains the PATH to the node executable.
+#
+# Customize the NODE_BINARY variable here.
+# For example, to use nvm with brew, add the following line
+# . "$(brew --prefix nvm)/nvm.sh" --no-use
+export NODE_BINARY=$(command -v node)

package/ios/Podfile

@@ -0,0 +1,60 @@
+require File.join(File.dirname(`node --print "require.resolve('expo/package.json')"`), "scripts/autolinking")
+require File.join(File.dirname(`node --print "require.resolve('react-native/package.json')"`), "scripts/react_native_pods")
+
+require 'json'
+podfile_properties = JSON.parse(File.read(File.join(__dir__, 'Podfile.properties.json'))) rescue {}
+
+def ccache_enabled?(podfile_properties)
+  # Environment variable takes precedence
+  return ENV['USE_CCACHE'] == '1' if ENV['USE_CCACHE']
+  
+  # Fall back to Podfile properties
+  podfile_properties['apple.ccacheEnabled'] == 'true'
+end
+
+ENV['RCT_NEW_ARCH_ENABLED'] ||= '0' if podfile_properties['newArchEnabled'] == 'false'
+ENV['EX_DEV_CLIENT_NETWORK_INSPECTOR'] ||= podfile_properties['EX_DEV_CLIENT_NETWORK_INSPECTOR']
+ENV['RCT_USE_RN_DEP'] ||= '1' if podfile_properties['ios.buildReactNativeFromSource'] != 'true' && podfile_properties['newArchEnabled'] != 'false'
+ENV['RCT_USE_PREBUILT_RNCORE'] ||= '1' if podfile_properties['ios.buildReactNativeFromSource'] != 'true' && podfile_properties['newArchEnabled'] != 'false'
+platform :ios, podfile_properties['ios.deploymentTarget'] || '15.1'
+
+prepare_react_native_project!
+
+target 'reactnativeuniversalkeyboardawarescrollview' do
+  use_expo_modules!
+
+  if ENV['EXPO_USE_COMMUNITY_AUTOLINKING'] == '1'
+    config_command = ['node', '-e', "process.argv=['', '', 'config'];require('@react-native-community/cli').run()"];
+  else
+    config_command = [
+      'npx',
+      'expo-modules-autolinking',
+      'react-native-config',
+      '--json',
+      '--platform',
+      'ios'
+    ]
+  end
+
+  config = use_native_modules!(config_command)
+
+  use_frameworks! :linkage => podfile_properties['ios.useFrameworks'].to_sym if podfile_properties['ios.useFrameworks']
+  use_frameworks! :linkage => ENV['USE_FRAMEWORKS'].to_sym if ENV['USE_FRAMEWORKS']
+
+  use_react_native!(
+    :path => config[:reactNativePath],
+    :hermes_enabled => podfile_properties['expo.jsEngine'] == nil || podfile_properties['expo.jsEngine'] == 'hermes',
+    # An absolute path to your application root.
+    :app_path => "#{Pod::Config.instance.installation_root}/..",
+    :privacy_file_aggregation_enabled => podfile_properties['apple.privacyManifestAggregationEnabled'] != 'false',
+  )
+
+  post_install do |installer|
+    react_native_post_install(
+      installer,
+      config[:reactNativePath],
+      :mac_catalyst_enabled => false,
+      :ccache_enabled => ccache_enabled?(podfile_properties),
+    )
+  end
+end