@react-native-firebase/storage 26.3.3 → 26.4.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 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
+
+- **storage:** use RNFBHandleMap for pending tasks ([acf77f1](https://github.com/invertase/react-native-firebase/commit/acf77f1ff1680f1ce9c65f72cf0056df7b998aa5))
+
 ## [26.3.3](https://github.com/invertase/react-native-firebase/compare/v26.3.2...v26.3.3) (2026-09-01)
 
 ### Bug Fixes

package/RNFBStorage.podspec

@@ -33,7 +33,7 @@ Pod::Spec.new do |s|
     'ios/RNFBStorage/*.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/**'
 
   # Must be set before install_modules_dependencies so RN can append use_frameworks
   # HEADER_SEARCH_PATHS (React-debug etc.). Assigning after overwrites those paths

package/android/build.gradle

@@ -93,6 +93,9 @@ dependencies {
   api appProject
   implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
   implementation "com.google.firebase:firebase-storage"
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.mockito:mockito-core:5.14.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/src/main/java/io/invertase/firebase/storage/NativeRNFBTurboStorage.java

@@ -56,7 +56,7 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
 
   @Override
   public void invalidate() {
-    ReactNativeFirebaseStorageTask.destroyAllTasks();
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.takeAllAndCancel();
     super.invalidate();
   }
 
@@ -274,6 +274,10 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
       ReactNativeFirebaseStorageDownloadTask storageTask =
           new ReactNativeFirebaseStorageDownloadTask((int) taskId, reference, appName);
       storageTask.begin(getTransactionalExecutor(), localFilePath);
+      if (storageTask.hasStorageTask() && !storageTask.registerPending()) {
+        rejectPromiseWithCodeAndMessage(promise, "internal", "Handle id already registered");
+        return;
+      }
       storageTask.addOnCompleteListener(getTransactionalExecutor(), promise);
     } catch (Exception e) {
       promiseRejectStorageException(promise, e);
@@ -294,6 +298,10 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
       ReactNativeFirebaseStorageUploadTask storageTask =
           new ReactNativeFirebaseStorageUploadTask((int) taskId, reference, appName);
       storageTask.begin(getTransactionalExecutor(), string, format, metadataMap);
+      if (!storageTask.registerPending()) {
+        rejectPromiseWithCodeAndMessage(promise, "internal", "Handle id already registered");
+        return;
+      }
       storageTask.addOnCompleteListener(getTransactionalExecutor(), promise);
     } catch (Exception e) {
       promiseRejectStorageException(promise, e);
@@ -313,6 +321,10 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
       ReactNativeFirebaseStorageUploadTask storageTask =
           new ReactNativeFirebaseStorageUploadTask((int) taskId, reference, appName);
       storageTask.begin(getTransactionalExecutor(), localFilePath, metadata);
+      if (!storageTask.registerPending()) {
+        rejectPromiseWithCodeAndMessage(promise, "internal", "Handle id already registered");
+        return;
+      }
       storageTask.addOnCompleteListener(getTransactionalExecutor(), promise);
     } catch (Exception e) {
       promiseRejectStorageException(promise, e);
@@ -321,13 +333,21 @@ public class NativeRNFBTurboStorage extends NativeRNFBTurboStorageSpec {
 
   @Override
   public boolean setTaskStatus(String appName, double taskId, double status) {
+    RNFBStorageTaskRegistry tasks = ReactNativeFirebaseStorageTask.PENDING_TASKS;
+    int id = (int) taskId;
     switch ((int) status) {
       case 0:
-        return ReactNativeFirebaseStorageTask.pauseTaskById((int) taskId);
+        {
+          StoragePendingHandle handle = tasks.get(id);
+          return handle != null && handle.pause();
+        }
       case 1:
-        return ReactNativeFirebaseStorageTask.resumeTaskById((int) taskId);
+        {
+          StoragePendingHandle handle = tasks.get(id);
+          return handle != null && handle.resume();
+        }
       case 2:
-        return ReactNativeFirebaseStorageTask.cancelTaskById((int) taskId);
+        return tasks.takeAndCancel(id);
       default:
         return false;
     }

package/android/src/main/java/io/invertase/firebase/storage/RNFBStorageTaskRegistry.java

@@ -0,0 +1,93 @@
+package io.invertase.firebase.storage;
+
+/*
+ * 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;
+import java.util.function.Predicate;
+
+/**
+ * Pending upload/download task map. Unique {@link #put}; callers {@link #take} or {@link
+ * #takeAllAndCancel} then cancel outside the HandleMap lock.
+ */
+final class RNFBStorageTaskRegistry {
+  private final RNFBHandleMap<Integer, StoragePendingHandle> map = new RNFBHandleMap<>();
+
+  void put(int taskId, StoragePendingHandle handle) throws RNFBHandleCollisionException {
+    map.put(taskId, handle);
+  }
+
+  /**
+   * Unique put. On collision, {@code cancel()} the incoming handle and leave the existing mapping.
+   *
+   * @return true if stored
+   */
+  boolean putOrDiscard(int taskId, StoragePendingHandle handle) {
+    if (map.putIfAbsent(taskId, handle)) {
+      return true;
+    }
+    if (handle != null) {
+      handle.cancel();
+    }
+    return false;
+  }
+
+  StoragePendingHandle get(int taskId) {
+    return map.get(taskId);
+  }
+
+  StoragePendingHandle take(int taskId) {
+    return map.take(taskId);
+  }
+
+  StoragePendingHandle takeIf(int taskId, Predicate<StoragePendingHandle> shouldTake) {
+    return map.takeIf(taskId, shouldTake);
+  }
+
+  /**
+   * Cancel outside the HandleMap lock; remove the mapping only when cancel succeeds. Returns {@code
+   * false} when no mapping existed or cancel failed. Trailing unregister is identity-gated so a
+   * replacement put after {@code cancel()} (e.g. production {@code destroyTask}) is not stolen.
+   *
+   * <p>Shape: get → cancel → identity takeIf on success (keep mapping when cancel returns false).
+   * iOS registry mirrors get → cancel → identity takeIf, but FIRStorage cancel is void so there is
+   * no keep-on-false path — see {@code RNFBStorageTaskRegistry.takeAndCancel:} / helper {@code
+   * setTaskStatus}.
+   */
+  boolean takeAndCancel(int taskId) {
+    StoragePendingHandle handle = map.get(taskId);
+    if (handle == null) {
+      return false;
+    }
+    boolean cancelled = handle.cancel();
+    if (cancelled) {
+      map.takeIf(taskId, h -> h == handle);
+    }
+    return cancelled;
+  }
+
+  void takeAllAndCancel() {
+    List<StoragePendingHandle> remaining = map.takeAll();
+    for (StoragePendingHandle handle : remaining) {
+      if (handle != null) {
+        handle.cancel();
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/storage/ReactNativeFirebaseStorageTask.java

@@ -23,14 +23,13 @@ import static io.invertase.firebase.storage.ReactNativeFirebaseStorageCommon.STA
 import static io.invertase.firebase.storage.ReactNativeFirebaseStorageCommon.getExceptionCodeAndMessage;
 
 import android.util.Log;
-import android.util.SparseArray;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.google.firebase.storage.StorageReference;
 import com.google.firebase.storage.StorageTask;
 import javax.annotation.Nullable;
 
-class ReactNativeFirebaseStorageTask {
+class ReactNativeFirebaseStorageTask implements StoragePendingHandle {
   static final String KEY_STATE = "state";
   static final String KEY_META_DATA = "metadata";
   static final String KEY_TOTAL_BYTES = "totalBytes";
@@ -39,8 +38,7 @@ class ReactNativeFirebaseStorageTask {
   private static final String KEY_CODE = "code";
   private static final String KEY_MESSAGE = "message";
   private static final String KEY_NATIVE_ERROR_MESSAGE = "nativeErrorMessage";
-  private static final SparseArray<ReactNativeFirebaseStorageTask> PENDING_TASKS =
-      new SparseArray<>();
+  static final RNFBStorageTaskRegistry PENDING_TASKS = new RNFBStorageTaskRegistry();
   private static final String TAG = "RNFBStorageTask";
   int taskId;
   String appName;
@@ -51,43 +49,15 @@ class ReactNativeFirebaseStorageTask {
     this.taskId = taskId;
     this.storageReference = storageReference;
     this.appName = appName;
-    PENDING_TASKS.put(taskId, this);
   }
 
-  static boolean pauseTaskById(int taskId) {
-    ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(taskId);
-    if (reactNativeFirebaseStorageTask != null) {
-      return reactNativeFirebaseStorageTask.pause();
-    }
-
-    return false;
-  }
-
-  static boolean resumeTaskById(int taskId) {
-    ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(taskId);
-    if (reactNativeFirebaseStorageTask != null) {
-      return reactNativeFirebaseStorageTask.resume();
-    }
-
-    return false;
+  /** Register after the native {@link StorageTask} exists; collision cancels this handle. */
+  boolean registerPending() {
+    return PENDING_TASKS.putOrDiscard(taskId, this);
   }
 
-  static boolean cancelTaskById(int taskId) {
-    ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(taskId);
-    if (reactNativeFirebaseStorageTask != null) {
-      return reactNativeFirebaseStorageTask.cancel();
-    }
-
-    return false;
-  }
-
-  static void destroyAllTasks() {
-    for (int i = 0, size = PENDING_TASKS.size(); i < size; i++) {
-      int key = PENDING_TASKS.keyAt(i);
-      ReactNativeFirebaseStorageTask reactNativeFirebaseStorageTask = PENDING_TASKS.get(key);
-      reactNativeFirebaseStorageTask.cancel();
-    }
-    PENDING_TASKS.clear();
+  boolean hasStorageTask() {
+    return storageTask != null;
   }
 
   static WritableMap buildCancelledSnapshotMap(WritableMap snapshot) {
@@ -108,39 +78,48 @@ class ReactNativeFirebaseStorageTask {
     return taskMap;
   }
 
-  private boolean pause() {
+  @Override
+  public boolean pause() {
     Log.d(TAG, "pausing task for " + storageReference.toString());
 
-    if (!storageTask.isPaused() && storageTask.isInProgress()) {
+    if (storageTask != null && !storageTask.isPaused() && storageTask.isInProgress()) {
       return storageTask.pause();
     }
 
     return false;
   }
 
-  private boolean resume() {
+  @Override
+  public boolean resume() {
     Log.d(TAG, "resuming task for " + storageReference.toString());
 
-    if (storageTask.isPaused()) {
+    if (storageTask != null && storageTask.isPaused()) {
       return storageTask.resume();
     }
 
     return false;
   }
 
-  private boolean cancel() {
+  @Override
+  public boolean cancel() {
     Log.d(TAG, "cancelling task for " + storageReference.toString());
 
-    if (!storageTask.isCanceled() && storageTask.isInProgress()) {
-      destroyTask();
-      return storageTask.cancel();
+    if (storageTask != null
+        && !storageTask.isCanceled()
+        && !storageTask.isComplete()
+        && (storageTask.isInProgress() || storageTask.isPaused())) {
+      if (storageTask.cancel()) {
+        destroyTask();
+        return true;
+      }
     }
 
     return false;
   }
 
   void destroyTask() {
-    PENDING_TASKS.remove(taskId);
+    // Identity-gated: cancel of a discarded collision must not evict another handle at taskId.
+    PENDING_TASKS.takeIf(taskId, handle -> handle == this);
 
     Log.d(TAG, "destroyed completed task for " + storageReference.toString());
   }

package/android/src/main/java/io/invertase/firebase/storage/StoragePendingHandle.java

@@ -0,0 +1,30 @@
+package io.invertase.firebase.storage;
+
+/*
+ * 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.
+ *
+ */
+
+/**
+ * Pause / resume / cancel surface stored in {@link RNFBStorageTaskRegistry}. Invoked after {@code
+ * get}/{@code take}/{@code takeAll}, never under the HandleMap lock.
+ */
+interface StoragePendingHandle {
+  boolean pause();
+
+  boolean resume();
+
+  boolean cancel();
+}

package/android/src/test/java/io/invertase/firebase/storage/RNFBStorageTaskRegistryTest.java

@@ -0,0 +1,212 @@
+package io.invertase.firebase.storage;
+
+/*
+ * 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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import org.junit.Test;
+
+public class RNFBStorageTaskRegistryTest {
+
+  private static final class FakeHandle implements StoragePendingHandle {
+    int pauseCount;
+    int resumeCount;
+    int cancelCount;
+    boolean pauseResult = true;
+    boolean resumeResult = true;
+    boolean cancelResult = true;
+    Runnable onCancel;
+
+    @Override
+    public boolean pause() {
+      pauseCount++;
+      return pauseResult;
+    }
+
+    @Override
+    public boolean resume() {
+      resumeCount++;
+      return resumeResult;
+    }
+
+    @Override
+    public boolean cancel() {
+      cancelCount++;
+      if (onCancel != null) {
+        onCancel.run();
+      }
+      return cancelResult;
+    }
+  }
+
+  @Test
+  public void putGetTake_happyPath() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put(1, handle);
+    assertSame(handle, registry.get(1));
+    assertSame(handle, registry.take(1));
+    assertNull(registry.get(1));
+    assertEquals(0, handle.cancelCount);
+  }
+
+  @Test
+  public void put_occupiedId_throwsCollision() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put(1, first);
+    try {
+      registry.put(1, new FakeHandle());
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("1"));
+      assertSame(first, registry.get(1));
+    }
+  }
+
+  @Test
+  public void putOrDiscard_collision_cancelsIncoming() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    FakeHandle duplicate = new FakeHandle();
+    registry.put(2, first);
+    assertFalse(registry.putOrDiscard(2, duplicate));
+    assertEquals(1, duplicate.cancelCount);
+    assertEquals(0, first.cancelCount);
+    assertSame(first, registry.get(2));
+  }
+
+  @Test
+  public void putOrDiscard_storesWhenFree() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    assertTrue(registry.putOrDiscard(3, handle));
+    assertSame(handle, registry.get(3));
+    assertEquals(0, handle.cancelCount);
+  }
+
+  @Test
+  public void putOrDiscard_collision_nullIncoming_isNoOp() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put(4, first);
+    assertFalse(registry.putOrDiscard(4, null));
+    assertSame(first, registry.get(4));
+  }
+
+  @Test
+  public void takeAndCancel_cancelsAfterTake() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put(5, handle);
+    assertTrue(registry.takeAndCancel(5));
+    assertEquals(1, handle.cancelCount);
+    assertNull(registry.get(5));
+  }
+
+  @Test
+  public void takeAndCancel_missingKey_isNoOp() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    assertFalse(registry.takeAndCancel(99));
+    assertNull(registry.get(99));
+  }
+
+  @Test
+  public void takeAndCancel_whenCancelReturnsFalse_keepsMapping() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle handle = new FakeHandle();
+    handle.cancelResult = false;
+    registry.put(6, handle);
+    assertFalse(registry.takeAndCancel(6));
+    assertEquals(1, handle.cancelCount);
+    assertSame(handle, registry.get(6));
+  }
+
+  /**
+   * Regression: production cancel may destroyTask (clear A) then a new put B can land at the same
+   * id before takeAndCancel's trailing unregister. Trailing take must be identity-gated so B stays.
+   */
+  @Test
+  public void takeAndCancel_replacementDuringCancel_leavesReplacement() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle replacement = new FakeHandle();
+    FakeHandle original = new FakeHandle();
+    original.onCancel =
+        () -> {
+          // Simulate destroyTask clearing this handle, then a new put at the same id.
+          assertSame(original, registry.take(9));
+          try {
+            registry.put(9, replacement);
+          } catch (RNFBHandleCollisionException e) {
+            fail(e.getMessage());
+          }
+        };
+    registry.put(9, original);
+    assertTrue(registry.takeAndCancel(9));
+    assertEquals(1, original.cancelCount);
+    assertSame(replacement, registry.get(9));
+    assertEquals(0, replacement.cancelCount);
+  }
+
+  @Test
+  public void takeAllAndCancel_cancelsSnapshotAndLeavesEmpty() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle a = new FakeHandle();
+    FakeHandle b = new FakeHandle();
+    registry.put(1, a);
+    registry.put(2, b);
+    registry.takeAllAndCancel();
+    assertEquals(1, a.cancelCount);
+    assertEquals(1, b.cancelCount);
+    assertNull(registry.get(1));
+    assertNull(registry.get(2));
+  }
+
+  @Test
+  public void takeAllAndCancel_empty_isNoOp() {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    registry.takeAllAndCancel();
+    assertNull(registry.get(1));
+  }
+
+  @Test
+  public void takeAllAndCancel_nullHandle_isNoOp() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    registry.put(6, null);
+    registry.takeAllAndCancel();
+    assertNull(registry.get(6));
+  }
+
+  @Test
+  public void put_afterTake_allowsReuse() throws Exception {
+    RNFBStorageTaskRegistry registry = new RNFBStorageTaskRegistry();
+    FakeHandle first = new FakeHandle();
+    FakeHandle second = new FakeHandle();
+    registry.put(1, first);
+    assertSame(first, registry.take(1));
+    registry.put(1, second);
+    assertSame(second, registry.get(1));
+    assertEquals(0, first.cancelCount);
+  }
+}