@react-native-oh/react-native-harmony 0.77.18 → 0.77.33

package/Libraries/Network/RCTFileRequestHandler.mm

@@ -0,0 +1,100 @@
+/*
+ * 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/RCTFileRequestHandler.h>
+
+#import <MobileCoreServices/MobileCoreServices.h>
+
+#import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import "RCTNetworkPlugins.h"
+
+@interface RCTFileRequestHandler () <RCTTurboModule>
+@end
+
+@implementation RCTFileRequestHandler {
+  NSOperationQueue *_fileQueue;
+}
+
+RCT_EXPORT_MODULE()
+
+- (void)invalidate
+{
+  [_fileQueue cancelAllOperations];
+  _fileQueue = nil;
+}
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+  return [request.URL.scheme caseInsensitiveCompare:@"file"] == NSOrderedSame && !RCTIsBundleAssetURL(request.URL);
+}
+
+- (NSOperation *)sendRequest:(NSURLRequest *)request withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+  // Lazy setup
+  if (!_fileQueue) {
+    _fileQueue = [NSOperationQueue new];
+    _fileQueue.maxConcurrentOperationCount = 4;
+  }
+
+  __weak __block NSBlockOperation *weakOp;
+  __block NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
+    // Get content length
+    NSError *error = nil;
+    NSFileManager *fileManager = [NSFileManager new];
+    NSDictionary<NSString *, id> *fileAttributes = [fileManager attributesOfItemAtPath:request.URL.path error:&error];
+    if (!fileAttributes) {
+      [delegate URLRequest:weakOp didCompleteWithError:error];
+      return;
+    }
+
+    // Get mime type
+    NSString *fileExtension = [request.URL pathExtension];
+    NSString *UTI = (__bridge_transfer NSString *)UTTypeCreatePreferredIdentifierForTag(
+        kUTTagClassFilenameExtension, (__bridge CFStringRef)fileExtension, NULL);
+    NSString *contentType =
+        (__bridge_transfer NSString *)UTTypeCopyPreferredTagWithClass((__bridge CFStringRef)UTI, kUTTagClassMIMEType);
+
+    // Send response
+    NSURLResponse *response = [[NSURLResponse alloc] initWithURL:request.URL
+                                                        MIMEType:contentType
+                                           expectedContentLength:[fileAttributes[NSFileSize] ?: @-1 integerValue]
+                                                textEncodingName:nil];
+
+    [delegate URLRequest:weakOp didReceiveResponse:response];
+
+    // Load data
+    NSData *data = [NSData dataWithContentsOfURL:request.URL options:NSDataReadingMappedIfSafe error:&error];
+    if (data) {
+      [delegate URLRequest:weakOp didReceiveData:data];
+    }
+    [delegate URLRequest:weakOp didCompleteWithError:error];
+  }];
+
+  weakOp = op;
+  [_fileQueue addOperation:op];
+  return op;
+}
+
+- (void)cancelRequest:(NSOperation *)op
+{
+  [op cancel];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return nullptr;
+}
+
+@end
+
+Class RCTFileRequestHandlerCls(void)
+{
+  return RCTFileRequestHandler.class;
+}

package/Libraries/Network/RCTHTTPRequestHandler.h

@@ -0,0 +1,22 @@
+/*
+ * 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/RCTInvalidating.h>
+#import <React/RCTURLRequestHandler.h>
+
+typedef NSURLSessionConfiguration * (^NSURLSessionConfigurationProvider)(void);
+/**
+ *  The block provided via this function will provide the NSURLSessionConfiguration for all HTTP requests made by the
+ * app.
+ */
+RCT_EXTERN void RCTSetCustomNSURLSessionConfigurationProvider(NSURLSessionConfigurationProvider);
+/**
+ * This is the default RCTURLRequestHandler implementation for HTTP requests.
+ */
+@interface RCTHTTPRequestHandler : NSObject <RCTURLRequestHandler, RCTInvalidating>
+
+@end

package/Libraries/Network/RCTHTTPRequestHandler.mm

@@ -0,0 +1,195 @@
+/*
+ * 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/RCTHTTPRequestHandler.h>
+
+#import <mutex>
+
+#import <React/RCTNetworking.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import "RCTNetworkPlugins.h"
+
+@interface RCTHTTPRequestHandler () <NSURLSessionDataDelegate, RCTTurboModule>
+
+@end
+
+static NSURLSessionConfigurationProvider urlSessionConfigurationProvider;
+
+void RCTSetCustomNSURLSessionConfigurationProvider(NSURLSessionConfigurationProvider provider)
+{
+  urlSessionConfigurationProvider = provider;
+}
+
+@implementation RCTHTTPRequestHandler {
+  NSMapTable *_delegates;
+  NSURLSession *_session;
+  std::mutex _mutex;
+}
+
+@synthesize moduleRegistry = _moduleRegistry;
+
+RCT_EXPORT_MODULE()
+
+- (void)invalidate
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  [self->_session invalidateAndCancel];
+  self->_session = nil;
+}
+
+// Needs to lock before call this method.
+- (BOOL)isValid
+{
+  // if session == nil and delegates != nil, we've been invalidated
+  return _session || !_delegates;
+}
+
+#pragma mark - NSURLRequestHandler
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+  static NSSet<NSString *> *schemes = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    // technically, RCTHTTPRequestHandler can handle file:// as well,
+    // but it's less efficient than using RCTFileRequestHandler
+    schemes = [[NSSet alloc] initWithObjects:@"http", @"https", nil];
+  });
+  return [schemes containsObject:request.URL.scheme.lowercaseString];
+}
+
+- (NSURLSessionDataTask *)sendRequest:(NSURLRequest *)request withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+  std::lock_guard<std::mutex> lock(_mutex);
+  // Lazy setup
+  if (!_session && [self isValid]) {
+    // You can override default NSURLSession instance property allowsCellularAccess (default value YES)
+    //  by providing the following key to your RN project (edit ios/project/Info.plist file in Xcode):
+    // <key>ReactNetworkForceWifiOnly</key>    <true/>
+    // This will set allowsCellularAccess to NO and force Wifi only for all network calls on iOS
+    // If you do not want to override default behavior, do nothing or set key with value false
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    NSNumber *useWifiOnly = [infoDictionary objectForKey:@"ReactNetworkForceWifiOnly"];
+
+    NSOperationQueue *callbackQueue = [NSOperationQueue new];
+    callbackQueue.maxConcurrentOperationCount = 1;
+    RCTNetworking *networking = [_moduleRegistry moduleForName:"Networking"];
+    callbackQueue.underlyingQueue = [networking requestQueue];
+    NSURLSessionConfiguration *configuration;
+    if (urlSessionConfigurationProvider) {
+      configuration = urlSessionConfigurationProvider();
+    } else {
+      configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
+      // Set allowsCellularAccess to NO ONLY if key ReactNetworkForceWifiOnly exists AND its value is YES
+      if (useWifiOnly) {
+        configuration.allowsCellularAccess = ![useWifiOnly boolValue];
+      }
+      [configuration setHTTPShouldSetCookies:YES];
+      [configuration setHTTPCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
+      [configuration setHTTPCookieStorage:[NSHTTPCookieStorage sharedHTTPCookieStorage]];
+    }
+    assert(configuration != nil);
+    _session = [NSURLSession sessionWithConfiguration:configuration delegate:self delegateQueue:callbackQueue];
+
+    _delegates = [[NSMapTable alloc] initWithKeyOptions:NSPointerFunctionsStrongMemory
+                                           valueOptions:NSPointerFunctionsStrongMemory
+                                               capacity:0];
+  }
+  NSURLSessionDataTask *task = [_session dataTaskWithRequest:request];
+  [_delegates setObject:delegate forKey:task];
+  [task resume];
+  return task;
+}
+
+- (void)cancelRequest:(NSURLSessionDataTask *)task
+{
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    [_delegates removeObjectForKey:task];
+  }
+  [task cancel];
+}
+
+#pragma mark - NSURLSession delegate
+
+- (void)URLSession:(NSURLSession *)session
+                        task:(NSURLSessionTask *)task
+             didSendBodyData:(int64_t)bytesSent
+              totalBytesSent:(int64_t)totalBytesSent
+    totalBytesExpectedToSend:(int64_t)totalBytesExpectedToSend
+{
+  id<RCTURLRequestDelegate> delegate;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    delegate = [_delegates objectForKey:task];
+  }
+  [delegate URLRequest:task didSendDataWithProgress:totalBytesSent];
+}
+
+- (void)URLSession:(NSURLSession *)session
+                          task:(NSURLSessionTask *)task
+    willPerformHTTPRedirection:(NSHTTPURLResponse *)response
+                    newRequest:(NSURLRequest *)request
+             completionHandler:(void (^)(NSURLRequest *))completionHandler
+{
+  // Reset the cookies on redirect.
+  // This is necessary because we're not letting iOS handle cookies by itself
+  NSMutableURLRequest *nextRequest = [request mutableCopy];
+
+  NSArray<NSHTTPCookie *> *cookies = [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookiesForURL:request.URL];
+  nextRequest.allHTTPHeaderFields = [NSHTTPCookie requestHeaderFieldsWithCookies:cookies];
+  completionHandler(nextRequest);
+}
+
+- (void)URLSession:(NSURLSession *)session
+              dataTask:(NSURLSessionDataTask *)task
+    didReceiveResponse:(NSURLResponse *)response
+     completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
+{
+  id<RCTURLRequestDelegate> delegate;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    delegate = [_delegates objectForKey:task];
+  }
+  [delegate URLRequest:task didReceiveResponse:response];
+  completionHandler(NSURLSessionResponseAllow);
+}
+
+- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)task didReceiveData:(NSData *)data
+{
+  id<RCTURLRequestDelegate> delegate;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    delegate = [_delegates objectForKey:task];
+  }
+  [delegate URLRequest:task didReceiveData:data];
+}
+
+- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
+  id<RCTURLRequestDelegate> delegate;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    delegate = [_delegates objectForKey:task];
+    [_delegates removeObjectForKey:task];
+  }
+  [delegate URLRequest:task didCompleteWithError:error];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return nullptr;
+}
+
+@end
+
+Class RCTHTTPRequestHandlerCls(void)
+{
+  return RCTHTTPRequestHandler.class;
+}

package/Libraries/Network/RCTNetworkPlugins.h

@@ -0,0 +1,43 @@
+/**
+ * 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: FBRCTNetworkPlugins.h is autogenerated by the build system.
+#import <React/FBRCTNetworkPlugins.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 RCTNetworkClassProvider(const char *name);
+
+// Lookup functions
+Class RCTDataRequestHandlerCls(void) __attribute__((used));
+Class RCTFileRequestHandlerCls(void) __attribute__((used));
+Class RCTHTTPRequestHandlerCls(void) __attribute__((used));
+Class RCTNetworkingCls(void) __attribute__((used));
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma GCC diagnostic pop
+
+#endif // RN_DISABLE_OSS_PLUGIN_HEADER

package/Libraries/Network/RCTNetworkPlugins.mm

@@ -0,0 +1,36 @@
+/**
+ * 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 "RCTNetworkPlugins.h"
+
+#import <string>
+#import <unordered_map>
+
+Class RCTNetworkClassProvider(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)>{
+    {"DataRequestHandler", RCTDataRequestHandlerCls},
+    {"FileRequestHandler", RCTFileRequestHandlerCls},
+    {"HTTPRequestHandler", RCTHTTPRequestHandlerCls},
+    {"Networking", RCTNetworkingCls},
+  };
+
+  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/Network/RCTNetworkTask.h

@@ -0,0 +1,47 @@
+/*
+ * 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 <Foundation/Foundation.h>
+
+#import <React/RCTURLRequestDelegate.h>
+#import <React/RCTURLRequestHandler.h>
+
+typedef void (^RCTURLRequestCompletionBlock)(NSURLResponse *response, NSData *data, NSError *error);
+typedef void (^RCTURLRequestCancellationBlock)(void);
+typedef void (^RCTURLRequestIncrementalDataBlock)(NSData *data, int64_t progress, int64_t total);
+typedef void (^RCTURLRequestProgressBlock)(int64_t progress, int64_t total);
+typedef void (^RCTURLRequestResponseBlock)(NSURLResponse *response);
+
+typedef NS_ENUM(NSInteger, RCTNetworkTaskStatus) {
+  RCTNetworkTaskPending = 0,
+  RCTNetworkTaskInProgress,
+  RCTNetworkTaskFinished,
+};
+
+@interface RCTNetworkTask : NSObject <RCTURLRequestDelegate>
+
+@property (nonatomic, readonly) NSURLRequest *request;
+@property (nonatomic, readonly) NSNumber *requestID;
+@property (nonatomic, readonly, weak) id requestToken;
+@property (nonatomic, readonly) NSURLResponse *response;
+
+@property (nonatomic, copy) RCTURLRequestCompletionBlock completionBlock;
+@property (nonatomic, copy) RCTURLRequestProgressBlock downloadProgressBlock;
+@property (nonatomic, copy) RCTURLRequestIncrementalDataBlock incrementalDataBlock;
+@property (nonatomic, copy) RCTURLRequestResponseBlock responseBlock;
+@property (nonatomic, copy) RCTURLRequestProgressBlock uploadProgressBlock;
+
+@property (atomic, readonly) RCTNetworkTaskStatus status;
+
+- (instancetype)initWithRequest:(NSURLRequest *)request
+                        handler:(id<RCTURLRequestHandler>)handler
+                  callbackQueue:(dispatch_queue_t)callbackQueue NS_DESIGNATED_INITIALIZER;
+
+- (void)start;
+- (void)cancel;
+
+@end

package/Libraries/Network/RCTNetworkTask.mm

@@ -0,0 +1,228 @@
+/*
+ * 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 <atomic>
+#import <mutex>
+
+#import <React/RCTLog.h>
+#import <React/RCTNetworkTask.h>
+#import <React/RCTUtils.h>
+
+@implementation RCTNetworkTask {
+  NSMutableData *_data;
+  id<RCTURLRequestHandler> _handler;
+  dispatch_queue_t _callbackQueue;
+  std::mutex _mutex;
+  std::atomic<RCTNetworkTaskStatus> _atomicStatus;
+  RCTNetworkTask *_selfReference;
+}
+
+static auto currentRequestId = std::atomic<NSUInteger>(0);
+
+- (instancetype)initWithRequest:(NSURLRequest *)request
+                        handler:(id<RCTURLRequestHandler>)handler
+                  callbackQueue:(dispatch_queue_t)callbackQueue
+{
+  RCTAssertParam(request);
+  RCTAssertParam(handler);
+  RCTAssertParam(callbackQueue);
+
+  if ((self = [super init])) {
+    _requestID = @(currentRequestId++);
+    _request = request;
+    _handler = handler;
+    _callbackQueue = callbackQueue;
+    _atomicStatus = RCTNetworkTaskPending;
+
+    dispatch_queue_set_specific(callbackQueue, (__bridge void *)self, (__bridge void *)self, NULL);
+  }
+  return self;
+}
+
+RCT_NOT_IMPLEMENTED(-(instancetype)init)
+
+- (RCTNetworkTaskStatus)status
+{
+  return _atomicStatus;
+}
+
+- (void)invalidate
+{
+  _selfReference = nil;
+  _completionBlock = nil;
+  _downloadProgressBlock = nil;
+  _incrementalDataBlock = nil;
+  _responseBlock = nil;
+  _uploadProgressBlock = nil;
+  _requestToken = nil;
+}
+
+- (void)dispatchCallback:(dispatch_block_t)callback
+{
+  if (dispatch_get_specific((__bridge void *)self) == (__bridge void *)self) {
+    callback();
+  } else {
+    dispatch_async(_callbackQueue, callback);
+  }
+}
+
+- (void)start
+{
+  if (_atomicStatus != RCTNetworkTaskPending) {
+    RCTLogError(@"RCTNetworkTask was already started or completed");
+    return;
+  }
+
+  if (_requestToken == nil) {
+    id token = [_handler sendRequest:_request withDelegate:self];
+    if ([self validateRequestToken:token]) {
+      _selfReference = self;
+      _atomicStatus = RCTNetworkTaskInProgress;
+    }
+  }
+}
+
+- (void)cancel
+{
+  if (_atomicStatus.exchange(RCTNetworkTaskFinished) == RCTNetworkTaskFinished) {
+    return;
+  }
+
+  id token = _requestToken;
+  if (token && [_handler respondsToSelector:@selector(cancelRequest:)]) {
+    [_handler cancelRequest:token];
+  }
+  [self invalidate];
+}
+
+- (BOOL)validateRequestToken:(id)requestToken
+{
+  BOOL valid = YES;
+  if (_requestToken == nil) {
+    _requestToken = requestToken;
+  } else if (![requestToken isEqual:_requestToken]) {
+    if (RCT_DEBUG) {
+      RCTLogError(@"Unrecognized request token: %@ expected: %@", requestToken, _requestToken);
+    }
+    valid = NO;
+  }
+
+  if (!valid) {
+    _atomicStatus = RCTNetworkTaskFinished;
+    if (_completionBlock) {
+      RCTURLRequestCompletionBlock completionBlock = _completionBlock;
+      [self dispatchCallback:^{
+        completionBlock(self->_response, nil, RCTErrorWithMessage(@"Invalid request token."));
+      }];
+    }
+    [self invalidate];
+  }
+  return valid;
+}
+
+- (void)URLRequest:(id)requestToken didSendDataWithProgress:(int64_t)bytesSent
+{
+  if (![self validateRequestToken:requestToken]) {
+    return;
+  }
+
+  if (_uploadProgressBlock) {
+    RCTURLRequestProgressBlock uploadProgressBlock = _uploadProgressBlock;
+    int64_t length = _request.HTTPBody.length;
+    [self dispatchCallback:^{
+      uploadProgressBlock(bytesSent, length);
+    }];
+  }
+}
+
+- (void)URLRequest:(id)requestToken didReceiveResponse:(NSURLResponse *)response
+{
+  if (![self validateRequestToken:requestToken]) {
+    return;
+  }
+
+  _response = response;
+  if (_responseBlock) {
+    RCTURLRequestResponseBlock responseBlock = _responseBlock;
+    [self dispatchCallback:^{
+      responseBlock(response);
+    }];
+  }
+}
+
+- (void)URLRequest:(id)requestToken didReceiveData:(NSData *)data
+{
+  if (![self validateRequestToken:requestToken]) {
+    return;
+  }
+
+  int64_t length = 0;
+
+  {
+    // NSData is not thread-safe and this method could be called from different threads as
+    // RCTURLRequestHandlers does not provide any guarantee of which thread we are called on.
+    std::lock_guard<std::mutex> lock(_mutex);
+    if (!_data) {
+      _data = [NSMutableData new];
+    }
+    @try {
+      [_data appendData:data];
+    } @catch (NSException *exception) {
+      _atomicStatus = RCTNetworkTaskFinished;
+      if (_completionBlock) {
+        RCTURLRequestCompletionBlock completionBlock = _completionBlock;
+        [self dispatchCallback:^{
+          completionBlock(
+              self->_response, nil, RCTErrorWithMessage(exception.reason ?: @"Request's received data too long."));
+        }];
+      }
+      [self invalidate];
+      return;
+    }
+
+    length = _data.length;
+  }
+
+  int64_t total = _response.expectedContentLength;
+
+  if (_incrementalDataBlock) {
+    RCTURLRequestIncrementalDataBlock incrementalDataBlock = _incrementalDataBlock;
+    [self dispatchCallback:^{
+      incrementalDataBlock(data, length, total);
+    }];
+  }
+  if (_downloadProgressBlock) {
+    RCTURLRequestProgressBlock downloadProgressBlock = _downloadProgressBlock;
+    [self dispatchCallback:^{
+      downloadProgressBlock(length, total);
+    }];
+  }
+}
+
+- (void)URLRequest:(id)requestToken didCompleteWithError:(NSError *)error
+{
+  if (![self validateRequestToken:requestToken]) {
+    return;
+  }
+
+  _atomicStatus = RCTNetworkTaskFinished;
+  if (_completionBlock) {
+    RCTURLRequestCompletionBlock completionBlock = _completionBlock;
+    NSData *dataCopy = nil;
+    {
+      std::lock_guard<std::mutex> lock(self->_mutex);
+      dataCopy = _data;
+      _data = nil;
+    }
+    [self dispatchCallback:^{
+      completionBlock(self->_response, dataCopy, error);
+    }];
+  }
+  [self invalidate];
+}
+
+@end