@react-native-firebase/storage 26.3.2 → 26.4.0

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

@@ -0,0 +1,285 @@
+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.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+import android.util.Log;
+import com.google.firebase.storage.StorageReference;
+import com.google.firebase.storage.StorageTask;
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.MockedStatic;
+
+public class ReactNativeFirebaseStorageTaskTest {
+
+  private static final class FakeHandle implements StoragePendingHandle {
+    int cancelCount;
+
+    @Override
+    public boolean pause() {
+      return false;
+    }
+
+    @Override
+    public boolean resume() {
+      return false;
+    }
+
+    @Override
+    public boolean cancel() {
+      cancelCount++;
+      return true;
+    }
+  }
+
+  private static final class RecordingTask extends ReactNativeFirebaseStorageTask {
+    int beginCount;
+
+    RecordingTask(int taskId) {
+      super(taskId, null, "app");
+    }
+
+    void begin() {
+      beginCount++;
+    }
+  }
+
+  @After
+  public void tearDown() {
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(11);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(12);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(13);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(14);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(15);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(16);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(17);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(18);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(19);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(20);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(21);
+    ReactNativeFirebaseStorageTask.PENDING_TASKS.take(22);
+  }
+
+  private static StorageReference stubReference() {
+    StorageReference ref = mock(StorageReference.class);
+    when(ref.toString()).thenReturn("gs://bucket/path");
+    return ref;
+  }
+
+  private static ReactNativeFirebaseStorageTask registeredTask(int taskId) {
+    ReactNativeFirebaseStorageTask task =
+        new ReactNativeFirebaseStorageTask(taskId, stubReference(), "app");
+    assertTrue(task.registerPending());
+    return task;
+  }
+
+  @Test
+  public void constructor_uniqueId_registersPendingTask() {
+    RecordingTask task = new RecordingTask(11);
+    assertTrue(task.registerPending());
+    assertSame(task, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(11));
+    task.begin();
+    assertEquals(1, task.beginCount);
+  }
+
+  @Test
+  public void registerPending_occupiedId_cancelsIncomingAndKeepsExisting() throws Exception {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      FakeHandle first = new FakeHandle();
+      ReactNativeFirebaseStorageTask.PENDING_TASKS.put(12, first);
+      ReactNativeFirebaseStorageTask second =
+          new ReactNativeFirebaseStorageTask(12, stubReference(), "app");
+      assertFalse(second.registerPending());
+      assertSame(first, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(12));
+      assertEquals(0, first.cancelCount);
+    }
+  }
+
+  /**
+   * Regression: when the incoming handle has a live StorageTask whose cancel() succeeds,
+   * destroyTask must not evict the existing mapping at the same taskId (identity-gated take).
+   */
+  @Test
+  public void registerPending_occupiedId_successfulCancelDoesNotEvictExisting() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask existing = registeredTask(22);
+
+      ReactNativeFirebaseStorageTask incoming =
+          new ReactNativeFirebaseStorageTask(22, stubReference(), "app");
+      StorageTask<?> storageTask = mock(StorageTask.class);
+      incoming.setStorageTask(storageTask);
+      when(storageTask.isCanceled()).thenReturn(false);
+      when(storageTask.isComplete()).thenReturn(false);
+      when(storageTask.isPaused()).thenReturn(false);
+      when(storageTask.isInProgress()).thenReturn(true);
+      when(storageTask.cancel()).thenReturn(true);
+
+      assertFalse(incoming.registerPending());
+      assertSame(existing, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(22));
+    }
+  }
+
+  @Test
+  public void pauseResumeCancel_whenStorageTaskNull_returnFalseWithoutNpe() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(13);
+      assertSame(task, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(13));
+      assertFalse(task.pause());
+      assertFalse(task.resume());
+      assertFalse(task.cancel());
+      assertSame(task, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(13));
+    }
+  }
+
+  @Test
+  public void cancelIfPresent_whenStorageTaskNull_doesNotTakeMapping() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(14);
+      assertFalse(ReactNativeFirebaseStorageTask.PENDING_TASKS.takeAndCancel(14));
+      assertSame(task, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(14));
+      assertFalse(task.pause());
+    }
+  }
+
+  @Test
+  public void setTaskStatusCancel_whenStorageTaskNull_doesNotTakeMapping() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      registeredTask(15);
+      assertFalse(ReactNativeFirebaseStorageTask.PENDING_TASKS.takeAndCancel(15));
+      assertNotNull(ReactNativeFirebaseStorageTask.PENDING_TASKS.get(15));
+    }
+  }
+
+  @Test
+  public void destroyTask_takesPendingMapping() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(16);
+      task.destroyTask();
+      assertNull(ReactNativeFirebaseStorageTask.PENDING_TASKS.get(16));
+    }
+  }
+
+  @Test
+  public void invalidate_whenStorageTaskNull_takeAllThenCancelWithoutNpe() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      registeredTask(17);
+      ReactNativeFirebaseStorageTask.PENDING_TASKS.takeAllAndCancel();
+      assertNull(ReactNativeFirebaseStorageTask.PENDING_TASKS.get(17));
+    }
+  }
+
+  @Test
+  public void pauseResumeCancel_whenStorageTaskPresent_delegateToSdkTask() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(18);
+      StorageTask<?> storageTask = mock(StorageTask.class);
+      task.setStorageTask(storageTask);
+
+      when(storageTask.isPaused()).thenReturn(false);
+      when(storageTask.isInProgress()).thenReturn(true);
+      when(storageTask.pause()).thenReturn(true);
+      assertTrue(task.pause());
+
+      when(storageTask.isPaused()).thenReturn(true);
+      when(storageTask.resume()).thenReturn(true);
+      assertTrue(task.resume());
+
+      when(storageTask.isPaused()).thenReturn(false);
+      when(storageTask.isCanceled()).thenReturn(false);
+      when(storageTask.isInProgress()).thenReturn(true);
+      when(storageTask.cancel()).thenReturn(true);
+      assertTrue(task.cancel());
+      assertNull(ReactNativeFirebaseStorageTask.PENDING_TASKS.get(18));
+    }
+  }
+
+  @Test
+  public void cancel_whenPaused_delegatesToSdkTask() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(19);
+      StorageTask<?> storageTask = mock(StorageTask.class);
+      task.setStorageTask(storageTask);
+
+      when(storageTask.isCanceled()).thenReturn(false);
+      when(storageTask.isComplete()).thenReturn(false);
+      when(storageTask.isPaused()).thenReturn(true);
+      when(storageTask.isInProgress()).thenReturn(false);
+      when(storageTask.cancel()).thenReturn(true);
+
+      assertTrue(task.cancel());
+      assertNull(ReactNativeFirebaseStorageTask.PENDING_TASKS.get(19));
+    }
+  }
+
+  @Test
+  public void takeAndCancel_whenPausedCancelSucceeds_takesMapping() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(20);
+      StorageTask<?> storageTask = mock(StorageTask.class);
+      task.setStorageTask(storageTask);
+
+      when(storageTask.isCanceled()).thenReturn(false);
+      when(storageTask.isComplete()).thenReturn(false);
+      when(storageTask.isPaused()).thenReturn(true);
+      when(storageTask.isInProgress()).thenReturn(false);
+      when(storageTask.cancel()).thenReturn(true);
+
+      assertTrue(ReactNativeFirebaseStorageTask.PENDING_TASKS.takeAndCancel(20));
+      assertNull(ReactNativeFirebaseStorageTask.PENDING_TASKS.get(20));
+    }
+  }
+
+  @Test
+  public void cancel_whenSdkCancelReturnsFalse_keepsMapping() {
+    try (MockedStatic<Log> ignored = mockStatic(Log.class)) {
+      when(Log.d(anyString(), anyString())).thenReturn(0);
+      ReactNativeFirebaseStorageTask task = registeredTask(21);
+      StorageTask<?> storageTask = mock(StorageTask.class);
+      task.setStorageTask(storageTask);
+
+      when(storageTask.isCanceled()).thenReturn(false);
+      when(storageTask.isComplete()).thenReturn(false);
+      when(storageTask.isPaused()).thenReturn(true);
+      when(storageTask.isInProgress()).thenReturn(false);
+      when(storageTask.cancel()).thenReturn(false);
+
+      assertFalse(task.cancel());
+      assertSame(task, ReactNativeFirebaseStorageTask.PENDING_TASKS.get(21));
+    }
+  }
+}

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '26.3.2';
+export const version = '26.4.0';
 //# sourceMappingURL=version.js.map

package/dist/typescript/lib/index.d.ts

@@ -1,7 +1,7 @@
 import type { FirebaseApp } from '@react-native-firebase/app';
 import './types/internal';
 import type { EmulatorMockTokenOptions, FirebaseStorage, FullMetadata, ListOptions, ListResult, SettableMetadata, StorageReference, Task, UploadMetadata, UploadResult, UploadTask } from './types/storage';
-export declare const SDK_VERSION = "26.3.2";
+export declare const SDK_VERSION = "26.4.0";
 export declare function getStorage(app?: FirebaseApp, bucketUrl?: string): FirebaseStorage;
 export type * from './types/storage';
 export { StringFormat, TaskEvent, TaskState } from './StorageStatics';

package/dist/typescript/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "26.3.2";
+export declare const version = "26.4.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RNFBStorage/RNFBStorageHelper.m

@@ -28,6 +28,7 @@
 #import "RNFBRCTEventEmitter.h"
 #import "RNFBStorageCommon.h"
 #import "RNFBStorageHelper.h"
+#import "RNFBStorageTaskRegistry.h"
 
 static NSString *const RNFB_STORAGE_EVENT = @"storage_event";
 static NSString *const RNFB_STORAGE_STATE_CHANGED = @"state_changed";
@@ -36,7 +37,7 @@ static NSString *const RNFB_STORAGE_UPLOAD_FAILURE = @"upload_failure";
 static NSString *const RNFB_STORAGE_DOWNLOAD_SUCCESS = @"download_success";
 static NSString *const RNFB_STORAGE_DOWNLOAD_FAILURE = @"download_failure";
 
-static NSMutableDictionary *PENDING_TASKS;
+static RNFBStorageTaskRegistry *pendingTasks;
 
 // The iOS SDK has a short memory on settings, store these globally and set them in each time
 static NSString *emulatorHost = nil;
@@ -54,16 +55,14 @@ static NSTimeInterval maxOperationRetryTime = 120;
 + (void)initializeSharedStateOnce {
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    PENDING_TASKS = [[NSMutableDictionary alloc] init];
+    pendingTasks = [[RNFBStorageTaskRegistry alloc] init];
     emulatorConfigs = [[NSMutableDictionary alloc] init];
   });
 }
 
 + (void)invalidate {
   [self initializeSharedStateOnce];
-  for (NSString *key in [PENDING_TASKS allKeys]) {
-    [PENDING_TASKS removeObjectForKey:key];
-  }
+  [pendingTasks cancelAll];
 }
 
 #pragma mark -
@@ -283,7 +282,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
     downloadTask = [storageReference writeToFile:localFile];
   });
 
-  PENDING_TASKS[taskIdNumber] = downloadTask;
+  if (![pendingTasks putOrDiscard:taskIdNumber value:downloadTask]) {
+    reject(@"internal", @"Handle id already registered", nil);
+    return;
+  }
 
   [downloadTask
       observeStatus:FIRStorageTaskStatusResume
@@ -324,7 +326,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
   [downloadTask
       observeStatus:FIRStorageTaskStatusSuccess
             handler:^(FIRStorageTaskSnapshot *snapshot) {
-              [PENDING_TASKS removeObjectForKey:taskIdNumber];
+              [pendingTasks takeIf:taskIdNumber
+                              when:^BOOL(id value) {
+                                return value == downloadTask;
+                              }];
 
               NSDictionary *stateChangedEventBody =
                   [RNFBStorageCommon getDownloadTaskAsDictionary:snapshot];
@@ -349,7 +354,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
   [downloadTask
       observeStatus:FIRStorageTaskStatusFailure
             handler:^(FIRStorageTaskSnapshot *snapshot) {
-              [PENDING_TASKS removeObjectForKey:taskIdNumber];
+              [pendingTasks takeIf:taskIdNumber
+                              when:^BOOL(id value) {
+                                return value == downloadTask;
+                              }];
 
               NSDictionary *stateChangedEventBody =
                   [RNFBStorageCommon getDownloadTaskAsDictionary:snapshot];
@@ -501,7 +509,7 @@ static NSTimeInterval maxOperationRetryTime = 120;
 + (NSNumber *)setTaskStatus:(NSString *)appName taskId:(double)taskId status:(double)status {
   [self initializeSharedStateOnce];
   NSNumber *taskIdNumber = @(taskId);
-  id task = PENDING_TASKS[taskIdNumber];
+  id task = [pendingTasks get:taskIdNumber];
   if (task == nil) {
     return @NO;
   }
@@ -546,7 +554,15 @@ static NSTimeInterval maxOperationRetryTime = 120;
           (currentStatus == FIRStorageTaskStatusResume ||
            currentStatus == FIRStorageTaskStatusProgress ||
            currentStatus == FIRStorageTaskStatusPause)) {
-        [PENDING_TASKS removeObjectForKey:taskIdNumber];
+        // Identity take then cancel so a replacement at taskId is not stolen.
+        // Ordering differs from registry takeAndCancel: (takeIf → cancel) vs Android
+        // (get → cancel → takeIf). Both are identity-safe; FIRStorage cancel is void.
+        if ([pendingTasks takeIf:taskIdNumber
+                            when:^BOOL(id value) {
+                              return value == task;
+                            }] == nil) {
+          return @NO;
+        }
         if ([task isKindOfClass:[FIRStorageDownloadTask class]]) {
           [(FIRStorageDownloadTask *)task cancel];
         } else {
@@ -595,7 +611,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
                       resolver:(RCTPromiseResolveBlock)resolve
                       rejecter:(RCTPromiseRejectBlock)reject {
   [self initializeSharedStateOnce];
-  PENDING_TASKS[taskId] = uploadTask;
+  if (![pendingTasks putOrDiscard:taskId value:uploadTask]) {
+    reject(@"internal", @"Handle id already registered", nil);
+    return;
+  }
 
   [uploadTask
       observeStatus:FIRStorageTaskStatusResume
@@ -635,7 +654,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
 
   [uploadTask observeStatus:FIRStorageTaskStatusSuccess
                     handler:^(FIRStorageTaskSnapshot *snapshot) {
-                      [PENDING_TASKS removeObjectForKey:taskId];
+                      [pendingTasks takeIf:taskId
+                                      when:^BOOL(id value) {
+                                        return value == uploadTask;
+                                      }];
 
                       NSDictionary *eventBody =
                           [RNFBStorageCommon getUploadTaskAsDictionary:snapshot];
@@ -661,7 +683,10 @@ static NSTimeInterval maxOperationRetryTime = 120;
   [uploadTask
       observeStatus:FIRStorageTaskStatusFailure
             handler:^(FIRStorageTaskSnapshot *snapshot) {
-              [PENDING_TASKS removeObjectForKey:taskId];
+              [pendingTasks takeIf:taskId
+                              when:^BOOL(id value) {
+                                return value == uploadTask;
+                              }];
 
               NSMutableDictionary *taskSnapshotDict =
                   [RNFBStorageCommon getUploadTaskAsDictionary:snapshot];

package/ios/RNFBStorage/RNFBStorageModule.mm

@@ -239,13 +239,12 @@ RCT_EXPORT_MODULE(NativeRNFBTurboStorage);
 #pragma mark -
 #pragma mark Constants
 
-- (facebook::react::ModuleConstants<JS::NativeRNFBTurboStorage::Constants::Builder>)
-    constantsToExport {
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboStorage::Constants>)constantsToExport {
   return [_RCTTypedModuleConstants
       newWithUnsafeDictionary:[RNFBStorageHelper storageConstantsDictionary]];
 }
 
-- (facebook::react::ModuleConstants<JS::NativeRNFBTurboStorage::Constants::Builder>)getConstants {
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboStorage::Constants>)getConstants {
   return [self constantsToExport];
 }
 

package/ios/RNFBStorage/RNFBStorageTaskRegistry.h

@@ -0,0 +1,42 @@
+/**
+ * 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 <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Pending upload/download task map. Unique `put`; callers `take` or `cancelAll` then cancel
+ * outside the HandleMap lock. Stored values are expected to respond to `cancel`.
+ */
+@interface RNFBStorageTaskRegistry : NSObject
+
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+/// Unique put. On collision, `cancel`s the incoming value and leaves the existing mapping.
+- (BOOL)putOrDiscard:(id)key value:(id)value;
+- (nullable id)get:(id)key;
+- (nullable id)take:(id)key;
+/// Identity-gated take; see RNFBHandleMap `takeIf:when:`.
+- (nullable id)takeIf:(id)key when:(BOOL (^)(id value))condition;
+/// get → cancel → identity take (Android shape). FIRStorage cancel is void (no keep-on-false).
+/// Production setTaskStatus cancel uses takeIf then cancel; see RNFBStorageHelper.
+- (BOOL)takeAndCancel:(id)key;
+- (void)cancelAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBStorage/RNFBStorageTaskRegistry.m

@@ -0,0 +1,94 @@
+/**
+ * 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 "RNFBStorageTaskRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+@interface RNFBStorageTaskRegistry ()
+@property(nonatomic, strong) RNFBHandleMap *map;
+@end
+
+@implementation RNFBStorageTaskRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _map = [[RNFBHandleMap alloc] init];
+  }
+  return self;
+}
+
+- (void)rnfb_cancelHandle:(id)handle {
+  if (handle && [handle respondsToSelector:@selector(cancel)]) {
+    [handle cancel];
+  }
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  return [self.map put:key value:value error:error];
+}
+
+- (BOOL)putOrDiscard:(id)key value:(id)value {
+  if ([self.map putIfAbsent:key value:value]) {
+    return YES;
+  }
+  [self rnfb_cancelHandle:value];
+  return NO;
+}
+
+- (id)get:(id)key {
+  return [self.map get:key];
+}
+
+- (id)take:(id)key {
+  return [self.map take:key];
+}
+
+- (id)takeIf:(id)key when:(BOOL (^)(id))condition {
+  return [self.map takeIf:key when:condition];
+}
+
+- (BOOL)takeAndCancel:(id)key {
+  // Align with Android RNFBStorageTaskRegistry.takeAndCancel: get → cancel → identity take.
+  // FIRStorage*Task cancel is void (no BOOL), so there is no keep-on-false path; always
+  // identity-take after cancel. Production setTaskStatus cancel uses takeIf then cancel
+  // (RNFBStorageHelper) — identity-safe; this helper matches Android ordering for registry/tests.
+  id handle = [self.map get:key];
+  if (handle == nil) {
+    return NO;
+  }
+  [self rnfb_cancelHandle:handle];
+  [self.map takeIf:key
+              when:^BOOL(id value) {
+                return value == handle;
+              }];
+  return YES;
+}
+
+- (void)cancelAll {
+  NSArray *handlers = [self.map takeAll];
+  for (id handler in handlers) {
+    [self rnfb_cancelHandle:handler];
+  }
+}
+
+@end