@react-native-firebase/database 26.3.2 → 26.4.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
+
+### Bug Fixes
+
+- **database:** use RNFBHandleMap for transaction and query maps ([8adba4c](https://github.com/invertase/react-native-firebase/commit/8adba4cb88dffec2442ea0fe37738d1080d0a185))
+
+## [26.3.3](https://github.com/invertase/react-native-firebase/compare/v26.3.2...v26.3.3) (2026-09-01)
+
+### Reverts
+
+- Revert "chore(release): release packages" ([0a85268](https://github.com/invertase/react-native-firebase/commit/0a85268ae21c706cf1392eaa5b088e85c3273cb7))
+
 ## [26.3.2](https://github.com/invertase/react-native-firebase/compare/v26.3.1...v26.3.2) (2026-08-21)
 
 **Note:** Version bump only for package @react-native-firebase/database

package/RNFBDatabase.podspec

@@ -36,9 +36,11 @@ Pod::Spec.new do |s|
     'ios/RNFBDatabase/RNFBDatabaseQueryModule.h',
     'ios/RNFBDatabase/RNFBDatabaseOnDisconnectModule.h',
     'ios/RNFBDatabase/RNFBDatabaseTransactionModule.h',
+    'ios/RNFBDatabase/RNFBDatabaseQueryRegistry.h',
+    'ios/RNFBDatabase/RNFBDatabaseListenerRegistry.h',
     'ios/generated/**/*.h',
   ]
-  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*'
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**'
 
   s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/generated/RNFBDatabaseTurboModules\" \"$(PODS_TARGET_SRCROOT)/ios/generated\"",

package/android/build.gradle

@@ -93,6 +93,8 @@ dependencies {
   api appProject
   implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
   implementation "com.google.firebase:firebase-database"
+
+  testImplementation "junit:junit:4.13.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/src/main/java/io/invertase/firebase/database/DatabaseAbortable.java

@@ -0,0 +1,22 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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.
+ *
+ */
+
+interface DatabaseAbortable {
+  void abort();
+}

package/android/src/main/java/io/invertase/firebase/database/DatabaseQueryHandle.java

@@ -0,0 +1,24 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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.
+ *
+ */
+
+interface DatabaseQueryHandle {
+  void removeAllEventListeners();
+
+  Boolean hasListeners();
+}

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseListenerRegistry.java

@@ -0,0 +1,117 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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 io.invertase.firebase.common.RNFBHandleCollisionException;
+import io.invertase.firebase.common.RNFBHandleMap;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Per-query value/child listener maps. Unique {@link #putValue}/{@link #putChild}; callers {@link
+ * #takeValue}/{@link #takeChild} or {@link #takeAll} then remove the SDK listener outside the
+ * HandleMap lock. Null values are not stored so {@link #hasListeners} can use occupancy.
+ */
+final class RNFBDatabaseListenerRegistry {
+  private final Object occupancyLock = new Object();
+  private final RNFBHandleMap<String, Object> valueListeners = new RNFBHandleMap<>();
+  private final RNFBHandleMap<String, Object> childListeners = new RNFBHandleMap<>();
+  private int occupancy;
+
+  void putValue(String eventRegistrationKey, Object listener) throws RNFBHandleCollisionException {
+    if (listener == null) {
+      throw new NullPointerException("listener");
+    }
+    synchronized (occupancyLock) {
+      valueListeners.put(eventRegistrationKey, listener);
+      occupancy++;
+    }
+  }
+
+  void putChild(String eventRegistrationKey, Object listener) throws RNFBHandleCollisionException {
+    if (listener == null) {
+      throw new NullPointerException("listener");
+    }
+    synchronized (occupancyLock) {
+      childListeners.put(eventRegistrationKey, listener);
+      occupancy++;
+    }
+  }
+
+  Object getValue(String eventRegistrationKey) {
+    return valueListeners.get(eventRegistrationKey);
+  }
+
+  Object getChild(String eventRegistrationKey) {
+    return childListeners.get(eventRegistrationKey);
+  }
+
+  Object takeValue(String eventRegistrationKey) {
+    synchronized (occupancyLock) {
+      Object listener = valueListeners.take(eventRegistrationKey);
+      if (listener != null) {
+        occupancy--;
+      }
+      return listener;
+    }
+  }
+
+  Object takeChild(String eventRegistrationKey) {
+    synchronized (occupancyLock) {
+      Object listener = childListeners.take(eventRegistrationKey);
+      if (listener != null) {
+        occupancy--;
+      }
+      return listener;
+    }
+  }
+
+  List<Object> takeAllValues() {
+    synchronized (occupancyLock) {
+      List<Object> remaining = valueListeners.takeAll();
+      occupancy -= remaining.size();
+      return remaining;
+    }
+  }
+
+  List<Object> takeAllChildren() {
+    synchronized (occupancyLock) {
+      List<Object> remaining = childListeners.takeAll();
+      occupancy -= remaining.size();
+      return remaining;
+    }
+  }
+
+  List<Object> takeAll() {
+    List<Object> remaining = new ArrayList<>();
+    remaining.addAll(takeAllValues());
+    remaining.addAll(takeAllChildren());
+    return remaining;
+  }
+
+  boolean hasEventListener(String eventRegistrationKey) {
+    return valueListeners.get(eventRegistrationKey) != null
+        || childListeners.get(eventRegistrationKey) != null;
+  }
+
+  boolean hasListeners() {
+    synchronized (occupancyLock) {
+      return occupancy > 0;
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseQueryRegistry.java

@@ -0,0 +1,78 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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 io.invertase.firebase.common.RNFBHandleCollisionException;
+import io.invertase.firebase.common.RNFBHandleMap;
+import java.util.List;
+
+/**
+ * Cached query map. Unique {@link #put}; callers {@link #take}, {@link #takeIfIdle}, or {@link
+ * #takeAllAndRemove} then {@code removeAllEventListeners()} outside the HandleMap lock.
+ */
+final class RNFBDatabaseQueryRegistry {
+  private final RNFBHandleMap<String, DatabaseQueryHandle> map = new RNFBHandleMap<>();
+
+  void put(String queryKey, DatabaseQueryHandle query) throws RNFBHandleCollisionException {
+    map.put(queryKey, query);
+  }
+
+  DatabaseQueryHandle get(String queryKey) {
+    return map.get(queryKey);
+  }
+
+  DatabaseQueryHandle take(String queryKey) {
+    return map.take(queryKey);
+  }
+
+  /**
+   * Removes the mapping when the query has no listeners. Reads {@link
+   * DatabaseQueryHandle#hasListeners()} outside the HandleMap lock (avoids nesting {@code
+   * occupancyLock}), then identity-takes and put-backs if listeners appeared.
+   */
+  void takeIfIdle(String queryKey) {
+    DatabaseQueryHandle query = map.get(queryKey);
+    if (query == null) {
+      return;
+    }
+    if (Boolean.TRUE.equals(query.hasListeners())) {
+      return;
+    }
+    DatabaseQueryHandle taken = map.takeIf(queryKey, q -> q == query);
+    if (taken == null) {
+      return;
+    }
+    if (Boolean.TRUE.equals(taken.hasListeners())) {
+      // Prefer put-back so an active query stays registered. If a concurrent put claimed the
+      // slot, putIfAbsent fails and this taken query would be an orphan with listeners — clear
+      // them so SDK callbacks are not left attached outside the registry.
+      if (!map.putIfAbsent(queryKey, taken)) {
+        taken.removeAllEventListeners();
+      }
+    }
+  }
+
+  void takeAllAndRemove() {
+    List<DatabaseQueryHandle> remaining = map.takeAll();
+    for (DatabaseQueryHandle query : remaining) {
+      if (query != null) {
+        query.removeAllEventListeners();
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/database/RNFBDatabaseTransactionRegistry.java

@@ -0,0 +1,71 @@
+package io.invertase.firebase.database;
+
+/*
+ * 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 io.invertase.firebase.common.RNFBHandleCollisionException;
+import io.invertase.firebase.common.RNFBHandleMap;
+import java.util.List;
+
+/**
+ * Transaction handler map. Unique {@link #put} (occupied id aborts the incoming handler, then
+ * throws); callers {@link #take} or {@link #takeAllAndAbort} then {@code abort()} outside the
+ * HandleMap lock. Replace is {@link #registerReplacing} (atomic last wins).
+ */
+final class RNFBDatabaseTransactionRegistry {
+  private final RNFBHandleMap<Integer, DatabaseAbortable> map = new RNFBHandleMap<>();
+
+  void put(int transactionId, DatabaseAbortable handler) throws RNFBHandleCollisionException {
+    try {
+      map.put(transactionId, handler);
+    } catch (RNFBHandleCollisionException collision) {
+      if (handler != null) {
+        handler.abort();
+      }
+      throw collision;
+    }
+  }
+
+  /** Atomic replace (last wins). The replaced handler is not aborted (Firebase retry). */
+  void registerReplacing(int transactionId, DatabaseAbortable handler) {
+    map.putReplacing(transactionId, handler);
+  }
+
+  DatabaseAbortable get(int transactionId) {
+    return map.get(transactionId);
+  }
+
+  DatabaseAbortable take(int transactionId) {
+    return map.take(transactionId);
+  }
+
+  void takeAndAbort(int transactionId) {
+    DatabaseAbortable handler = map.take(transactionId);
+    if (handler != null) {
+      handler.abort();
+    }
+  }
+
+  void takeAllAndAbort() {
+    List<DatabaseAbortable> remaining = map.takeAll();
+    for (DatabaseAbortable handler : remaining) {
+      if (handler != null) {
+        handler.abort();
+      }
+    }
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/database/NativeRNFBTurboDatabaseQuery.java

@@ -26,11 +26,9 @@ import com.facebook.fbreact.specs.NativeRNFBTurboDatabaseQuerySpec;
 import com.facebook.react.bridge.*;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.database.*;
+import io.invertase.firebase.common.RNFBHandleCollisionException;
 import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
 import io.invertase.firebase.common.ReactNativeFirebaseModule;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
 import java.util.Objects;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
@@ -38,7 +36,7 @@ import javax.annotation.Nullable;
 public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySpec {
   private final DatabaseTurboModuleSupport turboSupport =
       new DatabaseTurboModuleSupport("RNFBDatabaseQuery");
-  private HashMap<String, ReactNativeFirebaseDatabaseQuery> queryMap = new HashMap<>();
+  private final RNFBDatabaseQueryRegistry queryMap = new RNFBDatabaseQueryRegistry();
 
   public NativeRNFBTurboDatabaseQuery(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -47,14 +45,7 @@ public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySp
   @Override
   @CallSuper
   public void invalidate() {
-    Iterator refIterator = queryMap.entrySet().iterator();
-    while (refIterator.hasNext()) {
-      Map.Entry pair = (Map.Entry) refIterator.next();
-      ReactNativeFirebaseDatabaseQuery databaseQuery =
-          (ReactNativeFirebaseDatabaseQuery) pair.getValue();
-      databaseQuery.removeAllEventListeners();
-      refIterator.remove();
-    }
+    queryMap.takeAllAndRemove();
 
     turboSupport.invalidate();
     super.invalidate();
@@ -67,16 +58,23 @@ public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySp
 
   private ReactNativeFirebaseDatabaseQuery getDatabaseQueryInstance(
       String key, DatabaseReference reference, ReadableArray modifiers) {
-    ReactNativeFirebaseDatabaseQuery cachedDatabaseQuery = queryMap.get(key);
+    DatabaseQueryHandle cached = queryMap.get(key);
 
-    if (cachedDatabaseQuery != null) {
-      return cachedDatabaseQuery;
+    if (cached instanceof ReactNativeFirebaseDatabaseQuery) {
+      return (ReactNativeFirebaseDatabaseQuery) cached;
     }
 
     ReactNativeFirebaseDatabaseQuery databaseQuery =
         new ReactNativeFirebaseDatabaseQuery(reference, modifiers);
 
-    queryMap.put(key, databaseQuery);
+    try {
+      queryMap.put(key, databaseQuery);
+    } catch (RNFBHandleCollisionException collision) {
+      DatabaseQueryHandle winner = queryMap.get(key);
+      if (winner instanceof ReactNativeFirebaseDatabaseQuery) {
+        return (ReactNativeFirebaseDatabaseQuery) winner;
+      }
+    }
     return databaseQuery;
   }
 
@@ -396,15 +394,13 @@ public class NativeRNFBTurboDatabaseQuery extends NativeRNFBTurboDatabaseQuerySp
 
   @Override
   public void off(String queryKey, String eventRegistrationKey) {
-    ReactNativeFirebaseDatabaseQuery databaseQuery = queryMap.get(queryKey);
+    DatabaseQueryHandle handle = queryMap.get(queryKey);
 
-    if (databaseQuery != null) {
+    if (handle instanceof ReactNativeFirebaseDatabaseQuery) {
+      ReactNativeFirebaseDatabaseQuery databaseQuery = (ReactNativeFirebaseDatabaseQuery) handle;
       databaseQuery.removeEventListener(eventRegistrationKey);
       turboSupport.removeEventListeningExecutor(eventRegistrationKey);
-
-      if (!databaseQuery.hasListeners()) {
-        queryMap.remove(queryKey);
-      }
+      queryMap.takeIfIdle(queryKey);
     }
   }
 

package/android/src/reactnative/java/io/invertase/firebase/database/NativeRNFBTurboDatabaseTransaction.java

@@ -20,7 +20,6 @@ package io.invertase.firebase.database;
 import static io.invertase.firebase.database.UniversalFirebaseDatabaseCommon.getDatabaseForApp;
 
 import android.os.AsyncTask;
-import android.util.SparseArray;
 import com.facebook.fbreact.specs.NativeRNFBTurboDatabaseTransactionSpec;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
@@ -31,8 +30,8 @@ import javax.annotation.Nonnull;
 
 public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseTransactionSpec {
   private static final String SERVICE_NAME = "DatabaseTransaction";
-  private static SparseArray<ReactNativeFirebaseDatabaseTransactionHandler> transactionHandlers =
-      new SparseArray<>();
+  private static final RNFBDatabaseTransactionRegistry transactionHandlers =
+      new RNFBDatabaseTransactionRegistry();
   private final DatabaseTurboModuleSupport turboSupport =
       new DatabaseTurboModuleSupport("RNFBDatabaseTransaction");
 
@@ -42,17 +41,7 @@ public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseT
 
   @Override
   public void invalidate() {
-    for (int i = 0, size = transactionHandlers.size(); i < size; i++) {
-      int key = transactionHandlers.keyAt(i);
-      ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
-          transactionHandlers.get(key);
-
-      if (transactionHandler != null) {
-        transactionHandler.abort();
-      }
-    }
-
-    transactionHandlers.clear();
+    transactionHandlers.takeAllAndAbort();
     turboSupport.invalidate();
   }
 
@@ -71,7 +60,7 @@ public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseT
                   final ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
                       new ReactNativeFirebaseDatabaseTransactionHandler(
                           (int) transactionId, app, dbURL);
-                  transactionHandlers.put((int) transactionId, transactionHandler);
+                  transactionHandlers.registerReplacing((int) transactionId, transactionHandler);
                   final WritableMap updatesMap = transactionHandler.createUpdateMap(mutableData);
 
                   AsyncTask.execute(
@@ -109,14 +98,15 @@ public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseT
                 @Override
                 public void onComplete(
                     DatabaseError error, boolean committed, DataSnapshot snapshot) {
-                  ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
-                      transactionHandlers.get((int) transactionId);
+                  DatabaseAbortable abortable = transactionHandlers.take((int) transactionId);
 
-                  if (transactionHandler == null) {
-                    transactionHandlers.delete((int) transactionId);
+                  if (!(abortable instanceof ReactNativeFirebaseDatabaseTransactionHandler)) {
                     return;
                   }
 
+                  ReactNativeFirebaseDatabaseTransactionHandler transactionHandler =
+                      (ReactNativeFirebaseDatabaseTransactionHandler) abortable;
+
                   WritableMap resultMap =
                       transactionHandler.createResultMap(error, committed, snapshot);
 
@@ -129,8 +119,6 @@ public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseT
                           resultMap,
                           app,
                           (int) transactionId));
-
-                  transactionHandlers.delete((int) transactionId);
                 }
               },
               applyLocally);
@@ -140,11 +128,10 @@ public class NativeRNFBTurboDatabaseTransaction extends NativeRNFBTurboDatabaseT
   @Override
   public void transactionTryCommit(
       String app, String dbURL, double transactionId, ReadableMap updates) {
-    ReactNativeFirebaseDatabaseTransactionHandler handler =
-        transactionHandlers.get((int) transactionId);
+    DatabaseAbortable abortable = transactionHandlers.get((int) transactionId);
 
-    if (handler != null) {
-      handler.signalUpdateReceived(updates);
+    if (abortable instanceof ReactNativeFirebaseDatabaseTransactionHandler) {
+      ((ReactNativeFirebaseDatabaseTransactionHandler) abortable).signalUpdateReceived(updates);
     }
   }
 }

package/android/src/reactnative/java/io/invertase/firebase/database/ReactNativeFirebaseDatabaseQuery.java

@@ -25,15 +25,14 @@ import com.google.firebase.database.ChildEventListener;
 import com.google.firebase.database.DatabaseReference;
 import com.google.firebase.database.Query;
 import com.google.firebase.database.ValueEventListener;
-import java.util.HashMap;
-import java.util.Iterator;
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import java.util.List;
 import java.util.Map;
 
-public class ReactNativeFirebaseDatabaseQuery {
+public class ReactNativeFirebaseDatabaseQuery implements DatabaseQueryHandle {
 
   public Query query;
-  private HashMap<String, ChildEventListener> childEventListeners = new HashMap<>();
-  private HashMap<String, ValueEventListener> valueEventListeners = new HashMap<>();
+  final RNFBDatabaseListenerRegistry listeners = new RNFBDatabaseListenerRegistry();
 
   ReactNativeFirebaseDatabaseQuery(DatabaseReference reference, ReadableArray modifiers) {
     this.query = reference;
@@ -78,7 +77,11 @@ public class ReactNativeFirebaseDatabaseQuery {
    * @param listener
    */
   public void addEventListener(String eventRegistrationKey, ValueEventListener listener) {
-    valueEventListeners.put(eventRegistrationKey, listener);
+    try {
+      listeners.putValue(eventRegistrationKey, listener);
+    } catch (RNFBHandleCollisionException | NullPointerException collision) {
+      return;
+    }
     query.addValueEventListener(listener);
   }
 
@@ -89,7 +92,11 @@ public class ReactNativeFirebaseDatabaseQuery {
    * @param listener
    */
   public void addEventListener(String eventRegistrationKey, ChildEventListener listener) {
-    childEventListeners.put(eventRegistrationKey, listener);
+    try {
+      listeners.putChild(eventRegistrationKey, listener);
+    } catch (RNFBHandleCollisionException | NullPointerException collision) {
+      return;
+    }
     query.addChildEventListener(listener);
   }
 
@@ -117,36 +124,26 @@ public class ReactNativeFirebaseDatabaseQuery {
    * @param eventRegistrationKey
    */
   public void removeEventListener(String eventRegistrationKey) {
-    if (valueEventListeners.containsKey(eventRegistrationKey)) {
-      query.removeEventListener(valueEventListeners.get(eventRegistrationKey));
-      valueEventListeners.remove(eventRegistrationKey);
+    Object valueListener = listeners.takeValue(eventRegistrationKey);
+    if (valueListener instanceof ValueEventListener) {
+      query.removeEventListener((ValueEventListener) valueListener);
     }
 
-    if (childEventListeners.containsKey(eventRegistrationKey)) {
-      query.removeEventListener(childEventListeners.get(eventRegistrationKey));
-      childEventListeners.remove(eventRegistrationKey);
+    Object childListener = listeners.takeChild(eventRegistrationKey);
+    if (childListener instanceof ChildEventListener) {
+      query.removeEventListener((ChildEventListener) childListener);
     }
   }
 
   /** Iterates over all current event listeners on the current query and removes each one */
+  @Override
   public void removeAllEventListeners() {
-    if (hasListeners()) {
-      Iterator valueIterator = valueEventListeners.entrySet().iterator();
-
-      while (valueIterator.hasNext()) {
-        Map.Entry pair = (Map.Entry) valueIterator.next();
-        ValueEventListener valueEventListener = (ValueEventListener) pair.getValue();
-        query.removeEventListener(valueEventListener);
-        valueIterator.remove();
-      }
-
-      Iterator childIterator = childEventListeners.entrySet().iterator();
-
-      while (childIterator.hasNext()) {
-        Map.Entry pair = (Map.Entry) childIterator.next();
-        ChildEventListener childEventListener = (ChildEventListener) pair.getValue();
-        query.removeEventListener(childEventListener);
-        childIterator.remove();
+    List<Object> remaining = listeners.takeAll();
+    for (Object listener : remaining) {
+      if (listener instanceof ValueEventListener) {
+        query.removeEventListener((ValueEventListener) listener);
+      } else if (listener instanceof ChildEventListener) {
+        query.removeEventListener((ChildEventListener) listener);
       }
     }
   }
@@ -158,8 +155,7 @@ public class ReactNativeFirebaseDatabaseQuery {
    * @return
    */
   public Boolean hasEventListener(String eventRegistrationKey) {
-    return valueEventListeners.containsKey(eventRegistrationKey)
-        || childEventListeners.containsKey(eventRegistrationKey);
+    return listeners.hasEventListener(eventRegistrationKey);
   }
 
   /**
@@ -167,8 +163,9 @@ public class ReactNativeFirebaseDatabaseQuery {
    *
    * @return
    */
+  @Override
   public Boolean hasListeners() {
-    return valueEventListeners.size() > 0 || childEventListeners.size() > 0;
+    return listeners.hasListeners();
   }
 
   /**

package/android/src/reactnative/java/io/invertase/firebase/database/ReactNativeFirebaseDatabaseTransactionHandler.java

@@ -32,7 +32,7 @@ import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 import javax.annotation.Nullable;
 
-public class ReactNativeFirebaseDatabaseTransactionHandler {
+public class ReactNativeFirebaseDatabaseTransactionHandler implements DatabaseAbortable {
   private final ReentrantLock lock;
   private final Condition condition;
   public Object value;
@@ -81,8 +81,8 @@ public class ReactNativeFirebaseDatabaseTransactionHandler {
     }
   }
 
-  /** Abort the currently in progress transaction if any. */
-  void abort() {
+  @Override
+  public void abort() {
     lock.lock();
     try {
       abort = true;