react-native-keyboard-controller 1.0.1 → 1.2.0

package/android/build.gradle

@@ -14,9 +14,6 @@ buildscript {
   }
 }
 
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
-
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['KeyboardController_' + name]
 }
@@ -25,6 +22,22 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['KeyboardController_' + name]).toInteger()
 }
 
+def isNewArchitectureEnabled() {
+  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
 android {
   compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
   defaultConfig {
@@ -32,7 +45,53 @@ android {
     targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
     versionCode 1
     versionName "1.0"
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    if (isNewArchitectureEnabled()) {
+      var appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+      externalNativeBuild {
+        ndkBuild {
+          arguments "APP_PLATFORM=android-21",
+                  "APP_STL=c++_shared",
+                  "NDK_TOOLCHAIN_VERSION=clang",
+                  "GENERATED_SRC_DIR=${appProject.buildDir}/generated/source",
+                  "PROJECT_BUILD_DIR=${appProject.buildDir}",
+                  "REACT_ANDROID_DIR=${appProject.rootDir}/../node_modules/react-native/ReactAndroid",
+                  "REACT_ANDROID_BUILD_DIR=${appProject.rootDir}/../node_modules/react-native/ReactAndroid/build"
+          cFlags "-Wall", "-Werror", "-fexceptions", "-frtti", "-DWITH_INSPECTOR=1"
+          cppFlags "-std=c++17"
+          targets "reactnativekeyboardcontroller_modules"
+        }
+      }
+    }
+    ndk {
+      abiFilters (*reactNativeArchitectures())
+    }
+  }
 
+  if (isNewArchitectureEnabled()) {
+    externalNativeBuild {
+      ndkBuild {
+        path "src/main/jni/Android.mk"
+      }
+    }
+
+    packagingOptions {
+      exclude "**/libreact_render_*.so"
+      exclude "**/librrc_root.so"
+    }
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          'src/fabric',
+          'build/generated/source/codegen/java'
+        ]
+      } else {
+        java.srcDirs += ['src/paper']
+      }
+    }
   }
 
   buildTypes {
@@ -127,3 +186,13 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation 'androidx.core:core-ktx:1.5.0-beta03'
 }
+
+if (isNewArchitectureEnabled()) {
+  react {
+    reactNativeDir = rootProject.file("../node_modules/react-native/")
+    jsRootDir = file("../src/")
+    codegenDir = rootProject.file("../node_modules/react-native-codegen/")
+    libraryName = "reactnativekeyboardcontroller"
+    codegenJavaPackageName = "com.reactnativekeyboardcontroller"
+  }
+}

package/android/gradle.properties

@@ -1,4 +1,4 @@
-KeyboardController_kotlinVersion=1.3.50
+KeyboardController_kotlinVersion=1.6.21
 KeyboardController_compileSdkVersion=29
 KeyboardController_targetSdkVersion=29
 

package/android/src/fabric/java/com/reactnativekeyboardcontroller/KeyboardControllerComponentsRegistry.kt

@@ -0,0 +1,31 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.fabric.ComponentFactory
+import com.facebook.soloader.SoLoader
+
+@DoNotStrip
+class KeyboardControllerComponentsRegistry @DoNotStrip private constructor(componentFactory: ComponentFactory) {
+  companion object {
+    @DoNotStrip
+    fun register(componentFactory: ComponentFactory): KeyboardControllerComponentsRegistry {
+      return KeyboardControllerComponentsRegistry(componentFactory)
+    }
+
+    init {
+      SoLoader.loadLibrary("fabricjni")
+      SoLoader.loadLibrary("reactnativekeyboardcontroller_modules")
+    }
+  }
+
+  @DoNotStrip
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  private external fun initHybrid(componentFactory: ComponentFactory): HybridData
+
+  init {
+    mHybridData = initHybrid(componentFactory)
+  }
+}

package/android/src/fabric/java/com/reactnativekeyboardcontroller/KeyboardControllerModule.kt

@@ -0,0 +1,25 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+class KeyboardControllerModule(mReactContext: ReactApplicationContext) : NativeKeyboardControllerSpec(mReactContext) {
+  private val module = KeyboardControllerModuleImpl(mReactContext)
+
+  override fun getName(): String = KeyboardControllerModuleImpl.NAME
+
+  override fun setInputMode(mode: Double) {
+    module.setInputMode(mode.toInt())
+  }
+
+  override fun setDefaultMode() {
+    module.setDefaultMode()
+  }
+
+  override fun addListener(eventName: String?) {
+    /* Required for RN built-in Event Emitter Calls. */
+  }
+
+  override fun removeListeners(count: Double) {
+    /* Required for RN built-in Event Emitter Calls. */
+  }
+}

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

@@ -0,0 +1,32 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.KeyboardControllerViewManagerDelegate
+import com.facebook.react.viewmanagers.KeyboardControllerViewManagerInterface
+import com.facebook.react.views.view.ReactViewGroup
+import com.facebook.react.views.view.ReactViewManager
+
+class KeyboardControllerViewManager(mReactContext: ReactApplicationContext) : ReactViewManager(), KeyboardControllerViewManagerInterface<ReactViewGroup> {
+  private val manager = KeyboardControllerViewManagerImpl(mReactContext)
+  private val mDelegate = KeyboardControllerViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<ReactViewGroup?> {
+    return mDelegate
+  }
+
+  override fun getName(): String = KeyboardControllerViewManagerImpl.NAME
+
+  override fun createViewInstance(context: ThemedReactContext): ReactViewGroup {
+    return manager.createViewInstance(context)
+  }
+
+  override fun setStatusBarTranslucent(view: ReactViewGroup, value: Boolean) {
+    return manager.setStatusBarTranslucent(view, value)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    return manager.getExportedCustomDirectEventTypeConstants()
+  }
+}

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

@@ -0,0 +1,25 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationContext) : NativeStatusBarManagerCompatSpec(mReactContext) {
+  private val module = StatusBarManagerCompatImpl(mReactContext)
+
+  override fun getName(): String = StatusBarManagerCompatImpl.NAME
+
+  override fun setHidden(hidden: Boolean) {
+    module.setHidden(hidden)
+  }
+
+  override fun setColor(color: Double, animated: Boolean) {
+    module.setColor(color.toInt(), animated)
+  }
+
+  override fun setTranslucent(translucent: Boolean) {
+    module.setTranslucent(translucent)
+  }
+
+  override fun setStyle(style: String) {
+    module.setStyle(style)
+  }
+}

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

@@ -0,0 +1,188 @@
+package com.reactnativekeyboardcontroller
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import android.view.View
+import androidx.core.animation.doOnEnd
+import androidx.core.graphics.Insets
+import androidx.core.view.OnApplyWindowInsetsListener
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.view.ReactViewGroup
+import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
+
+fun toDp(px: Float, context: Context?): Int {
+  if (context == null) {
+    return 0
+  }
+
+  return (px / context.resources.displayMetrics.density).toInt()
+}
+
+class KeyboardAnimationCallback(
+  val view: ReactViewGroup,
+  val persistentInsetTypes: Int,
+  val deferredInsetTypes: Int,
+  dispatchMode: Int = DISPATCH_MODE_STOP,
+  val context: ReactApplicationContext?,
+  val onApplyWindowInsetsListener: OnApplyWindowInsetsListener
+) : WindowInsetsAnimationCompat.Callback(dispatchMode), OnApplyWindowInsetsListener {
+  private val TAG = KeyboardAnimationCallback::class.qualifiedName
+  private var persistentKeyboardHeight = 0
+  private var isKeyboardVisible = false
+  private var isTransitioning = false
+
+  init {
+    require(persistentInsetTypes and deferredInsetTypes == 0) {
+      "persistentInsetTypes and deferredInsetTypes can not contain any of " +
+        " same WindowInsetsCompat.Type values"
+    }
+  }
+
+  /**
+   * When keyboard changes its size we have different behavior per APIs.
+   * On 21<=API<30 - WindowInsetsAnimationCompat dispatches onStart/onProgress/onEnd events.
+   * On API>=30 - WindowInsetsAnimationCompat doesn't dispatch anything. As a result behavior
+   * between different Android versions is not consistent. On old Android versions we have a
+   * reaction, on newer versions - not. In my understanding it's a bug in core library and the
+   * behavior should be consistent across all versions of platform. To level the difference we
+   * have to implement `onApplyWindowInsets` listener and simulate onStart/onProgress/onEnd
+   * events when keyboard changes its size.
+   * In the method below we fully recreate the logic that is implemented on old android versions:
+   * - we dispatch `keyboardWillShow` (onStart);
+   * - we dispatch change height/progress as animated values (onProgress);
+   * - we dispatch `keyboardDidShow` (onEnd).
+   */
+  override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+    // when keyboard appears values will be (false && true)
+    // when keyboard disappears values will be (true && false)
+    // `!isTransitioning` check is needed to avoid calls of `onApplyWindowInsets` during keyboard animation
+    // having such check allows us not to dispatch unnecessary incorrect events
+    // the condition will be executed only when keyboard is opened and changes its size
+    // (for example it happens when user changes keyboard type from 'text' to 'emoji' input
+    if (isKeyboardVisible && isKeyboardVisible() && !isTransitioning && Build.VERSION.SDK_INT >= 30) {
+      val keyboardHeight = getCurrentKeyboardHeight()
+
+      this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(keyboardHeight))
+
+      val animation = ValueAnimator.ofInt(-this.persistentKeyboardHeight, -keyboardHeight)
+      animation.addUpdateListener { animator ->
+        val toValue = animator.animatedValue as Int
+        this.sendEventToJS(KeyboardTransitionEvent(view.id, toValue, -toValue.toDouble() / keyboardHeight))
+      }
+      animation.doOnEnd {
+        this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(keyboardHeight))
+      }
+      animation.setDuration(250).startDelay = 0
+      animation.start()
+
+      this.persistentKeyboardHeight = keyboardHeight
+    }
+
+    return onApplyWindowInsetsListener.onApplyWindowInsets(v, insets)
+  }
+
+  override fun onStart(
+    animation: WindowInsetsAnimationCompat,
+    bounds: WindowInsetsAnimationCompat.BoundsCompat
+  ): WindowInsetsAnimationCompat.BoundsCompat {
+    isTransitioning = true
+    isKeyboardVisible = isKeyboardVisible()
+    val keyboardHeight = getCurrentKeyboardHeight()
+
+    if (isKeyboardVisible) {
+      // do not update it on hide, since back progress will be invalid
+      this.persistentKeyboardHeight = keyboardHeight
+    }
+
+    this.emitEvent("KeyboardController::" + if (!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow", getEventParams(keyboardHeight))
+
+    Log.i(TAG, "HEIGHT:: $keyboardHeight")
+
+    return super.onStart(animation, bounds)
+  }
+
+  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)).let { if (it.isNaN()) 0.0 else it }
+    } catch (e: ArithmeticException) {
+      // do nothing, send progress as 0
+    }
+    Log.i(TAG, "DiffY: $diffY $height $progress")
+
+    this.sendEventToJS(KeyboardTransitionEvent(view.id, height, progress))
+
+    return insets
+  }
+
+  override fun onEnd(animation: WindowInsetsAnimationCompat) {
+    super.onEnd(animation)
+
+    isTransitioning = false
+    this.persistentKeyboardHeight = getCurrentKeyboardHeight()
+    this.emitEvent("KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
+  }
+
+  private fun isKeyboardVisible(): Boolean {
+    val insets = ViewCompat.getRootWindowInsets(view)
+
+    return insets?.isVisible(WindowInsetsCompat.Type.ime()) ?: false
+  }
+
+  private fun getCurrentKeyboardHeight(): Int {
+    val insets = ViewCompat.getRootWindowInsets(view)
+    val keyboardHeight = insets?.getInsets(WindowInsetsCompat.Type.ime())?.bottom ?: 0
+    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)
+  }
+
+  private fun sendEventToJS(event: Event<*>) {
+    val eventDispatcher: EventDispatcher? =
+      UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
+    eventDispatcher?.dispatchEvent(event)
+  }
+
+  private fun emitEvent(event: String, params: WritableMap) {
+    context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(event, params)
+
+    Log.i(TAG, event)
+  }
+
+  private fun getEventParams(height: Int): WritableMap {
+    val params: WritableMap = Arguments.createMap()
+    params.putInt("height", height)
+
+    return params
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/{KeyboardControllerModule.kt → KeyboardControllerModuleImpl.kt}

@@ -2,38 +2,26 @@ package com.reactnativekeyboardcontroller
 
 import android.view.WindowManager
 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 KeyboardControllerModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(mReactContext) {
+class KeyboardControllerModuleImpl(private val mReactContext: ReactApplicationContext) {
   private val mDefaultMode: Int = mReactContext.currentActivity?.window?.attributes?.softInputMode ?: WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED
 
-  override fun getName(): String = "KeyboardController"
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
   fun setInputMode(mode: Int) {
     setSoftInputMode(mode)
   }
 
-  @ReactMethod(isBlockingSynchronousMethod = true)
   fun setDefaultMode() {
     setSoftInputMode(mDefaultMode)
   }
 
-  @ReactMethod
-  fun addListener(eventName: String?) {
-    /* Required for RN built-in Event Emitter Calls. */
-  }
-
-  @ReactMethod
-  fun removeListeners(count: Int?) {
-    /* Required for RN built-in Event Emitter Calls. */
-  }
-
   private fun setSoftInputMode(mode: Int) {
     UiThreadUtil.runOnUiThread {
       mReactContext.currentActivity?.window?.setSoftInputMode(mode)
     }
   }
+
+  companion object {
+    const val NAME = "KeyboardController"
+  }
 }

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

@@ -4,6 +4,7 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
+import com.facebook.soloader.SoLoader
 
 class KeyboardControllerPackage : ReactPackage {
   override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
@@ -11,6 +12,10 @@ class KeyboardControllerPackage : ReactPackage {
   }
 
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      SoLoader.loadLibrary("reactnativekeyboardcontroller_modules")
+    }
+
     return listOf(KeyboardControllerViewManager(reactContext))
   }
 }

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

@@ -0,0 +1,71 @@
+package com.reactnativekeyboardcontroller
+
+import android.util.Log
+import androidx.appcompat.widget.FitWindowsLinearLayout
+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
+import com.facebook.react.views.view.ReactViewGroup
+import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
+
+class KeyboardControllerViewManagerImpl(reactContext: ReactApplicationContext) {
+  private val TAG = KeyboardControllerViewManagerImpl::class.qualifiedName
+  private var mReactContext = reactContext
+  private var isStatusBarTranslucent = false
+
+  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 callback = KeyboardAnimationCallback(
+      view = view,
+      persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
+      deferredInsetTypes = WindowInsetsCompat.Type.ime(),
+      // We explicitly allow dispatch to continue down to binding.messageHolder's
+      // child views, so that step 2.5 below receives the call
+      dispatchMode = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE,
+      context = mReactContext,
+      onApplyWindowInsetsListener = { v, insets ->
+        val content =
+          mReactContext.currentActivity?.window?.decorView?.rootView?.findViewById<FitWindowsLinearLayout>(
+            R.id.action_bar_root
+          )
+        content?.setPadding(
+          0, if (this.isStatusBarTranslucent) 0 else insets?.getInsets(WindowInsetsCompat.Type.systemBars())?.top ?: 0, 0,
+          insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom ?: 0
+        )
+
+        insets
+      }
+    )
+    ViewCompat.setWindowInsetsAnimationCallback(view, callback)
+    ViewCompat.setOnApplyWindowInsetsListener(view, callback)
+
+    return view
+  }
+
+  fun setStatusBarTranslucent(view: ReactViewGroup, isStatusBarTranslucent: Boolean) {
+    this.isStatusBarTranslucent = isStatusBarTranslucent
+  }
+
+  fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    val map: MutableMap<String, Any> = MapBuilder.of(
+      KeyboardTransitionEvent.EVENT_NAME,
+      MapBuilder.of("registrationName", "onKeyboardMove")
+    )
+
+    return map
+  }
+
+  companion object {
+    const val NAME = "KeyboardControllerView"
+  }
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/{StatusBarManagerCompatModule.kt → StatusBarManagerCompatImpl.kt}

@@ -8,18 +8,13 @@ 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
+class StatusBarManagerCompatImpl(private val mReactContext: ReactApplicationContext) {
+  private val TAG = StatusBarManagerCompatImpl::class.qualifiedName
   private var controller: WindowInsetsControllerCompat? = null
 
-  override fun getName(): String = "StatusBarManagerCompat"
-
-  @ReactMethod
-  private fun setHidden(hidden: Boolean) {
+  fun setHidden(hidden: Boolean) {
     UiThreadUtil.runOnUiThread {
       if (hidden) {
         getController()?.hide(WindowInsetsCompat.Type.statusBars())
@@ -30,8 +25,7 @@ class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationCo
   }
 
   @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
-  @ReactMethod
-  private fun setColor(color: Int, animated: Boolean) {
+  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.")
@@ -55,8 +49,7 @@ class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationCo
     }
   }
 
-  @ReactMethod
-  private fun setTranslucent(translucent: Boolean) {
+  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
@@ -70,8 +63,7 @@ class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationCo
     // 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) {
+  fun setStyle(style: String) {
     UiThreadUtil.runOnUiThread {
       getController()?.isAppearanceLightStatusBars = style == "dark-content"
     }
@@ -92,4 +84,8 @@ class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationCo
 
     return this.controller
   }
+
+  companion object {
+    const val NAME = "StatusBarManagerCompat"
+  }
 }

package/android/src/main/jni/Android.mk

@@ -0,0 +1,42 @@
+KEYBOARD_CONTROLLER_MAIN_THIS_DIR := $(call my-dir)
+
+include $(REACT_ANDROID_DIR)/Android-prebuilt.mk
+
+include $(KEYBOARD_CONTROLLER_MAIN_THIS_DIR)/../../../build/generated/source/codegen/jni/Android.mk
+
+include $(CLEAR_VARS)
+
+LOCAL_PATH := $(KEYBOARD_CONTROLLER_MAIN_THIS_DIR)
+LOCAL_MODULE := reactnativekeyboardcontroller_modules
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH) $(GENERATED_SRC_DIR)/codegen/jni
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp) $(wildcard $(GENERATED_SRC_DIR)/codegen/jni/*.cpp)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH) $(GENERATED_SRC_DIR)/codegen/jni
+
+# Please note as one of the library listed is libreact_codegen_samplelibrary
+# This name will be generated as libreact_codegen_<library-name>
+# where <library-name> is the one you specified in the Gradle configuration
+LOCAL_SHARED_LIBRARIES := libjsi \
+    libfbjni \
+    libglog \
+    libfolly_runtime \
+    libyoga \
+    libreact_nativemodule_core \
+    libturbomodulejsijni \
+    librrc_view \
+    libreact_render_core \
+    libreact_render_graphics \
+    libfabricjni \
+    libreact_debug \
+    libreact_render_componentregistry \
+    libreact_render_debug \
+    libruntimeexecutor \
+    libreact_render_mapbuffer \
+    libreact_codegen_rncore \
+    libreact_codegen_reactnativekeyboardcontroller
+
+LOCAL_CFLAGS := \
+    -DLOG_TAG=\"ReactNative\"
+LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall
+
+include $(BUILD_SHARED_LIBRARY)