@react-native-firebase/app 23.8.0 → 23.8.1

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

@@ -0,0 +1,186 @@
+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.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+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.ReactNativeFirebaseModule;
+import io.invertase.firebase.common.ReactNativeFirebasePreferences;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ReactNativeFirebaseAppModule extends ReactNativeFirebaseModule {
+  private static final String TAG = "App";
+
+  public static Map<String, String> authDomains = new HashMap<>();
+
+  ReactNativeFirebaseAppModule(ReactApplicationContext reactContext) {
+    super(reactContext, TAG);
+  }
+
+  @Override
+  public void initialize() {
+    super.initialize();
+    ReactNativeFirebaseEventEmitter.getSharedInstance().attachReactContext(getContext());
+  }
+
+  @ReactMethod
+  public void initializeApp(ReadableMap options, ReadableMap appConfig, Promise promise) {
+    FirebaseApp firebaseApp =
+        RCTConvertFirebase.readableMapToFirebaseApp(options, appConfig, getContext());
+    ReactNativeFirebaseAppModule.configureAuthDomain(
+        appConfig.getString("name"), options.getString("authDomain"));
+
+    WritableMap firebaseAppMap = RCTConvertFirebase.firebaseAppToWritableMap(firebaseApp);
+    promise.resolve(firebaseAppMap);
+  }
+
+  public static void configureAuthDomain(String name, String authDomain) {
+    if (authDomain != null) {
+      Log.d(TAG, name + " custom authDomain " + authDomain);
+      authDomains.put(name, authDomain);
+    } else {
+      authDomains.remove(name);
+    }
+  }
+
+  @ReactMethod
+  public void setAutomaticDataCollectionEnabled(String appName, Boolean enabled) {
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+    firebaseApp.setDataCollectionDefaultEnabled(enabled);
+  }
+
+  @ReactMethod
+  public void deleteApp(String appName, Promise promise) {
+    FirebaseApp firebaseApp = FirebaseApp.getInstance(appName);
+
+    if (firebaseApp != null) {
+      firebaseApp.delete();
+    }
+
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void eventsNotifyReady(Boolean ready) {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.notifyJsReady(ready);
+  }
+
+  @ReactMethod
+  public void eventsGetListeners(Promise promise) {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    promise.resolve(emitter.getListenersMap());
+  }
+
+  @ReactMethod
+  public void eventsPing(String eventName, ReadableMap eventBody, Promise promise) {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.sendEvent(
+        new ReactNativeFirebaseEvent(
+            eventName, RCTConvertFirebase.readableMapToWritableMap(eventBody)));
+    promise.resolve(RCTConvertFirebase.readableMapToWritableMap(eventBody));
+  }
+
+  @ReactMethod
+  public void eventsAddListener(String eventName) {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.addListener(eventName);
+  }
+
+  @ReactMethod
+  public void eventsRemoveListener(String eventName, Boolean all) {
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+    emitter.removeListener(eventName, all);
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  /** ------------------ META ------------------ */
+  @ReactMethod
+  public void metaGetAll(Promise promise) {
+    promise.resolve(ReactNativeFirebaseMeta.getSharedInstance().getAll());
+  }
+
+  /** ------------------ JSON ------------------ */
+  @ReactMethod
+  public void jsonGetAll(Promise promise) {
+    promise.resolve(ReactNativeFirebaseJSON.getSharedInstance().getAll());
+  }
+
+  /** ------------------ PREFERENCES ------------------ */
+  @ReactMethod
+  public void preferencesSetBool(String key, boolean value, Promise promise) {
+    ReactNativeFirebasePreferences.getSharedInstance().setBooleanValue(key, value);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void preferencesSetString(String key, String value, Promise promise) {
+    ReactNativeFirebasePreferences.getSharedInstance().setStringValue(key, value);
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void preferencesGetAll(Promise promise) {
+    promise.resolve(ReactNativeFirebasePreferences.getSharedInstance().getAll());
+  }
+
+  @ReactMethod
+  public void preferencesClearAll(Promise promise) {
+    ReactNativeFirebasePreferences.getSharedInstance().clearAll();
+    promise.resolve(null);
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    Map<String, Object> constants = new HashMap<>();
+    List<Map<String, Object>> appsList = new ArrayList<>();
+    List<FirebaseApp> firebaseApps = FirebaseApp.getApps(getReactApplicationContext());
+
+    for (FirebaseApp app : firebaseApps) {
+      appsList.add(RCTConvertFirebase.firebaseAppToMap(app));
+    }
+
+    constants.put("NATIVE_FIREBASE_APPS", appsList);
+
+    constants.put("FIREBASE_RAW_JSON", ReactNativeFirebaseJSON.getSharedInstance().getRawJSON());
+
+    return constants;
+  }
+}

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

@@ -0,0 +1,49 @@
+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.ReactNativeFirebaseUtilsModule;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nonnull;
+
+@SuppressWarnings("unused")
+public class ReactNativeFirebaseAppPackage implements ReactPackage {
+  @Nonnull
+  @Override
+  public List<NativeModule> createNativeModules(@Nonnull ReactApplicationContext reactContext) {
+    if (ReactNativeFirebaseApp.getApplicationContext() == null) {
+      ReactNativeFirebaseApp.setApplicationContext(reactContext.getApplicationContext());
+    }
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ReactNativeFirebaseAppModule(reactContext));
+    modules.add(new ReactNativeFirebaseUtilsModule(reactContext));
+    return modules;
+  }
+
+  @Nonnull
+  @Override
+  public List<ViewManager> createViewManagers(@Nonnull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

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

@@ -0,0 +1,35 @@
+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;
+import java.util.Collections;
+import java.util.List;
+
+@Keep
+public class ReactNativeFirebaseAppRegistrar implements ComponentRegistrar {
+  @Override
+  public List<Component<?>> getComponents() {
+    return Collections.singletonList(
+        LibraryVersionComponent.create(
+            "react-native-firebase", ReactNativeFirebaseVersion.VERSION));
+  }
+}

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

@@ -0,0 +1,22 @@
+
+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.
+ *
+ */
+// generated file - do not modify or commit
+public class ReactNativeFirebaseVersion {
+  public static String VERSION = "23.8.1";
+}

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

@@ -0,0 +1,191 @@
+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.ReactNativeFirebaseAppModule;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Utilities to convert to and from React Native bridge formats. */
+public class RCTConvertFirebase {
+  private static String TAG = "RCTConvertFirebase";
+
+  public static Map<String, Object> firebaseAppToMap(FirebaseApp firebaseApp) {
+    String name = firebaseApp.getName();
+    FirebaseOptions appOptions = firebaseApp.getOptions();
+
+    Map<String, Object> root = new HashMap<>();
+    Map<String, Object> options = new HashMap<>();
+    Map<String, Object> appConfig = new HashMap<>();
+
+    appConfig.put("name", name);
+    appConfig.put("automaticDataCollectionEnabled", firebaseApp.isDataCollectionDefaultEnabled());
+
+    // TODO: Salakar: Firebase SDK does not support reading this value
+    // appConfig.put("automaticResourceManagement", false);
+
+    options.put("apiKey", appOptions.getApiKey());
+    options.put("appId", appOptions.getApplicationId());
+    options.put("projectId", appOptions.getProjectId());
+    options.put("databaseURL", appOptions.getDatabaseUrl());
+    options.put("measurementId", appOptions.getGaTrackingId());
+    options.put("messagingSenderId", appOptions.getGcmSenderId());
+    options.put("storageBucket", appOptions.getStorageBucket());
+
+    if (ReactNativeFirebaseAppModule.authDomains.get(name) != null) {
+      options.put("authDomain", ReactNativeFirebaseAppModule.authDomains.get(name));
+    }
+
+    root.put("options", options);
+    root.put("appConfig", appConfig);
+
+    return root;
+  }
+
+  public static WritableMap firebaseAppToWritableMap(FirebaseApp firebaseApp) {
+    return Arguments.makeNativeMap(firebaseAppToMap(firebaseApp));
+  }
+
+  public static FirebaseApp readableMapToFirebaseApp(
+      ReadableMap options, ReadableMap appConfig, Context context) {
+    FirebaseOptions.Builder builder = new FirebaseOptions.Builder();
+
+    String 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"));
+
+    FirebaseApp firebaseApp;
+    if (name.equals("[DEFAULT]")) {
+      firebaseApp = FirebaseApp.initializeApp(context, builder.build());
+    } else {
+      firebaseApp = FirebaseApp.initializeApp(context, builder.build(), name);
+    }
+
+    if (appConfig.hasKey("automaticDataCollectionEnabled")) {
+      firebaseApp.setDataCollectionDefaultEnabled(
+          Boolean.valueOf(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
+   */
+  @SuppressWarnings("unchecked")
+  public static WritableMap mapPutValue(String key, @Nullable Object value, WritableMap map) {
+    if (value == null) {
+      map.putNull(key);
+      return map;
+    }
+
+    String type = value.getClass().getName();
+
+    switch (type) {
+      case "java.lang.Boolean":
+        map.putBoolean(key, (Boolean) value);
+        break;
+      case "java.lang.Long":
+        Long longVal = (Long) value;
+        map.putDouble(key, (double) longVal);
+        break;
+      case "java.lang.Float":
+        float floatVal = (float) value;
+        map.putDouble(key, (double) floatVal);
+        break;
+      case "java.lang.Double":
+        map.putDouble(key, (Double) value);
+        break;
+      case "java.lang.Integer":
+        map.putInt(key, (int) value);
+        break;
+      case "java.lang.String":
+        map.putString(key, (String) value);
+        break;
+      case "org.json.JSONObject$1":
+        map.putString(key, value.toString());
+        break;
+      default:
+        if (List.class.isAssignableFrom(value.getClass())) {
+          map.putArray(key, Arguments.makeNativeArray((List<Object>) value));
+        } else if (Map.class.isAssignableFrom(value.getClass())) {
+          WritableMap childMap = Arguments.createMap();
+          Map<String, Object> valueMap = (Map<String, Object>) value;
+
+          for (Map.Entry<String, Object> entry : valueMap.entrySet()) {
+            mapPutValue(entry.getKey(), entry.getValue(), childMap);
+          }
+
+          map.putMap(key, childMap);
+        } else {
+          Log.d(TAG, "utils:mapPutValue:unknownType:" + type);
+          map.putNull(key);
+        }
+    }
+
+    return map;
+  }
+
+  // TODO Remove me - also in SharedUtils
+  public static WritableMap readableMapToWritableMap(ReadableMap map) {
+    WritableMap 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;
+  }
+
+  public static Map<String, Object> toHashMap(ReadableMap readableMap) {
+    // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeMap.java#L216
+    return readableMap.toHashMap();
+  }
+
+  public static List<Object> toArrayList(ReadableArray readableArray) {
+    // https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeArray.java#L175
+    return readableArray.toArrayList();
+  }
+}

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

@@ -0,0 +1,53 @@
+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;
+
+public class ReactNativeFirebaseEvent implements NativeEvent {
+  private String eventName;
+  private WritableMap eventBody;
+  private String firebaseAppName;
+
+  public ReactNativeFirebaseEvent(String eventName, WritableMap eventBody) {
+    this.eventName = eventName;
+    this.eventBody = eventBody;
+  }
+
+  public ReactNativeFirebaseEvent(String eventName, WritableMap eventBody, String firebaseAppName) {
+    this.eventName = eventName;
+    this.eventBody = eventBody;
+    this.firebaseAppName = firebaseAppName;
+  }
+
+  @Override
+  public String getEventName() {
+    return eventName;
+  }
+
+  @Override
+  public WritableMap getEventBody() {
+    return eventBody;
+  }
+
+  @Override
+  public String getFirebaseAppName() {
+    return firebaseAppName;
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/common/ReactNativeFirebaseEventEmitter.java

@@ -0,0 +1,151 @@
+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.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.MainThread;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import io.invertase.firebase.interfaces.NativeEvent;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ReactNativeFirebaseEventEmitter {
+  private static ReactNativeFirebaseEventEmitter sharedInstance =
+      new ReactNativeFirebaseEventEmitter();
+  private final List<NativeEvent> queuedEvents = new ArrayList<>();
+  private final Handler handler = new Handler(Looper.getMainLooper());
+  private final HashMap<String, Integer> jsListeners = new HashMap<>();
+  private ReactContext reactContext;
+  private Boolean jsReady = false;
+  private int jsListenerCount;
+
+  public static ReactNativeFirebaseEventEmitter getSharedInstance() {
+    return sharedInstance;
+  }
+
+  public void attachReactContext(final ReactContext reactContext) {
+    handler.post(
+        () -> {
+          ReactNativeFirebaseEventEmitter.this.reactContext = reactContext;
+          sendQueuedEvents();
+        });
+  }
+
+  public void notifyJsReady(Boolean ready) {
+    handler.post(
+        () -> {
+          jsReady = ready;
+          sendQueuedEvents();
+        });
+  }
+
+  public void sendEvent(final NativeEvent event) {
+    handler.post(
+        () -> {
+          synchronized (jsListeners) {
+            if (!jsListeners.containsKey(event.getEventName()) || !emit(event)) {
+              queuedEvents.add(event);
+            }
+          }
+        });
+  }
+
+  public void addListener(String eventName) {
+    synchronized (jsListeners) {
+      jsListenerCount++;
+      if (!jsListeners.containsKey(eventName)) {
+        jsListeners.put(eventName, 1);
+      } else {
+        int listenersForEvent = jsListeners.get(eventName);
+        jsListeners.put(eventName, listenersForEvent + 1);
+      }
+    }
+
+    handler.post(this::sendQueuedEvents);
+  }
+
+  public void removeListener(String eventName, Boolean all) {
+    synchronized (jsListeners) {
+      if (jsListeners.containsKey(eventName)) {
+        int listenersForEvent = jsListeners.get(eventName);
+
+        if (listenersForEvent <= 1 || all) {
+          jsListeners.remove(eventName);
+        } else {
+          jsListeners.put(eventName, listenersForEvent - 1);
+        }
+
+        jsListenerCount -= all ? listenersForEvent : 1;
+      }
+    }
+  }
+
+  public WritableMap getListenersMap() {
+    WritableMap writableMap = Arguments.createMap();
+    WritableMap events = Arguments.createMap();
+
+    writableMap.putInt("listeners", jsListenerCount);
+    writableMap.putInt("queued", queuedEvents.size());
+
+    synchronized (jsListeners) {
+      for (HashMap.Entry<String, Integer> entry : jsListeners.entrySet()) {
+        events.putInt(entry.getKey(), entry.getValue());
+      }
+    }
+
+    writableMap.putMap("events", events);
+
+    return writableMap;
+  }
+
+  @MainThread
+  private void sendQueuedEvents() {
+    synchronized (jsListeners) {
+      for (NativeEvent event : new ArrayList<>(queuedEvents)) {
+        if (jsListeners.containsKey(event.getEventName())) {
+          queuedEvents.remove(event);
+          sendEvent(event);
+        }
+      }
+    }
+  }
+
+  @MainThread
+  private boolean emit(final NativeEvent event) {
+    if (!jsReady || reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+      return false;
+    }
+
+    try {
+      reactContext
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+          .emit("rnfb_" + event.getEventName(), event.getEventBody());
+    } catch (Exception e) {
+      Log.wtf("RNFB_EMITTER", "Error sending Event " + event.getEventName(), e);
+      return false;
+    }
+
+    return true;
+  }
+}