react-native-keyboard-controller 1.0.0-alpha.3 → 1.0.1

package/README.md

@@ -2,14 +2,11 @@
 
 Keyboard manager which works in identical way on both iOS and Android.
 
-> **Note**: This library is still in development and in `alpha` stage. So most likely it has bugs/issues - don't hesitate to report if you find them 🙂.
-
 ## Demonstration
 
-<div>
-  <img align="right" width="28.65%" style="margin-left: 20px" src="./gifs/ios.gif?raw=true">
-  <img align="right" width="30%" style="margin-left: 20px" src="./gifs/android.gif?raw=true">  
-</div>
+<img src="./gifs/demo.gif?raw=true" width="60%">
+
+## Key features
 
 - mapping keyboard appearance to animated values 😎
 - missing `keyboardWillShow` / `keyboardWillHide` events are available on Android 😍
@@ -18,8 +15,6 @@ Keyboard manager which works in identical way on both iOS and Android.
 - interactive keyboard dismissing (planned) 👆📱
 - and more is coming... Stay tuned! 😊
 
-<br clear="right" />
-
 ## Installation
 
 Install `react-native-keyboard-controller` package from npm:
@@ -30,55 +25,9 @@ yarn add react-native-keyboard-controller
 # npm install react-native-keyboard-controller --save
 ```
 
-## Usage
-
-For more comprehensive usage you can have a look on [example](https://github.com/kirillzyusko/react-native-keyboard-controller/tree/main/example).
-
-Below you can see a short overview of library API:
+## Documentation
 
-```js
-import {
-  KeyboardProvider,
-  useKeyboardAnimation,
-} from 'react-native-keyboard-controller';
-
-// 1. wrap your app in Provider
-<KeyboardProvider>
-  <AppContainer />
-</KeyboardProvider>
-
-// 2. get animation values where you need them
-const { height, progress } = useKeyboardAnimation();
-
-// 3. Animate any elements as you wish :)
-<Animated.View
-  style={{
-    width: 50,
-    height: 50,
-    backgroundColor: 'red',
-    borderRadius: 25,
-    // the element will move up with the keyboard
-    transform: [{ translateY: height }],
-  }}
-/>
-<Animated.View
-  style={{
-    width: 50,
-    height: 50,
-    backgroundColor: 'green',
-    borderRadius: 25,
-    transform: [
-      {
-        // or use custom interpolation using `progress`
-        translateX: progress.interpolate({
-          inputRange: [0, 1],
-          outputRange: [0, 100],
-        }),
-      },
-    ],
-  }}
-/>
-```
+Check out our dedicated documentation page for info about this library, API reference and more: [https://kirillzyusko.github.io/react-native-keyboard-controller/](https://kirillzyusko.github.io/react-native-keyboard-controller/)
 
 ## Contributing
 

package/android/build.gradle

@@ -41,7 +41,7 @@ android {
     }
   }
   lintOptions {
-    disable 'GradleCompatible'
+    warningsAsErrors true
   }
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_1_8

package/android/gradle.properties

@@ -1,3 +1,5 @@
 KeyboardController_kotlinVersion=1.3.50
 KeyboardController_compileSdkVersion=29
 KeyboardController_targetSdkVersion=29
+
+android.useAndroidX=true

package/android/src/main/java/com/reactnativekeyboardcontroller/EdgeToEdgeReactViewGroup.kt

@@ -1,9 +1,11 @@
 package com.reactnativekeyboardcontroller
 
+import android.annotation.SuppressLint
 import androidx.core.view.WindowCompat
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.views.view.ReactViewGroup
 
+@SuppressLint("ViewConstructor")
 class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()

package/android/src/main/java/com/reactnativekeyboardcontroller/KeyboardControllerPackage.kt

@@ -6,11 +6,11 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
 class KeyboardControllerPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(KeyboardControllerModule(reactContext))
-    }
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(KeyboardControllerModule(reactContext), StatusBarManagerCompatModule(reactContext))
+  }
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return listOf(KeyboardControllerViewManager(reactContext))
-    }
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return listOf(KeyboardControllerViewManager(reactContext))
+  }
 }

package/android/src/main/java/com/reactnativekeyboardcontroller/KeyboardControllerViewManager.kt

@@ -1,7 +1,10 @@
 package com.reactnativekeyboardcontroller
 
+import android.util.Log
 import androidx.appcompat.widget.FitWindowsLinearLayout
-import androidx.core.view.*
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.ThemedReactContext
@@ -11,6 +14,7 @@ import com.facebook.react.views.view.ReactViewManager
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
 
 class KeyboardControllerViewManager(reactContext: ReactApplicationContext) : ReactViewManager() {
+  private val TAG = KeyboardControllerViewManager::class.qualifiedName
   private var mReactContext = reactContext
   private var isStatusBarTranslucent = false
 
@@ -18,6 +22,15 @@ class KeyboardControllerViewManager(reactContext: ReactApplicationContext) : Rea
 
   override fun createViewInstance(reactContext: ThemedReactContext): ReactViewGroup {
     val view = EdgeToEdgeReactViewGroup(reactContext)
+    val activity = mReactContext.currentActivity
+
+    if (activity == null) {
+      Log.w(TAG, "Can not setup keyboard animation listener, since `currentActivity` is null")
+      return view
+    }
+
+    val window = activity.window
+    val decorView = window.decorView
 
     ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
       val content =
@@ -33,7 +46,7 @@ class KeyboardControllerViewManager(reactContext: ReactApplicationContext) : Rea
     }
 
     ViewCompat.setWindowInsetsAnimationCallback(
-      reactContext.currentActivity!!.window!!.decorView,
+      decorView,
       TranslateDeferringInsetsAnimationCallback(
         view = view,
         persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),

package/android/src/main/java/com/reactnativekeyboardcontroller/StatusBarManagerCompatModule.kt

@@ -0,0 +1,95 @@
+package com.reactnativekeyboardcontroller
+
+import android.animation.ArgbEvaluator
+import android.animation.ValueAnimator
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.UiThreadUtil
+
+class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(mReactContext) {
+  private val TAG = StatusBarManagerCompatModule::class.qualifiedName
+  private var controller: WindowInsetsControllerCompat? = null
+
+  override fun getName(): String = "StatusBarManagerCompat"
+
+  @ReactMethod
+  private fun setHidden(hidden: Boolean) {
+    UiThreadUtil.runOnUiThread {
+      if (hidden) {
+        getController()?.hide(WindowInsetsCompat.Type.statusBars())
+      } else {
+        getController()?.show(WindowInsetsCompat.Type.statusBars())
+      }
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
+  @ReactMethod
+  private fun setColor(color: Int, animated: Boolean) {
+    val activity = mReactContext.currentActivity
+    if (activity == null) {
+      Log.w(TAG, "StatusBarManagerCompatModule: Ignored status bar change, current activity is null.")
+      return
+    }
+
+    UiThreadUtil.runOnUiThread {
+      val window = activity.window
+
+      if (animated) {
+        val curColor: Int = window.statusBarColor
+        val colorAnimation = ValueAnimator.ofObject(ArgbEvaluator(), curColor, color)
+        colorAnimation.addUpdateListener { animator ->
+          window.statusBarColor = animator.animatedValue as Int
+        }
+        colorAnimation.setDuration(300).startDelay = 0
+        colorAnimation.start()
+      } else {
+        window.statusBarColor = color
+      }
+    }
+  }
+
+  @ReactMethod
+  private fun setTranslucent(translucent: Boolean) {
+    // the status bar is translucent by default (once you wrapped App in Provider,
+    // and EdgeToEdgeReactViewGroup has been mounted and called
+    // `setDecorFitsSystemWindows(window, false)`. By default this library applies default padding
+    // which equal to StatusBar height, so it will have a default RN app behavior. Though once you
+    // need to set StatusBar as translucent, you will need to use `statusBarTranslucent` prop on
+    // `KeyboardProvider` (it will preventing of applying additional padding, and status bar will be
+    // translucent. Though it's important to note, that this value is not reactive (i. e. if you change
+    // `statusBarTranslucent` in runtime it will not have any effect. Just theoretically I could make
+    // it reactive, but I know, that most of apps or don't use StatusBar translucency at all or they are
+    // specifying it for entire app, so I don't see a lot of sense to make it reactive as of now. If your
+    // app requires to dynamically manage it - just shoot an issue and I will try to add a support fot that.
+  }
+
+  @ReactMethod
+  private fun setStyle(style: String) {
+    UiThreadUtil.runOnUiThread {
+      getController()?.isAppearanceLightStatusBars = style == "dark-content"
+    }
+  }
+
+  private fun getController(): WindowInsetsControllerCompat? {
+    if (this.controller == null) {
+      val activity = mReactContext.currentActivity
+      if (activity == null) {
+        Log.w(TAG, "StatusBarManagerCompatModule: can not get `WindowInsetsControllerCompat` because current activity is null.")
+        return this.controller
+      }
+
+      val window = activity.window
+
+      this.controller = WindowInsetsControllerCompat(window, window.decorView)
+    }
+
+    return this.controller
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/TranslateDeferringInsetsAnimationCallback.kt

@@ -31,7 +31,13 @@ import com.facebook.react.views.view.ReactViewGroup
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
 import java.util.*
 
-fun toDp(px: Float, context: Context): Int = (px / context.resources.displayMetrics.density).toInt()
+fun toDp(px: Float, context: Context?): Int {
+  if (context == null) {
+    return 0
+  }
+
+  return (px / context.resources.displayMetrics.density).toInt()
+}
 
 /**
  * A [WindowInsetsAnimationCompat.Callback] which will translate/move the given view during any
@@ -61,10 +67,10 @@ class TranslateDeferringInsetsAnimationCallback(
   private var persistentKeyboardHeight = 0
 
   init {
-      require(persistentInsetTypes and deferredInsetTypes == 0) {
-          "persistentInsetTypes and deferredInsetTypes can not contain any of " +
-                  " same WindowInsetsCompat.Type values"
-      }
+    require(persistentInsetTypes and deferredInsetTypes == 0) {
+      "persistentInsetTypes and deferredInsetTypes can not contain any of " +
+        " same WindowInsetsCompat.Type values"
+    }
   }
 
   override fun onStart(
@@ -81,9 +87,9 @@ class TranslateDeferringInsetsAnimationCallback(
 
     val params: WritableMap = Arguments.createMap()
     params.putInt("height", keyboardHeight)
-    context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit("KeyboardController::" + if(!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow", params)
+    context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit("KeyboardController::" + if (!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow", params)
 
-    Log.i(TAG, "KeyboardController::" + if(!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow")
+    Log.i(TAG, "KeyboardController::" + if (!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow")
     Log.i(TAG, "HEIGHT:: $keyboardHeight")
 
     return super.onStart(animation, bounds)
@@ -95,9 +101,9 @@ class TranslateDeferringInsetsAnimationCallback(
     val isKeyboardVisible = isKeyboardVisible()
 
     val params: WritableMap = Arguments.createMap()
-    context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit("KeyboardController::" + if(!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow", params)
+    context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit("KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow", params)
 
-    Log.i(TAG, "KeyboardController::" + if(!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow")
+    Log.i(TAG, "KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow")
   }
 
   private fun isKeyboardVisible(): Boolean {
@@ -112,41 +118,41 @@ class TranslateDeferringInsetsAnimationCallback(
     val navigationBar = insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom ?: 0
 
     // on hide it will be negative value, so we are using max function
-    return Math.max(toDp((keyboardHeight - navigationBar).toFloat(), context!!), 0)
+    return Math.max(toDp((keyboardHeight - navigationBar).toFloat(), context), 0)
   }
 
-    override fun onProgress(
-        insets: WindowInsetsCompat,
-        runningAnimations: List<WindowInsetsAnimationCompat>
-    ): WindowInsetsCompat {
-        // onProgress() is called when any of the running animations progress...
-
-        // First we get the insets which are potentially deferred
-        val typesInset = insets.getInsets(deferredInsetTypes)
-        // Then we get the persistent inset types which are applied as padding during layout
-        val otherInset = insets.getInsets(persistentInsetTypes)
-
-        // Now that we subtract the two insets, to calculate the difference. We also coerce
-        // the insets to be >= 0, to make sure we don't use negative insets.
-        val diff = Insets.subtract(typesInset, otherInset).let {
-            Insets.max(it, Insets.NONE)
-        }
-        val diffY = (diff.top - diff.bottom).toFloat()
-        val height = toDp(diffY, context!!)
-
-        var progress = 0.0
-        try {
-          progress = Math.abs((height.toDouble() / persistentKeyboardHeight))
-        } catch (e: ArithmeticException) {
-          // do nothing, send progress as 0
-        }
-        Log.i(TAG, "DiffY: $diffY $height")
-
-        context
-          .getNativeModule(UIManagerModule::class.java)
-          ?.eventDispatcher
-          ?.dispatchEvent(KeyboardTransitionEvent(view.id, height, progress))
-
-        return insets
+  override fun onProgress(
+    insets: WindowInsetsCompat,
+    runningAnimations: List<WindowInsetsAnimationCompat>
+  ): WindowInsetsCompat {
+    // onProgress() is called when any of the running animations progress...
+
+    // First we get the insets which are potentially deferred
+    val typesInset = insets.getInsets(deferredInsetTypes)
+    // Then we get the persistent inset types which are applied as padding during layout
+    val otherInset = insets.getInsets(persistentInsetTypes)
+
+    // Now that we subtract the two insets, to calculate the difference. We also coerce
+    // the insets to be >= 0, to make sure we don't use negative insets.
+    val diff = Insets.subtract(typesInset, otherInset).let {
+      Insets.max(it, Insets.NONE)
     }
+    val diffY = (diff.top - diff.bottom).toFloat()
+    val height = toDp(diffY, context)
+
+    var progress = 0.0
+    try {
+      progress = Math.abs((height.toDouble() / persistentKeyboardHeight))
+    } catch (e: ArithmeticException) {
+      // do nothing, send progress as 0
+    }
+    Log.i(TAG, "DiffY: $diffY $height")
+
+    context
+      ?.getNativeModule(UIManagerModule::class.java)
+      ?.eventDispatcher
+      ?.dispatchEvent(KeyboardTransitionEvent(view.id, height, progress))
+
+    return insets
+  }
 }

package/ios/.swift-version

@@ -0,0 +1 @@
+5.6

package/ios/.swiftformat

@@ -0,0 +1,5 @@
+--indent 2
+
+--disable redundantReturn
+
+--exclude Pods,Generated

package/ios/.swiftlint.yml

@@ -0,0 +1,5 @@
+disabled_rules:
+  - trailing_comma
+
+excluded:
+  - Pods

package/ios/KeyboardControllerModule.swift

@@ -6,15 +6,15 @@
 //  Copyright © 2022 Facebook. All rights reserved.
 //
 
+import AVFoundation
 import Foundation
 import UIKit
-import AVFoundation
 
 @objc(KeyboardController)
 class KeyboardController: RCTEventEmitter {
   public static var shared: KeyboardController?
   private var hasListeners = false
-    
+
   override class func requiresMainQueueSetup() -> Bool {
     return false
   }
@@ -25,29 +25,29 @@ class KeyboardController: RCTEventEmitter {
   }
 
   // Android stubs
-  @objc func setInputMode(_ mode: NSNumber!) {}
+  @objc func setInputMode(_: NSNumber!) {}
   @objc func setDefaultMode() {}
-    
-  @objc open override func supportedEvents() -> [String] {
+
+  @objc override open func supportedEvents() -> [String] {
     return [
-        "KeyboardController::keyboardWillShow",
-        "KeyboardController::keyboardDidShow",
-        "KeyboardController::keyboardWillHide",
-        "KeyboardController::keyboardDidHide"
+      "KeyboardController::keyboardWillShow",
+      "KeyboardController::keyboardDidShow",
+      "KeyboardController::keyboardWillHide",
+      "KeyboardController::keyboardDidHide",
     ]
   }
-    
-  @objc open override func startObserving() {
+
+  @objc override open func startObserving() {
     hasListeners = true
   }
-    
-  @objc open override func stopObserving() {
+
+  @objc override open func stopObserving() {
     hasListeners = false
   }
-    
-  @objc open override func sendEvent(withName name: String!, body: Any!) {
-    if (hasListeners) {
-        super.sendEvent(withName: name, body: body)
+
+  @objc override open func sendEvent(withName name: String!, body: Any!) {
+    if hasListeners {
+      super.sendEvent(withName: name, body: body)
     }
   }
 }

package/ios/KeyboardControllerViewManager.swift

@@ -5,74 +5,102 @@ class KeyboardControllerViewManager: RCTViewManager {
   }
 
   override func view() -> (KeyboardControllerView) {
-      return KeyboardControllerView(frame: CGRect.zero, eventDispatcher: self.bridge.eventDispatcher())
+    return KeyboardControllerView(frame: CGRect.zero, eventDispatcher: bridge.eventDispatcher())
   }
 }
 
-class KeyboardControllerView : UIView {
-    private var eventDispatcher: RCTEventDispatcherProtocol
-    @objc var onKeyboardMove: RCTDirectEventBlock?
-    
-    init(frame: CGRect, eventDispatcher: RCTEventDispatcherProtocol) {
-        self.eventDispatcher = eventDispatcher
-        super.init(frame: frame)
-    }
-    
-    required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-    
-    override func willMove(toWindow newWindow: UIWindow?) {
-        if (newWindow == nil) {
-            // Will be removed from a window
-            NotificationCenter.default.removeObserver(self)
-        }
-    }
-    
-    override func didMoveToWindow() {
-        if (self.window != nil) {
-            // Added to a window
-            NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillDisappear), name: UIResponder.keyboardWillHideNotification, object: nil)
-            NotificationCenter.default.addObserver(self, selector: #selector(keyboardWillAppear), name: UIResponder.keyboardWillShowNotification, object: nil)
-            NotificationCenter.default.addObserver(self, selector: #selector(keyboardDidAppear), name: UIResponder.keyboardDidShowNotification, object: nil)
-            NotificationCenter.default.addObserver(self, selector: #selector(keyboardDidDisappear), name: UIResponder.keyboardDidHideNotification, object: nil)
-        }
-    }
+class KeyboardControllerView: UIView {
+  private var eventDispatcher: RCTEventDispatcherProtocol
+  @objc var onKeyboardMove: RCTDirectEventBlock?
 
-    @objc func keyboardWillAppear(_ notification: Notification) {
-        if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
-            let keyboardHeight = keyboardFrame.cgRectValue.size.height
+  init(frame: CGRect, eventDispatcher: RCTEventDispatcherProtocol) {
+    self.eventDispatcher = eventDispatcher
+    super.init(frame: frame)
+  }
 
-            self.eventDispatcher.send(KeyboardMoveEvent(reactTag: self.reactTag, height: -keyboardHeight as NSNumber, progress: 1))
+  @available(*, unavailable)
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
 
-            var data = [AnyHashable: Any]()
-            data["height"] = keyboardHeight
-            KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardWillShow", body: data)
-        }
+  override func willMove(toWindow newWindow: UIWindow?) {
+    if newWindow == nil {
+      // Will be removed from a window
+      // swiftlint:disable notification_center_detachment
+      NotificationCenter.default.removeObserver(self)
     }
+  }
 
-    @objc func keyboardWillDisappear() {
-        self.eventDispatcher.send(KeyboardMoveEvent(reactTag: self.reactTag, height: 0, progress: 0))
-        
-        var data = [AnyHashable: Any]()
-        data["height"] = 0
-        KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardWillHide", body: data)
+  override func didMoveToWindow() {
+    if window != nil {
+      // Added to a window
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(keyboardWillDisappear),
+        name: UIResponder.keyboardWillHideNotification,
+        object: nil
+      )
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(keyboardWillAppear),
+        name: UIResponder.keyboardWillShowNotification,
+        object: nil
+      )
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(keyboardDidAppear),
+        name: UIResponder.keyboardDidShowNotification,
+        object: nil
+      )
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(keyboardDidDisappear),
+        name: UIResponder.keyboardDidHideNotification,
+        object: nil
+      )
     }
-    
-    @objc func keyboardDidAppear(_ notification: Notification) {
-        if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
-            let keyboardHeight = keyboardFrame.cgRectValue.size.height
-            
-            var data = [AnyHashable: Any]()
-            data["height"] = keyboardHeight
-            
-            KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardDidShow", body: data)
-        }
+  }
+
+  @objc func keyboardWillAppear(_ notification: Notification) {
+    if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
+      let keyboardHeight = keyboardFrame.cgRectValue.size.height
+
+      eventDispatcher.send(
+        KeyboardMoveEvent(
+          viewTag: reactTag,
+          height: -keyboardHeight as NSNumber,
+          progress: 1
+        )
+      )
+
+      var data = [AnyHashable: Any]()
+      data["height"] = keyboardHeight
+      KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardWillShow", body: data)
     }
-    
-    @objc func keyboardDidDisappear() {
-        var data = [AnyHashable: Any]()
-        data["height"] = 0
-        KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardDidHide", body: data)
+  }
+
+  @objc func keyboardWillDisappear() {
+    eventDispatcher.send(KeyboardMoveEvent(viewTag: reactTag, height: 0, progress: 0))
+
+    var data = [AnyHashable: Any]()
+    data["height"] = 0
+    KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardWillHide", body: data)
+  }
+
+  @objc func keyboardDidAppear(_ notification: Notification) {
+    if let keyboardFrame: NSValue = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? NSValue {
+      let keyboardHeight = keyboardFrame.cgRectValue.size.height
+
+      var data = [AnyHashable: Any]()
+      data["height"] = keyboardHeight
+
+      KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardDidShow", body: data)
     }
+  }
+
+  @objc func keyboardDidDisappear() {
+    var data = [AnyHashable: Any]()
+    data["height"] = 0
+    KeyboardController.shared?.sendEvent(withName: "KeyboardController::keyboardDidHide", body: data)
+  }
 }