@react-native-oh/react-native-harmony 0.72.86 → 0.77.18-1

package/Libraries/Blob/RCTBlobManager.mm

@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBlobManager.h>
+
+#import <mutex>
+
+#import <FBReactNativeSpec/FBReactNativeSpec.h>
+#import <React/RCTConvert.h>
+#import <React/RCTMockDef.h>
+#import <React/RCTNetworking.h>
+#import <React/RCTUtils.h>
+#import <React/RCTWebSocketModule.h>
+
+#import "RCTBlobCollector.h"
+#import "RCTBlobPlugins.h"
+
+RCT_MOCK_DEF(RCTBlobManager, dispatch_async);
+#define dispatch_async RCT_MOCK_USE(RCTBlobManager, dispatch_async)
+
+static BOOL gBlobManagerProcessingQueueEnabled = NO;
+
+RCT_EXTERN void RCTEnableBlobManagerProcessingQueue(BOOL enabled)
+{
+  gBlobManagerProcessingQueueEnabled = enabled;
+}
+
+static NSString *const kBlobURIScheme = @"blob";
+
+@interface RCTBlobManager () <
+    RCTNetworkingRequestHandler,
+    RCTNetworkingResponseHandler,
+    RCTWebSocketContentHandler,
+    NativeBlobModuleSpec>
+
+@end
+
+@implementation RCTBlobManager {
+  // Blobs should be thread safe since they are used from the websocket and networking module,
+  // make sure to use proper locking when accessing this.
+  NSMutableDictionary<NSString *, NSData *> *_blobs;
+  std::mutex _blobsMutex;
+
+  NSOperationQueue *_queue;
+  dispatch_queue_t _processingQueue;
+}
+
+RCT_EXPORT_MODULE(BlobModule)
+
+@synthesize bridge = _bridge;
+@synthesize moduleRegistry = _moduleRegistry;
+@synthesize methodQueue = _methodQueue;
+
+- (void)initialize
+{
+  std::lock_guard<std::mutex> lock(_blobsMutex);
+  _blobs = [NSMutableDictionary new];
+
+  if (gBlobManagerProcessingQueueEnabled) {
+    _processingQueue = dispatch_queue_create("com.facebook.react.blobmanager.processing", DISPATCH_QUEUE_SERIAL);
+  }
+
+  facebook::react::RCTBlobCollector::install(self);
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (NSDictionary<NSString *, id> *)constantsToExport
+{
+  return [self getConstants];
+}
+
+- (NSDictionary<NSString *, id> *)getConstants
+{
+  return @{
+    @"BLOB_URI_SCHEME" : kBlobURIScheme,
+    @"BLOB_URI_HOST" : [NSNull null],
+  };
+}
+
+- (NSString *)store:(NSData *)data
+{
+  NSString *blobId = [NSUUID UUID].UUIDString;
+  [self store:data withId:blobId];
+  return blobId;
+}
+
+- (void)store:(NSData *)data withId:(NSString *)blobId
+{
+  std::lock_guard<std::mutex> lock(_blobsMutex);
+  _blobs[blobId] = data;
+}
+
+- (NSUInteger)lengthOfBlobWithId:(NSString *)blobId
+{
+  std::lock_guard<std::mutex> lock(_blobsMutex);
+  return _blobs[blobId].length;
+}
+
+- (NSData *)resolve:(NSDictionary<NSString *, id> *)blob
+{
+  NSString *blobId = [RCTConvert NSString:blob[@"blobId"]];
+  NSNumber *offset = [RCTConvert NSNumber:blob[@"offset"]];
+  NSNumber *size = [RCTConvert NSNumber:blob[@"size"]];
+  return [self resolve:blobId offset:offset ? [offset integerValue] : 0 size:size ? [size integerValue] : -1];
+}
+
+- (NSData *)resolve:(NSString *)blobId offset:(NSInteger)offset size:(NSInteger)size
+{
+  NSData *data;
+  {
+    std::lock_guard<std::mutex> lock(_blobsMutex);
+    data = _blobs[blobId];
+  }
+  if (!data) {
+    return nil;
+  }
+  if (offset != 0 || (size != -1 && size != data.length)) {
+    data = [data subdataWithRange:NSMakeRange(offset, size)];
+  }
+  return data;
+}
+
+- (NSData *)resolveURL:(NSURL *)url
+{
+  NSURLComponents *components = [[NSURLComponents alloc] initWithURL:url resolvingAgainstBaseURL:NO];
+
+  NSString *blobId = components.path;
+  NSInteger offset = 0;
+  NSInteger size = -1;
+
+  if (components.queryItems) {
+    for (NSURLQueryItem *queryItem in components.queryItems) {
+      if ([queryItem.name isEqualToString:@"offset"]) {
+        offset = [queryItem.value integerValue];
+      }
+      if ([queryItem.name isEqualToString:@"size"]) {
+        size = [queryItem.value integerValue];
+      }
+    }
+  }
+
+  if (blobId) {
+    return [self resolve:blobId offset:offset size:size];
+  }
+  return nil;
+}
+
+- (void)remove:(NSString *)blobId
+{
+  std::lock_guard<std::mutex> lock(_blobsMutex);
+  [_blobs removeObjectForKey:blobId];
+}
+
+RCT_EXPORT_METHOD(addNetworkingHandler)
+{
+  RCTNetworking *const networking = [_moduleRegistry moduleForName:"Networking"];
+
+  // TODO(T63516227): Why can methodQueue be nil here?
+  // We don't want to do anything when methodQueue is nil.
+  if (![networking requestQueue]) {
+    return;
+  }
+
+  dispatch_async([networking requestQueue], ^{
+    [networking addRequestHandler:self];
+    [networking addResponseHandler:self];
+  });
+}
+
+RCT_EXPORT_METHOD(addWebSocketHandler : (double)socketID)
+{
+  dispatch_async(((RCTWebSocketModule *)[_moduleRegistry moduleForName:"WebSocketModule"]).methodQueue, ^{
+    [[self->_moduleRegistry moduleForName:"WebSocketModule"] setContentHandler:self
+                                                                   forSocketID:[NSNumber numberWithDouble:socketID]];
+  });
+}
+
+RCT_EXPORT_METHOD(removeWebSocketHandler : (double)socketID)
+{
+  dispatch_async(((RCTWebSocketModule *)[_moduleRegistry moduleForName:"WebSocketModule"]).methodQueue, ^{
+    [[self->_moduleRegistry moduleForName:"WebSocketModule"] setContentHandler:nil
+                                                                   forSocketID:[NSNumber numberWithDouble:socketID]];
+  });
+}
+
+// @lint-ignore FBOBJCUNTYPEDCOLLECTION1
+RCT_EXPORT_METHOD(sendOverSocket : (NSDictionary *)blob socketID : (double)socketID)
+{
+  dispatch_async(((RCTWebSocketModule *)[_moduleRegistry moduleForName:"WebSocketModule"]).methodQueue, ^{
+    [[self->_moduleRegistry moduleForName:"WebSocketModule"] sendData:[self resolve:blob]
+                                                          forSocketID:[NSNumber numberWithDouble:socketID]];
+  });
+}
+
+RCT_EXPORT_METHOD(createFromParts : (NSArray<NSDictionary<NSString *, id> *> *)parts withId : (NSString *)blobId)
+{
+  NSMutableData *data = [NSMutableData new];
+  for (NSDictionary<NSString *, id> *part in parts) {
+    NSString *type = [RCTConvert NSString:part[@"type"]];
+
+    if ([type isEqualToString:@"blob"]) {
+      NSData *partData = [self resolve:part[@"data"]];
+      [data appendData:partData];
+    } else if ([type isEqualToString:@"string"]) {
+      NSData *partData = [[RCTConvert NSString:part[@"data"]] dataUsingEncoding:NSUTF8StringEncoding];
+      [data appendData:partData];
+    } else {
+      [NSException raise:@"Invalid type for blob" format:@"%@ is invalid", type];
+    }
+  }
+
+  dispatch_async([self executionQueue], ^{
+    [self store:data withId:blobId];
+  });
+}
+
+RCT_EXPORT_METHOD(release : (NSString *)blobId)
+{
+  dispatch_async([self executionQueue], ^{
+    [self remove:blobId];
+  });
+}
+
+- (dispatch_queue_t)executionQueue
+{
+  return gBlobManagerProcessingQueueEnabled ? _processingQueue : _methodQueue;
+}
+
+#pragma mark - RCTURLRequestHandler methods
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+  return [request.URL.scheme caseInsensitiveCompare:kBlobURIScheme] == NSOrderedSame;
+}
+
+- (id)sendRequest:(NSURLRequest *)request withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+  // Lazy setup
+  if (!_queue) {
+    _queue = [NSOperationQueue new];
+    _queue.maxConcurrentOperationCount = 2;
+  }
+
+  __weak __typeof(self) weakSelf = self;
+  __weak __block NSBlockOperation *weakOp;
+  __block NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf) {
+      return;
+    }
+    NSURLResponse *response = [[NSURLResponse alloc] initWithURL:request.URL
+                                                        MIMEType:nil
+                                           expectedContentLength:-1
+                                                textEncodingName:nil];
+
+    [delegate URLRequest:weakOp didReceiveResponse:response];
+
+    NSData *data = [strongSelf resolveURL:response.URL];
+    NSError *error;
+    if (data) {
+      [delegate URLRequest:weakOp didReceiveData:data];
+    } else {
+      error = [[NSError alloc] initWithDomain:NSURLErrorDomain code:NSURLErrorBadURL userInfo:nil];
+    }
+    [delegate URLRequest:weakOp didCompleteWithError:error];
+  }];
+
+  weakOp = op;
+  [_queue addOperation:op];
+  return op;
+}
+
+- (void)cancelRequest:(NSOperation *)op
+{
+  [op cancel];
+}
+
+#pragma mark - RCTNetworkingRequestHandler methods
+
+// @lint-ignore FBOBJCUNTYPEDCOLLECTION1
+- (BOOL)canHandleNetworkingRequest:(NSDictionary *)data
+{
+  return data[@"blob"] != nil;
+}
+
+// @lint-ignore FBOBJCUNTYPEDCOLLECTION1
+- (NSDictionary *)handleNetworkingRequest:(NSDictionary *)data
+{
+  // @lint-ignore FBOBJCUNTYPEDCOLLECTION1
+  NSDictionary *blob = [RCTConvert NSDictionary:data[@"blob"]];
+
+  NSString *contentType = @"application/octet-stream";
+  NSString *blobType = [RCTConvert NSString:RCTNilIfNull(blob[@"type"])];
+  if (blobType != nil && blobType.length > 0) {
+    contentType = blob[@"type"];
+  }
+
+  return @{@"body" : [self resolve:blob], @"contentType" : contentType};
+}
+
+- (BOOL)canHandleNetworkingResponse:(NSString *)responseType
+{
+  return [responseType isEqualToString:@"blob"];
+}
+
+- (id)handleNetworkingResponse:(NSURLResponse *)response data:(NSData *)data
+{
+  // An empty body will have nil for data, in this case we need to return
+  // an empty blob as per the XMLHttpRequest spec.
+  data = data ?: [NSData new];
+  return @{
+    @"blobId" : [self store:data],
+    @"offset" : @0,
+    @"size" : @(data.length),
+    @"name" : RCTNullIfNil([response suggestedFilename]),
+    @"type" : RCTNullIfNil([response MIMEType]),
+  };
+}
+
+#pragma mark - RCTWebSocketContentHandler methods
+
+- (id)processWebsocketMessage:(id)message
+                  forSocketID:(NSNumber *)socketID
+                     withType:(NSString *__autoreleasing _Nonnull *)type
+{
+  if (![message isKindOfClass:[NSData class]]) {
+    *type = @"text";
+    return message;
+  }
+
+  *type = @"blob";
+  return @{
+    @"blobId" : [self store:message],
+    @"offset" : @0,
+    @"size" : @(((NSData *)message).length),
+  };
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeBlobModuleSpecJSI>(params);
+}
+
+@end
+
+Class RCTBlobManagerCls(void)
+{
+  return RCTBlobManager.class;
+}

package/Libraries/Blob/RCTBlobPlugins.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// FB Internal: FBRCTBlobPlugins.h is autogenerated by the build system.
+#import <React/FBRCTBlobPlugins.h>
+
+#else
+
+// OSS-compatibility layer
+
+#import <Foundation/Foundation.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wreturn-type-c-linkage"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// RCTTurboModuleManagerDelegate should call this to resolve module classes.
+Class RCTBlobClassProvider(const char *name);
+
+// Lookup functions
+Class RCTBlobManagerCls(void) __attribute__((used));
+Class RCTFileReaderModuleCls(void) __attribute__((used));
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/Blob/RCTBlobPlugins.mm

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @generated by an internal plugin build system
+ */
+
+#ifndef RN_DISABLE_OSS_PLUGIN_HEADER
+
+// OSS-compatibility layer
+
+#import "RCTBlobPlugins.h"
+
+#import <string>
+#import <unordered_map>
+
+Class RCTBlobClassProvider(const char *name) {
+  // Intentionally leak to avoid crashing after static destructors are run.
+  static const auto sCoreModuleClassMap = new const std::unordered_map<std::string, Class (*)(void)>{
+    {"BlobModule", RCTBlobManagerCls},
+    {"FileReaderModule", RCTFileReaderModuleCls},
+  };
+
+  auto p = sCoreModuleClassMap->find(name);
+  if (p != sCoreModuleClassMap->end()) {
+    auto classFunc = p->second;
+    return classFunc();
+  }
+  return nil;
+}
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/Blob/RCTFileReaderModule.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCTFileReaderModule : NSObject <RCTBridgeModule>
+
+@end

package/Libraries/Blob/RCTFileReaderModule.mm

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTFileReaderModule.h>
+
+#import <FBReactNativeSpec/FBReactNativeSpec.h>
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+
+#import <React/RCTBlobManager.h>
+
+#import "RCTBlobPlugins.h"
+
+@interface RCTFileReaderModule () <NativeFileReaderModuleSpec>
+@end
+
+@implementation RCTFileReaderModule
+
+RCT_EXPORT_MODULE(FileReaderModule)
+
+@synthesize moduleRegistry = _moduleRegistry;
+
+RCT_EXPORT_METHOD(readAsText
+                  : (NSDictionary<NSString *, id> *)blob encoding
+                  : (NSString *)encoding resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject)
+{
+  RCTBlobManager *blobManager = [_moduleRegistry moduleForName:"BlobModule"];
+  dispatch_async([blobManager executionQueue], ^{
+    NSData *data = [blobManager resolve:blob];
+
+    if (data == nil) {
+      reject(
+          RCTErrorUnspecified,
+          [NSString stringWithFormat:@"Unable to resolve data for blob: %@", [RCTConvert NSString:blob[@"blobId"]]],
+          nil);
+    } else {
+      NSStringEncoding stringEncoding;
+
+      if (encoding == nil) {
+        stringEncoding = NSUTF8StringEncoding;
+      } else {
+        stringEncoding =
+            CFStringConvertEncodingToNSStringEncoding(CFStringConvertIANACharSetNameToEncoding((CFStringRef)encoding));
+      }
+
+      NSString *text = [[NSString alloc] initWithData:data encoding:stringEncoding];
+
+      resolve(text);
+    }
+  });
+}
+
+RCT_EXPORT_METHOD(readAsDataURL
+                  : (NSDictionary<NSString *, id> *)blob resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject)
+{
+  RCTBlobManager *blobManager = [_moduleRegistry moduleForName:"BlobModule"];
+  dispatch_async([blobManager executionQueue], ^{
+    NSData *data = [blobManager resolve:blob];
+
+    if (data == nil) {
+      reject(
+          RCTErrorUnspecified,
+          [NSString stringWithFormat:@"Unable to resolve data for blob: %@", [RCTConvert NSString:blob[@"blobId"]]],
+          nil);
+    } else {
+      NSString *type = [RCTConvert NSString:blob[@"type"]];
+      NSString *text = [NSString
+          stringWithFormat:@"data:%@;base64,%@",
+                           ![type isEqual:[NSNull null]] && [type length] > 0 ? type : @"application/octet-stream",
+                           [data base64EncodedStringWithOptions:0]];
+
+      resolve(text);
+    }
+  });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeFileReaderModuleSpecJSI>(params);
+}
+
+@end
+
+Class RCTFileReaderModuleCls(void)
+{
+  return RCTFileReaderModule.class;
+}

package/Libraries/Blob/React-RCTBlob.podspec

@@ -0,0 +1,68 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_config = get_folly_config()
+folly_compiler_flags = folly_config[:compiler_flags]
+folly_version = folly_config[:version]
+
+header_search_paths = [
+  "\"$(PODS_ROOT)/RCT-Folly\"",
+  "\"$(PODS_ROOT)/boost\"",
+  "\"$(PODS_ROOT)/DoubleConversion\"",
+  "\"$(PODS_ROOT)/fast_float/include\"",
+  "\"$(PODS_ROOT)/fmt/include\"",
+  "\"${PODS_ROOT}/Headers/Public/ReactCodegen/react/renderer/components\"",
+]
+
+Pod::Spec.new do |s|
+  s.name                   = "React-RCTBlob"
+  s.version                = version
+  s.summary                = "An API for displaying iOS action sheets and share sheets."
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.compiler_flags         = folly_compiler_flags + ' -Wno-nullability-completeness'
+  s.source                 = source
+  s.source_files           = "*.{h,m,mm}"
+  s.preserve_paths         = "package.json", "LICENSE", "LICENSE-docs"
+  s.header_dir             = "RCTBlob"
+  s.pod_target_xcconfig    = {
+                               "USE_HEADERMAP" => "YES",
+                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' ')
+                             }
+
+  s.dependency "DoubleConversion"
+  s.dependency "fast_float", "6.1.4"
+  s.dependency "fmt", "11.0.2"
+  s.dependency "RCT-Folly", folly_version
+  s.dependency "React-jsi"
+  s.dependency "React-Core/RCTBlobHeaders"
+  s.dependency "React-Core/RCTWebSocket"
+  s.dependency "React-RCTNetwork"
+
+  add_dependency(s, "React-RCTFBReactNativeSpec")
+  add_dependency(s, "React-NativeModulesApple")
+  add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
+  add_dependency(s, "ReactCommon", :subspec => "turbomodule/core", :additional_framework_paths => ["react/nativemodule/core"])
+
+  if ENV["USE_HERMES"] == nil || ENV["USE_HERMES"] == "1"
+    s.dependency "hermes-engine"
+  end
+end