@react-native-firebase/app 26.4.0 → 27.1.0

package/android/src/reactnative/java/io/invertase/firebase/app/NativeRNFBTurboApp.kt

@@ -0,0 +1,250 @@
+package io.invertase.firebase.app
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.util.Log
+import com.facebook.fbreact.specs.NativeRNFBTurboAppSpec
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.google.firebase.FirebaseApp
+import io.invertase.firebase.common.RCTConvertFirebase
+import io.invertase.firebase.common.ReactNativeFirebaseEvent
+import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter
+import io.invertase.firebase.common.ReactNativeFirebaseJSON
+import io.invertase.firebase.common.ReactNativeFirebaseMeta
+import io.invertase.firebase.common.ReactNativeFirebasePreferences
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.concurrent.ConcurrentHashMap
+
+open class NativeRNFBTurboApp protected constructor(
+  reactContext: ReactApplicationContext?,
+) : NativeRNFBTurboAppSpec(reactContext),
+  LifecycleEventListener {
+  override fun initialize() {
+    super.initialize()
+    val reactContext = reactApplicationContext
+    // Register unconditionally. When the host is already RESUMED, addLifecycleEventListener
+    // posts onHostResume onto the UI queue asynchronously (it is not a synchronous call), so
+    // the explicit attach below is the primary path; resume remains best-effort convergence
+    // for later host flips. Stale-generation attaches are rejected or held pending by
+    // attachReactContext's fail-closed current-context arbitration.
+    reactContext.addLifecycleEventListener(this)
+    ReactNativeFirebaseEventEmitter.getSharedInstance().attachReactContext(reactContext)
+  }
+
+  override fun invalidate() {
+    val reactContext = reactApplicationContext
+    reactContext.removeLifecycleEventListener(this)
+    // Identity-guarded inside the emitter: only clears state belonging to this dying context,
+    // never state a replacement runtime has already installed.
+    ReactNativeFirebaseEventEmitter.getSharedInstance().detachReactContext(reactContext)
+    super.invalidate()
+  }
+
+  override fun onHostResume() {
+    // Re-attaching also flushes any events queued while no runtime was able to receive them.
+    ReactNativeFirebaseEventEmitter
+      .getSharedInstance()
+      .attachReactContext(reactApplicationContext)
+  }
+
+  override fun onHostPause() {
+    // No-op, required by LifecycleEventListener.
+  }
+
+  override fun onHostDestroy() {
+    // No-op, required by LifecycleEventListener.
+  }
+
+  protected override fun getTypedExportedConstants(): MutableMap<String, Any?> {
+    val constants: MutableMap<String, Any?> = HashMap()
+    val appsList: MutableList<Map<String, Any?>> = ArrayList()
+    val firebaseApps = FirebaseApp.getApps(reactApplicationContext)
+
+    for (app in firebaseApps) {
+      appsList.add(RCTConvertFirebase.firebaseAppToMap(app))
+    }
+
+    constants["NATIVE_FIREBASE_APPS"] = appsList
+    constants["FIREBASE_RAW_JSON"] = ReactNativeFirebaseJSON.getSharedInstance().getRawJSON()
+
+    return constants
+  }
+
+  override fun initializeApp(
+    options: ReadableMap?,
+    appConfig: ReadableMap?,
+    promise: Promise?,
+  ) {
+    val firebaseApp =
+      RCTConvertFirebase.readableMapToFirebaseApp(options, appConfig, reactApplicationContext)
+    configureAuthDomain(
+      nullableAsPlatformType<ReadableMap>(appConfig).getString("name"),
+      nullableAsPlatformType<ReadableMap>(options).getString("authDomain"),
+    )
+
+    val firebaseAppMap = RCTConvertFirebase.firebaseAppToWritableMap(firebaseApp)
+    nullableAsPlatformType<Promise>(promise).resolve(firebaseAppMap)
+  }
+
+  override fun setAutomaticDataCollectionEnabled(
+    appName: String?,
+    enabled: Boolean,
+  ) {
+    val firebaseApp: FirebaseApp? = FirebaseApp.getInstance(nullableAsPlatformType(appName))
+    nullableAsPlatformType<FirebaseApp>(firebaseApp).setDataCollectionDefaultEnabled(enabled)
+  }
+
+  override fun deleteApp(
+    appName: String?,
+    promise: Promise?,
+  ) {
+    val firebaseApp: FirebaseApp? = FirebaseApp.getInstance(nullableAsPlatformType(appName))
+
+    if (firebaseApp != null) {
+      firebaseApp.delete()
+      authDomains.remove(appName)
+    }
+
+    nullableAsPlatformType<Promise>(promise).resolve(null)
+  }
+
+  override fun eventsNotifyReady(ready: Boolean) {
+    val emitter = ReactNativeFirebaseEventEmitter.getSharedInstance()
+    emitter.notifyJsReady(ready)
+  }
+
+  override fun eventsGetListeners(promise: Promise?) {
+    val emitter = ReactNativeFirebaseEventEmitter.getSharedInstance()
+    nullableAsPlatformType<Promise>(promise).resolve(emitter.listenersMap)
+  }
+
+  override fun eventsPing(
+    eventName: String?,
+    eventBody: ReadableMap?,
+    promise: Promise?,
+  ) {
+    val emitter = ReactNativeFirebaseEventEmitter.getSharedInstance()
+    emitter.sendEvent(
+      ReactNativeFirebaseEvent(
+        nullableAsPlatformType(eventName),
+        nullableAsPlatformType(RCTConvertFirebase.readableMapToWritableMap(eventBody)),
+      ),
+    )
+    nullableAsPlatformType<Promise>(promise).resolve(
+      RCTConvertFirebase.readableMapToWritableMap(eventBody),
+    )
+  }
+
+  override fun eventsAddListener(eventName: String?) {
+    val emitter = ReactNativeFirebaseEventEmitter.getSharedInstance()
+    emitter.addListener(eventName)
+  }
+
+  override fun eventsRemoveListener(
+    eventName: String?,
+    all: Boolean,
+  ) {
+    val emitter = ReactNativeFirebaseEventEmitter.getSharedInstance()
+    emitter.removeListener(eventName, all)
+  }
+
+  override fun addListener(eventName: String?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  override fun removeListeners(count: Double) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  override fun metaGetAll(promise: Promise?) {
+    nullableAsPlatformType<Promise>(promise).resolve(
+      ReactNativeFirebaseMeta.getSharedInstance().getAll(),
+    )
+  }
+
+  override fun jsonGetAll(promise: Promise?) {
+    nullableAsPlatformType<Promise>(promise).resolve(
+      ReactNativeFirebaseJSON.getSharedInstance().getAll(),
+    )
+  }
+
+  override fun preferencesSetBool(
+    key: String?,
+    value: Boolean,
+    promise: Promise?,
+  ) {
+    ReactNativeFirebasePreferences.getSharedInstance().setBooleanValue(key, value)
+    nullableAsPlatformType<Promise>(promise).resolve(null)
+  }
+
+  override fun preferencesSetString(
+    key: String?,
+    value: String?,
+    promise: Promise?,
+  ) {
+    ReactNativeFirebasePreferences.getSharedInstance().setStringValue(key, value)
+    nullableAsPlatformType<Promise>(promise).resolve(null)
+  }
+
+  override fun preferencesGetAll(promise: Promise?) {
+    nullableAsPlatformType<Promise>(promise).resolve(
+      ReactNativeFirebasePreferences.getSharedInstance().getAll(),
+    )
+  }
+
+  override fun preferencesClearAll(promise: Promise?) {
+    ReactNativeFirebasePreferences.getSharedInstance().clearAll()
+    nullableAsPlatformType<Promise>(promise).resolve(null)
+  }
+
+  override fun setLogLevel(logLevel: String?) {
+    // Android uses Firebase SDK log level via manifest; no-op at runtime.
+  }
+
+  companion object {
+    private const val TAG = "App"
+
+    @JvmField
+    val authDomains: MutableMap<String?, String> = ConcurrentHashMap()
+
+    // Kotlin has no package-private constructor. Protected keeps same-package Java construction
+    // while avoiding an externally public constructor; this internal invoke keeps same-module
+    // Kotlin package registration source-compatible without widening the constructor itself.
+    internal operator fun invoke(reactContext: ReactApplicationContext?): NativeRNFBTurboApp = NativeRNFBTurboApp(reactContext)
+
+    @Suppress("UNCHECKED_CAST")
+    private fun <T> nullableAsPlatformType(value: T?): T = value as T
+
+    @JvmStatic
+    fun configureAuthDomain(
+      name: String?,
+      authDomain: String?,
+    ) {
+      if (authDomain != null) {
+        Log.d(TAG, "$name custom authDomain $authDomain")
+        authDomains[name] = authDomain
+      } else {
+        authDomains.remove(name)
+      }
+    }
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseApp.kt

@@ -0,0 +1,64 @@
+package io.invertase.firebase.app
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.content.Context
+import android.util.Log
+import com.google.firebase.FirebaseApp
+import com.google.firebase.FirebaseOptions
+
+open class ReactNativeFirebaseApp {
+  companion object {
+    private var applicationContext: Context? = null
+
+    @JvmStatic fun getApplicationContext(): Context = nullableAsPlatformType(applicationContext)
+
+    @JvmStatic
+    fun setApplicationContext(applicationContext: Context?) {
+      Log.d("ReactNativeFirebaseApp", "received application context.")
+      ReactNativeFirebaseApp.applicationContext = applicationContext
+    }
+
+    @JvmStatic
+    fun initializeSecondaryApp(name: String?) {
+      val context: Context = nullableAsPlatformType(applicationContext)
+      val options = FirebaseOptions.fromResource(context)
+      FirebaseApp.initializeApp(
+        context,
+        nullableAsPlatformType(options),
+        nullableAsPlatformType(name),
+      )
+    }
+
+    @JvmStatic
+    fun initializeSecondaryApp(
+      name: String?,
+      applicationContext: Context?,
+    ) {
+      val context: Context = nullableAsPlatformType(applicationContext)
+      val options = FirebaseOptions.fromResource(context)
+      FirebaseApp.initializeApp(
+        context,
+        nullableAsPlatformType(options),
+        nullableAsPlatformType(name),
+      )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun <T> nullableAsPlatformType(value: T?): T = value as T
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/app/{ReactNativeFirebaseAppInitProvider.java → ReactNativeFirebaseAppInitProvider.kt}

@@ -1,4 +1,4 @@
-package io.invertase.firebase.app;
+package io.invertase.firebase.app
 
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
@@ -14,9 +14,8 @@ package io.invertase.firebase.app;
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- *
  */
 
-import io.invertase.firebase.common.ReactNativeFirebaseInitProvider;
+import io.invertase.firebase.common.ReactNativeFirebaseInitProvider
 
-public class ReactNativeFirebaseAppInitProvider extends ReactNativeFirebaseInitProvider {}
+public open class ReactNativeFirebaseAppInitProvider : ReactNativeFirebaseInitProvider()

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseAppPackage.kt

@@ -0,0 +1,47 @@
+package io.invertase.firebase.app
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import io.invertase.firebase.utils.NativeRNFBTurboUtils
+import java.util.ArrayList
+import java.util.Collections
+import javax.annotation.Nonnull
+
+@Suppress("unused")
+open class ReactNativeFirebaseAppPackage : ReactPackage {
+  @Nonnull
+  override fun createNativeModules(
+    @Nonnull reactContext: ReactApplicationContext,
+  ): MutableList<NativeModule> {
+    if (ReactNativeFirebaseApp.getApplicationContext() == null) {
+      ReactNativeFirebaseApp.setApplicationContext(reactContext.applicationContext)
+    }
+    return ArrayList<NativeModule>().apply {
+      add(NativeRNFBTurboApp(reactContext))
+      add(NativeRNFBTurboUtils(reactContext))
+    }
+  }
+
+  @Nonnull
+  override fun createViewManagers(
+    @Nonnull reactContext: ReactApplicationContext,
+  ): MutableList<ViewManager<out Nothing, out Nothing>> = Collections.emptyList()
+}

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseAppRegistrar.kt

@@ -0,0 +1,33 @@
+package io.invertase.firebase.app
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import androidx.annotation.Keep
+import com.google.firebase.components.Component
+import com.google.firebase.components.ComponentRegistrar
+import com.google.firebase.platforminfo.LibraryVersionComponent
+
+@Keep
+public open class ReactNativeFirebaseAppRegistrar : ComponentRegistrar {
+  override fun getComponents(): List<Component<*>> =
+    listOf(
+      LibraryVersionComponent.create(
+        "react-native-firebase",
+        ReactNativeFirebaseVersion.VERSION,
+      ),
+    )
+}

package/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseVersion.java

@@ -18,5 +18,5 @@ package io.invertase.firebase.app;
  */
 // generated file - do not modify or commit
 public class ReactNativeFirebaseVersion {
-  public static String VERSION = "26.4.0";
+  public static String VERSION = "27.1.0";
 }

package/android/src/reactnative/java/io/invertase/firebase/common/RCTConvertFirebase.kt

@@ -0,0 +1,185 @@
+package io.invertase.firebase.common
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.google.firebase.FirebaseApp
+import com.google.firebase.FirebaseOptions
+import io.invertase.firebase.app.NativeRNFBTurboApp
+import java.util.HashMap
+
+/** Utilities to convert to and from React Native bridge formats. */
+open class RCTConvertFirebase {
+  companion object {
+    private const val TAG = "RCTConvertFirebase"
+
+    @JvmStatic
+    fun firebaseAppToMap(firebaseApp: FirebaseApp?): Map<String, Any?> {
+      val name = firebaseApp!!.name
+      val appOptions = firebaseApp.options
+
+      val root = HashMap<String, Any?>()
+      val options = HashMap<String, Any?>()
+      val appConfig = HashMap<String, Any?>()
+
+      appConfig["name"] = name
+      appConfig["automaticDataCollectionEnabled"] =
+        firebaseApp.isDataCollectionDefaultEnabled
+
+      // TODO: Salakar: Firebase SDK does not support reading this value
+      // appConfig["automaticResourceManagement"] = false
+
+      options["apiKey"] = appOptions.apiKey
+      options["appId"] = appOptions.applicationId
+      options["projectId"] = appOptions.projectId
+      options["databaseURL"] = appOptions.databaseUrl
+      options["measurementId"] = appOptions.gaTrackingId
+      options["messagingSenderId"] = appOptions.gcmSenderId
+      options["storageBucket"] = appOptions.storageBucket
+
+      NativeRNFBTurboApp.authDomains[name]?.let { options["authDomain"] = it }
+
+      root["options"] = options
+      root["appConfig"] = appConfig
+
+      return root
+    }
+
+    @JvmStatic
+    fun firebaseAppToWritableMap(firebaseApp: FirebaseApp?): WritableMap? = Arguments.makeNativeMap(firebaseAppToMap(firebaseApp))
+
+    @JvmStatic
+    fun readableMapToFirebaseApp(
+      options: ReadableMap?,
+      appConfig: ReadableMap?,
+      context: Context?,
+    ): FirebaseApp? {
+      val builder = FirebaseOptions.Builder()
+      val name = appConfig!!.getString("name")
+
+      builder.setApiKey(options!!.getString("apiKey")!!)
+      builder.setApplicationId(options.getString("appId")!!)
+      builder.setProjectId(options.getString("projectId"))
+      builder.setDatabaseUrl(options.getString("databaseURL"))
+
+      if (options.hasKey("measurementId")) {
+        builder.setGaTrackingId(options.getString("measurementId"))
+      }
+
+      builder.setStorageBucket(options.getString("storageBucket"))
+      builder.setGcmSenderId(options.getString("messagingSenderId"))
+
+      val firebaseApp =
+        if (name!!.equals("[DEFAULT]")) {
+          FirebaseApp.initializeApp(context!!, builder.build())
+        } else {
+          FirebaseApp.initializeApp(context!!, builder.build(), name)
+        }
+
+      if (appConfig.hasKey("automaticDataCollectionEnabled")) {
+        firebaseApp!!.setDataCollectionDefaultEnabled(
+          appConfig.getBoolean("automaticDataCollectionEnabled"),
+        )
+      }
+
+      if (appConfig.hasKey("automaticResourceManagement")) {
+        // https://developers.google.com/android/reference/com/google/firebase/FirebaseApp.html#setAutomaticResourceManagementEnabled(boolean)
+        firebaseApp!!.setAutomaticResourceManagementEnabled(
+          appConfig.getBoolean("automaticResourceManagement"),
+        )
+      }
+
+      return firebaseApp
+    }
+
+    /**
+     * Takes a value and calls the appropriate setter for its type on the target map + key.
+     *
+     * @param key String key to set on target map
+     * @param value Object value to set on target map
+     * @param map WritableMap target map to write the value to
+     */
+    @JvmStatic
+    @Suppress("UNCHECKED_CAST")
+    fun mapPutValue(
+      key: String?,
+      value: Any?,
+      map: WritableMap?,
+    ): WritableMap? {
+      val target = map!!
+      if (value == null) {
+        target.putNull(key!!)
+        return map
+      }
+
+      val type = value.javaClass.name
+      val targetKey = key!!
+
+      when (type) {
+        "java.lang.Boolean" -> target.putBoolean(targetKey, value as Boolean)
+        "java.lang.Long" -> target.putDouble(targetKey, (value as Long).toDouble())
+        "java.lang.Float" -> target.putDouble(targetKey, (value as Float).toDouble())
+        "java.lang.Double" -> target.putDouble(targetKey, value as Double)
+        "java.lang.Integer" -> target.putInt(targetKey, value as Int)
+        "java.lang.String" -> target.putString(targetKey, value as String)
+        "org.json.JSONObject\$1" -> target.putString(targetKey, value.toString())
+        else ->
+          when (value) {
+            is List<*> ->
+              target.putArray(targetKey, Arguments.makeNativeArray(value as List<Any?>))
+            is Map<*, *> -> {
+              val childMap = Arguments.createMap()
+              for ((childKey, childValue) in value as Map<String, Any?>) {
+                mapPutValue(childKey, childValue, childMap)
+              }
+              target.putMap(targetKey, childMap)
+            }
+            else -> {
+              Log.d(TAG, "utils:mapPutValue:unknownType:$type")
+              target.putNull(targetKey)
+            }
+          }
+      }
+
+      return map
+    }
+
+    // TODO Remove me - also in SharedUtils
+    @JvmStatic
+    fun readableMapToWritableMap(map: ReadableMap?): WritableMap? {
+      val writableMap = Arguments.createMap()
+      // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/WritableNativeMap.java#L54
+      writableMap.merge(map!!)
+      return writableMap
+    }
+
+    @JvmStatic
+    fun toHashMap(readableMap: ReadableMap?): Map<String, Any?>? =
+      // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeMap.java#L216
+      readableMap!!.toHashMap()
+
+    @JvmStatic
+    fun toArrayList(readableArray: ReadableArray?): List<Any?>? =
+      // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeArray.java#L175
+      readableArray!!.toArrayList()
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/common/ReactNativeFirebaseEvent.kt

@@ -0,0 +1,35 @@
+package io.invertase.firebase.common
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.bridge.WritableMap
+import io.invertase.firebase.interfaces.NativeEvent
+
+class ReactNativeFirebaseEvent
+  @JvmOverloads
+  constructor(
+    private val eventName: String,
+    private val eventBody: WritableMap,
+    private val firebaseAppName: String? = null,
+  ) : NativeEvent {
+    override fun getEventName(): String = eventName
+
+    override fun getEventBody(): WritableMap = eventBody
+
+    override fun getFirebaseAppName(): String? = firebaseAppName
+  }