react-native-buffered-blob 1.0.0

package/ios/BufferedBlobStreamingBridge.mm

@@ -0,0 +1,442 @@
+#import "BufferedBlobStreamingBridge.h"
+#import "BufferedBlobStreamingHostObject.h"
+#import "HandleRegistry.h"
+#import "HandleTypes.h"
+#import <Foundation/Foundation.h>
+#import <React/RCTBridge+Private.h>
+
+@interface DownloadSessionDelegate : NSObject <NSURLSessionDataDelegate>
+@property (nonatomic, copy) NSString *destPath;
+@property (nonatomic, strong) NSOutputStream *outputStream;
+@property (nonatomic, assign) int64_t totalBytes;
+@property (nonatomic, assign) int64_t downloadedBytes;
+@property (nonatomic, assign) BOOL isFinished;
+@property (nonatomic, weak) DownloaderHandleIOS *handle;
+@property (nonatomic, copy) void (^onProgress)(double, double, double);
+@property (nonatomic, copy) void (^onSuccess)(void);
+@property (nonatomic, copy) void (^onError)(NSString *);
+@property (nonatomic, strong) NSLock *stateLock;
+@end
+
+@implementation DownloadSessionDelegate
+
+- (void)finishWithError:(NSString *)msg session:(NSURLSession *)session {
+  [self.stateLock lock];
+  if (self.isFinished) {
+    [self.stateLock unlock];
+    return;
+  }
+  self.isFinished = YES;
+  void (^errorBlock)(NSString *) = self.onError;
+  self.onProgress = nil;
+  self.onSuccess = nil;
+  self.onError = nil;
+  [self.stateLock unlock];
+
+  if (errorBlock) errorBlock(msg);
+  [session invalidateAndCancel];
+}
+
+- (void)finishWithSuccess:(NSURLSession *)session {
+  [self.stateLock lock];
+  if (self.isFinished) {
+    [self.stateLock unlock];
+    return;
+  }
+  self.isFinished = YES;
+  void (^successBlock)(void) = self.onSuccess;
+  self.onProgress = nil;
+  self.onSuccess = nil;
+  self.onError = nil;
+  [self.stateLock unlock];
+
+  if (successBlock) successBlock();
+  [session finishTasksAndInvalidate];
+}
+
+- (void)URLSession:(NSURLSession *)session
+          dataTask:(NSURLSessionDataTask *)dataTask
+didReceiveResponse:(NSURLResponse *)response
+ completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler {
+  [self.stateLock lock];
+  if (self.isFinished) {
+    [self.stateLock unlock];
+    return;
+  }
+  [self.stateLock unlock];
+
+  DownloaderHandleIOS *strongHandle = self.handle;
+  if (!strongHandle || strongHandle.isCancelled) {
+    completionHandler(NSURLSessionResponseCancel);
+    [self finishWithError:@"[DOWNLOAD_CANCELLED] Download was cancelled" session:session];
+    return;
+  }
+
+  NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;
+  if (httpResponse.statusCode < 200 || httpResponse.statusCode >= 300) {
+    completionHandler(NSURLSessionResponseCancel);
+    NSString *errorMsg = [NSString stringWithFormat:@"[DOWNLOAD_FAILED] HTTP %ld",
+                          (long)httpResponse.statusCode];
+    [self finishWithError:errorMsg session:session];
+    return;
+  }
+
+  self.totalBytes = response.expectedContentLength;
+  self.downloadedBytes = 0;
+
+  self.outputStream = [NSOutputStream outputStreamToFileAtPath:self.destPath append:NO];
+  [self.outputStream open];
+
+  if (self.outputStream.streamStatus == NSStreamStatusError) {
+    completionHandler(NSURLSessionResponseCancel);
+    [self finishWithError:@"[IO_ERROR] Failed to open output stream" session:session];
+    return;
+  }
+
+  completionHandler(NSURLSessionResponseAllow);
+}
+
+- (void)URLSession:(NSURLSession *)session
+          dataTask:(NSURLSessionDataTask *)dataTask
+    didReceiveData:(NSData *)data {
+  [self.stateLock lock];
+  if (self.isFinished) {
+    [self.stateLock unlock];
+    return;
+  }
+  [self.stateLock unlock];
+
+  DownloaderHandleIOS *strongHandle = self.handle;
+  if (!strongHandle || strongHandle.isCancelled) {
+    [self finishWithError:@"[DOWNLOAD_CANCELLED] Download was cancelled" session:session];
+    return;
+  }
+
+  if (!self.outputStream || self.outputStream.streamStatus != NSStreamStatusOpen) {
+    [self finishWithError:@"[IO_ERROR] Output stream not open" session:session];
+    return;
+  }
+
+  const uint8_t *bytes = (const uint8_t *)data.bytes;
+  NSUInteger length = data.length;
+  NSUInteger totalWritten = 0;
+
+  while (totalWritten < length) {
+    NSInteger written = [self.outputStream write:(bytes + totalWritten)
+                                       maxLength:(length - totalWritten)];
+    if (written < 0) {
+      [self finishWithError:@"[IO_ERROR] Failed to write to file" session:session];
+      return;
+    }
+    totalWritten += written;
+  }
+
+  self.downloadedBytes += length;
+
+  if (self.onProgress && self.totalBytes > 0) {
+    double progress = (double)self.downloadedBytes / (double)self.totalBytes;
+    self.onProgress((double)self.downloadedBytes, (double)self.totalBytes, progress);
+  }
+}
+
+- (void)URLSession:(NSURLSession *)session
+              task:(NSURLSessionTask *)task
+didCompleteWithError:(NSError *)error {
+  if (self.outputStream) {
+    [self.outputStream close];
+    self.outputStream = nil;
+  }
+
+  [self.stateLock lock];
+  if (self.isFinished) {
+    [self.stateLock unlock];
+    return;
+  }
+  [self.stateLock unlock];
+
+  DownloaderHandleIOS *strongHandle = self.handle;
+  if (!strongHandle || strongHandle.isCancelled) {
+    [self finishWithError:@"[DOWNLOAD_CANCELLED] Download was cancelled" session:session];
+    return;
+  }
+
+  if (error) {
+    NSString *errorMsg = [NSString stringWithFormat:@"[DOWNLOAD_FAILED] %@",
+                          error.localizedDescription];
+    [self finishWithError:errorMsg session:session];
+    return;
+  }
+
+  [self finishWithSuccess:session];
+}
+
+@end
+
+namespace {
+
+using namespace bufferedblob;
+
+/**
+ * iOS implementation of PlatformBridge.
+ * Calls into HandleRegistry and handle types via ObjC interop.
+ */
+class IOSPlatformBridge : public PlatformBridge {
+public:
+  IOSPlatformBridge() {}
+
+  void readNextChunk(
+      int handleId,
+      std::function<void(std::vector<uint8_t>)> onSuccess,
+      std::function<void()> onEOF,
+      std::function<void(std::string)> onError) override {
+
+    HandleRegistry *registry = [HandleRegistry shared];
+    ReaderHandleIOS *reader = (ReaderHandleIOS *)[registry objectForId:handleId];
+
+    if (!reader) {
+      onError("[READER_CLOSED] Reader handle not found");
+      return;
+    }
+
+    // Dispatch to the reader's serial queue to serialize all access to this handle
+    dispatch_async(reader.queue, ^{
+      @autoreleasepool {
+        if (reader.isClosed) {
+          onError("[READER_CLOSED] Reader is closed");
+          return;
+        }
+
+        if (reader.isEOF) {
+          onEOF();
+          return;
+        }
+
+        NSInteger bufferSize = reader.bufferSize;
+        uint8_t *buffer = (uint8_t *)malloc(bufferSize);
+        if (!buffer) {
+          onError("[IO_ERROR] Failed to allocate read buffer");
+          return;
+        }
+
+        NSInteger bytesRead = [reader.inputStream read:buffer maxLength:bufferSize];
+
+        if (bytesRead < 0) {
+          free(buffer);
+          onError("[IO_ERROR] Read error");
+          return;
+        }
+
+        if (bytesRead == 0) {
+          free(buffer);
+          reader.isEOF = YES;
+          onEOF();
+          return;
+        }
+
+        reader.bytesRead = reader.bytesRead + bytesRead;
+
+        std::vector<uint8_t> data(buffer, buffer + bytesRead);
+        free(buffer);
+        onSuccess(std::move(data));
+      }
+    });
+  }
+
+  void write(
+      int handleId,
+      std::vector<uint8_t> data,
+      std::function<void(int)> onSuccess,
+      std::function<void(std::string)> onError) override {
+
+    HandleRegistry *registry = [HandleRegistry shared];
+    WriterHandleIOS *writer = (WriterHandleIOS *)[registry objectForId:handleId];
+
+    if (!writer) {
+      onError("[WRITER_CLOSED] Writer handle not found");
+      return;
+    }
+
+    // Move data into block-captured variable (single copy from JSI, no second copy)
+    __block auto ownedData = std::move(data);
+
+    // Dispatch to the writer's serial queue to serialize all access to this handle
+    dispatch_async(writer.queue, ^{
+      @autoreleasepool {
+        if (writer.isClosed) {
+          onError("[WRITER_CLOSED] Writer is closed");
+          return;
+        }
+
+        NSInteger totalWritten = 0;
+        const uint8_t *ptr = ownedData.data();
+        NSInteger remaining = static_cast<NSInteger>(ownedData.size());
+
+        while (remaining > 0) {
+          NSInteger written = [writer.outputStream write:ptr maxLength:remaining];
+          if (written < 0) {
+            onError("[IO_ERROR] Write error");
+            return;
+          }
+          if (written == 0) {
+            onError("[IO_ERROR] Write returned 0 bytes");
+            return;
+          }
+          totalWritten += written;
+          ptr += written;
+          remaining -= written;
+        }
+
+        writer.bytesWritten = writer.bytesWritten + totalWritten;
+        onSuccess(static_cast<int>(totalWritten));
+      }
+    });
+  }
+
+  void flush(
+      int handleId,
+      std::function<void()> onSuccess,
+      std::function<void(std::string)> onError) override {
+
+    HandleRegistry *registry = [HandleRegistry shared];
+    WriterHandleIOS *writer = (WriterHandleIOS *)[registry objectForId:handleId];
+
+    if (!writer) {
+      onError("[WRITER_CLOSED] Writer handle not found");
+      return;
+    }
+
+    // Dispatch to the writer's serial queue to serialize all access to this handle
+    dispatch_async(writer.queue, ^{
+      @autoreleasepool {
+        if (writer.isClosed) {
+          onError("[WRITER_CLOSED] Writer is closed");
+          return;
+        }
+
+        // NSOutputStream doesn't have an explicit flush, data is written immediately
+        onSuccess();
+      }
+    });
+  }
+
+  void close(int handleId) override {
+    HandleRegistry *registry = [HandleRegistry shared];
+    [registry removeObjectForId:handleId];
+  }
+
+  void startDownload(
+      int handleId,
+      std::function<void(double, double, double)> onProgress,
+      std::function<void()> onSuccess,
+      std::function<void(std::string)> onError) override {
+
+    HandleRegistry *registry = [HandleRegistry shared];
+    DownloaderHandleIOS *handle = (DownloaderHandleIOS *)[registry objectForId:handleId];
+
+    if (!handle) {
+      onError("[DOWNLOAD_FAILED] Download handle not found");
+      return;
+    }
+
+    if (handle.isCancelled) {
+      onError("[DOWNLOAD_CANCELLED] Download was cancelled");
+      return;
+    }
+
+    NSURL *url = [NSURL URLWithString:handle.url];
+    if (!url) {
+      onError("[DOWNLOAD_FAILED] Invalid URL");
+      return;
+    }
+
+    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
+    for (NSString *key in handle.headers) {
+      [request setValue:handle.headers[key] forHTTPHeaderField:key];
+    }
+
+    NSString *destPath = handle.destPath;
+    NSString *parentDir = [destPath stringByDeletingLastPathComponent];
+    [[NSFileManager defaultManager] createDirectoryAtPath:parentDir
+                                withIntermediateDirectories:YES
+                                                attributes:nil
+                                                     error:nil];
+
+    DownloadSessionDelegate *delegate = [[DownloadSessionDelegate alloc] init];
+    delegate.stateLock = [NSLock new];
+    delegate.destPath = destPath;
+    delegate.handle = handle;
+    delegate.onProgress = ^(double downloaded, double total, double progress) {
+      onProgress(downloaded, total, progress);
+    };
+    delegate.onSuccess = ^{
+      onSuccess();
+    };
+    delegate.onError = ^(NSString *errorMsg) {
+      onError(std::string([errorMsg UTF8String]));
+    };
+
+    NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
+    config.timeoutIntervalForRequest = 30.0;
+    config.timeoutIntervalForResource = 600.0;
+    NSOperationQueue *delegateQueue = [[NSOperationQueue alloc] init];
+    delegateQueue.maxConcurrentOperationCount = 1;
+    NSURLSession *session = [NSURLSession sessionWithConfiguration:config
+                                                          delegate:delegate
+                                                     delegateQueue:delegateQueue];
+    NSURLSessionDataTask *task = [session dataTaskWithRequest:request];
+
+    // Store session and task on the handle so cancelDownload can properly invalidate
+    [handle storeSession:session task:task];
+
+    // Re-check: cancel may have been called between the first check and storeSession
+    if (handle.isCancelled) {
+      [task cancel];
+      [session invalidateAndCancel];
+      onError("[DOWNLOAD_CANCELLED] Download was cancelled");
+      return;
+    }
+
+    [task resume];
+  }
+
+  void cancelDownload(int handleId) override {
+    HandleRegistry *registry = [HandleRegistry shared];
+    DownloaderHandleIOS *handle = (DownloaderHandleIOS *)[registry objectForId:handleId];
+    if (handle) {
+      // cancel() now properly invalidates the NSURLSession and task
+      [handle cancel];
+    }
+  }
+
+  ReaderInfo getReaderInfo(int handleId) override {
+    ReaderInfo info{0, 0, false};
+    HandleRegistry *registry = [HandleRegistry shared];
+    ReaderHandleIOS *reader = (ReaderHandleIOS *)[registry objectForId:handleId];
+    if (reader) {
+      info.fileSize = static_cast<double>(reader.fileSize);
+      info.bytesRead = static_cast<double>(reader.bytesRead);
+      info.isEOF = reader.isEOF;
+    }
+    return info;
+  }
+
+  WriterInfo getWriterInfo(int handleId) override {
+    WriterInfo info{0};
+    HandleRegistry *registry = [HandleRegistry shared];
+    WriterHandleIOS *writer = (WriterHandleIOS *)[registry objectForId:handleId];
+    if (writer) {
+      info.bytesWritten = static_cast<double>(writer.bytesWritten);
+    }
+    return info;
+  }
+};
+
+} // anonymous namespace
+
+void installBufferedBlobStreaming(
+    facebook::jsi::Runtime& runtime,
+    std::shared_ptr<facebook::react::CallInvoker> callInvoker) {
+  auto bridge = std::make_shared<IOSPlatformBridge>();
+  bufferedblob::BufferedBlobStreamingHostObject::install(
+      runtime, std::move(callInvoker), std::move(bridge));
+}

package/ios/HandleRegistry.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@protocol HandleCloseable <NSObject>
+- (void)closeHandle;
+@end
+
+/**
+ * Thread-safe singleton registry that maps integer IDs to handle objects.
+ * Used to pass opaque handles between JS and native.
+ */
+@interface HandleRegistry : NSObject
+
++ (instancetype)shared;
+
+/** Register an object and return its unique ID. */
+- (NSInteger)registerObject:(id)obj;
+
+/** Look up an object by ID. Returns nil if not found. */
+- (id)objectForId:(NSInteger)handleId;
+
+/** Remove and close (if HandleCloseable) the object for the given ID. */
+- (void)removeObjectForId:(NSInteger)handleId;
+
+/** Remove and close all registered objects. */
+- (void)clear;
+
+@end

package/ios/HandleRegistry.m

@@ -0,0 +1,67 @@
+#import "HandleRegistry.h"
+
+@implementation HandleRegistry {
+  NSInteger _nextId;
+  NSMutableDictionary<NSNumber *, id> *_handles;
+  NSLock *_lock;
+}
+
++ (instancetype)shared {
+  static HandleRegistry *instance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[HandleRegistry alloc] initPrivate];
+  });
+  return instance;
+}
+
+- (instancetype)initPrivate {
+  self = [super init];
+  if (self) {
+    _nextId = 1;
+    _handles = [NSMutableDictionary new];
+    _lock = [NSLock new];
+  }
+  return self;
+}
+
+- (NSInteger)registerObject:(id)obj {
+  [_lock lock];
+  NSInteger handleId = _nextId++;
+  _handles[@(handleId)] = obj;
+  [_lock unlock];
+  return handleId;
+}
+
+- (id)objectForId:(NSInteger)handleId {
+  [_lock lock];
+  id obj = _handles[@(handleId)];
+  [_lock unlock];
+  return obj;
+}
+
+- (void)removeObjectForId:(NSInteger)handleId {
+  [_lock lock];
+  id obj = _handles[@(handleId)];
+  [_handles removeObjectForKey:@(handleId)];
+  [_lock unlock];
+
+  if ([obj conformsToProtocol:@protocol(HandleCloseable)]) {
+    [(id<HandleCloseable>)obj closeHandle];
+  }
+}
+
+- (void)clear {
+  [_lock lock];
+  NSDictionary<NSNumber *, id> *snapshot = [_handles copy];
+  [_handles removeAllObjects];
+  [_lock unlock];
+
+  for (id obj in snapshot.allValues) {
+    if ([obj conformsToProtocol:@protocol(HandleCloseable)]) {
+      [(id<HandleCloseable>)obj closeHandle];
+    }
+  }
+}
+
+@end

package/ios/HandleTypes.h

@@ -0,0 +1,83 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import "HandleRegistry.h"
+
+/**
+ * Reader handle: wraps an NSInputStream for buffered file reading.
+ * All I/O is dispatched to a dedicated serial queue for thread safety.
+ */
+@interface ReaderHandleIOS : NSObject <HandleCloseable>
+
+@property (nonatomic, strong, readonly) NSInputStream *inputStream;
+@property (nonatomic, assign, readonly) NSInteger bufferSize;
+@property (nonatomic, assign, readonly) int64_t fileSize;
+
+/** Serial queue for dispatching I/O operations from the C++ bridge. */
+@property (nonatomic, strong, readonly) dispatch_queue_t queue;
+
+/** Bytes read so far. Thread-safe via internal lock. */
+@property (atomic, assign) int64_t bytesRead;
+/** Whether the stream has reached end-of-file. Thread-safe via internal lock. */
+@property (atomic, assign) BOOL isEOF;
+/** Whether the handle has been closed. Thread-safe via internal lock. */
+@property (atomic, assign) BOOL isClosed;
+
+- (nullable instancetype)initWithPath:(NSString *)path
+                           bufferSize:(NSInteger)bufferSize
+                                error:(NSError **)error;
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+/**
+ * Writer handle: wraps an NSOutputStream for buffered file writing.
+ * All I/O is dispatched to a dedicated serial queue for thread safety.
+ */
+@interface WriterHandleIOS : NSObject <HandleCloseable>
+
+@property (nonatomic, strong, readonly) NSOutputStream *outputStream;
+
+/** Serial queue for dispatching I/O operations from the C++ bridge. */
+@property (nonatomic, strong, readonly) dispatch_queue_t queue;
+
+/** Bytes written so far. Thread-safe via atomic. */
+@property (atomic, assign) int64_t bytesWritten;
+/** Whether the handle has been closed. Thread-safe via atomic. */
+@property (atomic, assign) BOOL isClosed;
+
+- (nullable instancetype)initWithPath:(NSString *)path
+                               append:(BOOL)append
+                                error:(NSError **)error;
+- (instancetype)init NS_UNAVAILABLE;
+
+@end
+
+/**
+ * Downloader handle: manages a URLSession download to a file.
+ * Supports cancellation via the cancel method.
+ */
+@interface DownloaderHandleIOS : NSObject <HandleCloseable>
+
+@property (nonatomic, copy, readonly) NSString *url;
+@property (nonatomic, copy, readonly) NSString *destPath;
+@property (nonatomic, copy, readonly) NSDictionary<NSString *, NSString *> *headers;
+
+/** Serial queue exposed for future use if needed. */
+@property (nonatomic, strong, readonly) dispatch_queue_t queue;
+
+/** Whether the download has been cancelled. Thread-safe via atomic. */
+@property (atomic, assign) BOOL isCancelled;
+
+- (instancetype)initWithURL:(NSString *)url
+                   destPath:(NSString *)destPath
+                    headers:(NSDictionary<NSString *, NSString *> *)headers;
+- (instancetype)init NS_UNAVAILABLE;
+
+/** Store the session and task so cancel can properly invalidate them. */
+- (void)storeSession:(NSURLSession *)session task:(NSURLSessionTask *)task;
+
+/** Cancel the download, invalidating the session. */
+- (void)cancel;
+
+@end