[RN 0.76] Kotlin / Interop Layer: DeviceEventManagerModule not working

[mfkrause]

I'm currently in the process of making some remaining internal packages compatible with the New Architecture through the Interop Layer. Unfortunately, I keep running into an issue with DeviceEventManagerModule on Kotlin projects. Whenever this is used and we enable the New Architecture for the Android app, the build fails with this error:

> Task :react-native-someapp:compileDebugKotlin FAILED
e: Supertypes of the following classes cannot be resolved. Please make sure you have the required dependencies in the classpath:
    class com.facebook.react.modules.core.DeviceEventManagerModule, unresolved supertypes: com.facebook.fbreact.specs.NativeDeviceEventManagerSpec
Adding -Xextended-compiler-checks argument might provide additional information.


FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':react-native-someapp:compileDebugKotlin'.
> A failure occurred while executing org.jetbrains.kotlin.compilerRunner.GradleCompilerRunnerWithWorkers$GradleKotlinCompilerWorkAction
   > Compilation error. See log for more details

Source code and gradle setup

This is a minified excerpt from one of the affected Kotlin modules:

package com.somecompany.someapp

import android.Manifest
import android.content.pm.PackageManager
import android.util.Log
import android.os.Bundle
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.facebook.react.bridge.*
import com.facebook.react.modules.core.DeviceEventManagerModule

class SomeAppModule(reactContext: ReactApplicationContext) :
  ReactContextBaseJavaModule(reactContext) {

  override fun getName(): String {
    return NAME
  }

  private fun sendEvent(eventName: String, params: Any?) {
    reactApplicationContext
      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
      .emit(eventName, params)
  }

  @ReactMethod
  fun someMethod(options: ReadableMap, promise: Promise) {
    val currentActivity = currentActivity
    if (currentActivity == null) {
      promise.reject("ERROR", "Activity is null")
      return
    }

    try {
      // Run on main thread
      UiThreadUtil.runOnUiThread {
        try {
          // ... do some stuff on the UI thread
          sendEvent("RNSomeApp.event", "some data")
        } catch (e: Exception) {
          promise.reject("ERROR", "Some error... ${e.message}")
        }
      }
    } catch (e: Exception) {
      promise.reject("ERROR", "Some error... ${e.message}")
    }
  }

  companion object {
    const val NAME = "SomeApp"
  }
}

This is the module's build.gradle:

buildscript {
  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["SomeApp_kotlinVersion"]

  repositories {
    google()
    mavenCentral()
  }

  dependencies {
    classpath "com.android.tools.build:gradle:7.2.1"
    // noinspection DifferentKotlinGradleVersion
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
  }
}

def reactNativeArchitectures() {
  def value = rootProject.getProperties().get("reactNativeArchitectures")
  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
}

def isNewArchitectureEnabled() {
  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
}

apply plugin: "com.android.library"
apply plugin: "kotlin-android"

if (isNewArchitectureEnabled()) {
  apply plugin: "com.facebook.react"
}

def getExtOrDefault(name) {
  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["SomeApp_" + name]
}

def getExtOrIntegerDefault(name) {
  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["SomeApp_" + name]).toInteger()
}

def supportsNamespace() {
  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
  def major = parsed[0].toInteger()
  def minor = parsed[1].toInteger()

  // Namespace support was added in 7.3.0
  return (major == 7 && minor >= 3) || major >= 8
}

android {
  if (supportsNamespace()) {
    namespace "com.somecompany.someapp"

    sourceSets {
      main {
        manifest.srcFile "src/main/AndroidManifestNew.xml"
      }
    }
  }

  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")

  defaultConfig {
    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")

  }

  buildTypes {
    release {
      minifyEnabled false
    }
  }

  lintOptions {
    disable "GradleCompatible"
  }

  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

repositories {
  mavenCentral()
  google()
}

def kotlin_version = getExtOrDefault("kotlinVersion")

dependencies {
  // For < 0.71, this will be from the local maven repo
  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
  //noinspection GradleDynamicVersion
  implementation "com.facebook.react:react-native:+"
  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}

And its gradle.properties:

SomeApp_kotlinVersion=1.7.0
SomeApp_minSdkVersion=21
SomeApp_targetSdkVersion=31
SomeApp_compileSdkVersion=31
SomeApp_ndkversion=21.4.7075529

This is the app's build.gradle:

buildscript {
    ext {
        buildToolsVersion = "35.0.0"
        minSdkVersion = 24
        compileSdkVersion = 35
        targetSdkVersion = 34
        ndkVersion = "26.1.10909125"
        kotlinVersion = "1.9.24"
    }
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath("com.android.tools.build:gradle")
        classpath("com.facebook.react:react-native-gradle-plugin")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin")
    }
}

apply plugin: "com.facebook.react.rootproject"

It works fine when disabling the New Architecture and building without it.

I'm unable to find any related issue to this or any material saying that we need to migrate DeviceEventManagerModule to something else for it to work through the Interop Layer. In fact, the React Native documentation on Native Modules still recommends using this: https://reactnative.dev/docs/legacy/native-modules-android?android-language=kotlin#sending-events-to-javascript

While I'm aware that the documentation on Native Modules isn't fully updated for the New Architecture yet, this does make me wonder that I seem to be the only person encountering this issue – leading me to believe that it's some problem in my build set-up?

Can someone help with this?

Update 1: This seems to be limited to React Native 0.76. After downgrading everything back to 0.75 (according to the RN Update Helper), the build and the module itself work fine, even with New Architecture enabled. Therefore not sure if this is fitting as a discussion here in the WG, or if it's more fitting as a bug report in React Native itself.

[mfkrause]

Pretty sure this is an issue with create-react-native-library since I can't reproduce it when setting up a native module myself without this helper tool. Closing this since probably unrelated.

[smith-xyz]

Were you able to figure this issue out - currently running into the same, was looking to post on create-react-native-library about to see if there is something I'm missing.