@onekeyfe/react-native-network-throttle 3.0.69 → 3.0.73

package/README.md

@@ -2,4 +2,8 @@
 
 React Native native network throttle for OneKey iOS and Android development settings.
 
+Current scope is an RN HTTP response latency gate. It does not emulate download
+throughput, upload throughput, offline mode, WebView traffic, or third-party
+native networking stacks.
+
 This package only owns native request throttling. Product settings, persistence, and UI controls should remain in the host app.

package/android/src/main/java/com/onekeyfe/reactnativenetworkthrottle/NetworkThrottle.kt

@@ -38,9 +38,16 @@ internal object NetworkThrottle {
     }
 
     fun setConfig(config: ReadableMap): WritableMap {
-        val nextEnabled = config.hasKey("enabled") && config.getBoolean("enabled")
+        val hasEnabled = config.hasKey("enabled") && !config.isNull("enabled")
+        val hasLatencyMs = config.hasKey("latencyMs") && !config.isNull("latencyMs")
+        val nextEnabled =
+            if (hasEnabled) config.getBoolean("enabled") else enabled.get()
         var nextLatencyMs =
-            if (config.hasKey("latencyMs")) config.getDouble("latencyMs") else DEFAULT_LATENCY_MS
+            if (hasLatencyMs) {
+                config.getDouble("latencyMs")
+            } else {
+                latencyNanos.get() / 1_000_000.0
+            }
         if (nextLatencyMs <= 0) {
             nextLatencyMs = DEFAULT_LATENCY_MS
         }
@@ -66,19 +73,27 @@ internal object NetworkThrottle {
 
     private class LatencyInterceptor : Interceptor {
         override fun intercept(chain: Interceptor.Chain): Response {
+            val requestStartNanos = System.nanoTime()
             val delayNanos = getLatencyNanos()
+            val response = chain.proceed(chain.request())
             if (delayNanos > 0) {
                 try {
-                    val delayMs = TimeUnit.NANOSECONDS.toMillis(delayNanos)
+                    val elapsedNanos = System.nanoTime() - requestStartNanos
+                    val remainingDelayNanos = delayNanos - elapsedNanos
+                    if (remainingDelayNanos <= 0) {
+                        return response
+                    }
+                    val delayMs = TimeUnit.NANOSECONDS.toMillis(remainingDelayNanos)
                     val remainingNanos =
-                        (delayNanos - TimeUnit.MILLISECONDS.toNanos(delayMs)).toInt()
+                        (remainingDelayNanos - TimeUnit.MILLISECONDS.toNanos(delayMs)).toInt()
                     Thread.sleep(delayMs, remainingNanos)
                 } catch (error: InterruptedException) {
+                    response.close()
                     Thread.currentThread().interrupt()
                     throw IOException("Interrupted while applying OneKey network throttle", error)
                 }
             }
-            return chain.proceed(chain.request())
+            return response
         }
     }
 }

package/ios/OneKeyNetworkThrottle.m

@@ -66,6 +66,16 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
 @property (nonatomic, strong) NSURLSessionDataTask *task;
 @property (nonatomic, strong) NSURLSession *session;
 @property (atomic, assign) BOOL stopped;
+@property (nonatomic, assign) CFAbsoluteTime requestStartTime;
+@property (nonatomic, assign) NSTimeInterval latencySeconds;
+@property (atomic, assign) BOOL responseDelivered;
+@property (nonatomic, strong) NSMutableArray<NSData *> *pendingData;
+@property (nonatomic, copy) void (^pendingResponseCompletionHandler)(NSURLSessionResponseDisposition disposition);
+- (NSTimeInterval)remainingLatencyDelay;
+- (void)deliverResponse:(NSURLResponse *)response;
+- (void)flushPendingData;
+- (void)cancelPendingResponseCompletionHandler;
+- (void)invalidateSessionAndClearTaskWithCancel:(BOOL)cancel;
 @end
 
 @implementation OneKeyNetworkThrottleURLProtocol
@@ -92,28 +102,100 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
   NSMutableURLRequest *request = [self.request mutableCopy];
   [NSURLProtocol setProperty:@YES forKey:OneKeyNetworkThrottleHandledKey inRequest:request];
 
-  NSTimeInterval delay = [OneKeyNetworkThrottleState latencyMs] / 1000.0;
-  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+  self.requestStartTime = CFAbsoluteTimeGetCurrent();
+  self.latencySeconds = [OneKeyNetworkThrottleState latencyMs] / 1000.0;
+  self.pendingData = [NSMutableArray array];
+
+  NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
+  NSNumber *useWifiOnly = [[NSBundle mainBundle].infoDictionary objectForKey:@"ReactNetworkForceWifiOnly"];
+  if (useWifiOnly) {
+    configuration.allowsCellularAccess = ![useWifiOnly boolValue];
+  }
+  configuration.HTTPShouldSetCookies = YES;
+  configuration.HTTPCookieAcceptPolicy = NSHTTPCookieAcceptPolicyAlways;
+  configuration.HTTPCookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+  self.session = [NSURLSession sessionWithConfiguration:configuration delegate:self delegateQueue:nil];
+  self.task = [self.session dataTaskWithRequest:request];
+  [self.task resume];
+}
+
+- (void)stopLoading
+{
+  self.stopped = YES;
+  [self cancelPendingResponseCompletionHandler];
+  [self invalidateSessionAndClearTaskWithCancel:YES];
+}
+
+- (NSTimeInterval)remainingLatencyDelay
+{
+  NSTimeInterval elapsed = CFAbsoluteTimeGetCurrent() - self.requestStartTime;
+  NSTimeInterval remainingDelay = self.latencySeconds - elapsed;
+  return remainingDelay > 0 ? remainingDelay : 0;
+}
+
+- (void)deliverResponse:(NSURLResponse *)response
+{
+  void (^completionHandler)(NSURLSessionResponseDisposition disposition) = nil;
+  @synchronized (self) {
+    completionHandler = self.pendingResponseCompletionHandler;
+    self.pendingResponseCompletionHandler = nil;
+  }
+  if (!completionHandler) {
+    return;
+  }
+  if (self.stopped) {
+    completionHandler(NSURLSessionResponseCancel);
+    return;
+  }
+  self.responseDelivered = YES;
+  [self.client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
+  [self flushPendingData];
+  completionHandler(NSURLSessionResponseAllow);
+}
+
+- (void)flushPendingData
+{
+  NSArray<NSData *> *pendingData = nil;
+  @synchronized (self) {
+    pendingData = [self.pendingData copy];
+    [self.pendingData removeAllObjects];
+  }
+  for (NSData *data in pendingData) {
     if (self.stopped) {
       return;
     }
-    NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
-    configuration.HTTPShouldSetCookies = YES;
-    configuration.HTTPCookieAcceptPolicy = NSHTTPCookieAcceptPolicyAlways;
-    configuration.HTTPCookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
-    self.session = [NSURLSession sessionWithConfiguration:configuration delegate:self delegateQueue:nil];
-    self.task = [self.session dataTaskWithRequest:request];
-    [self.task resume];
-  });
+    [self.client URLProtocol:self didLoadData:data];
+  }
 }
 
-- (void)stopLoading
+- (void)cancelPendingResponseCompletionHandler
 {
-  self.stopped = YES;
-  [self.task cancel];
-  [self.session invalidateAndCancel];
-  self.task = nil;
-  self.session = nil;
+  void (^completionHandler)(NSURLSessionResponseDisposition disposition) = nil;
+  @synchronized (self) {
+    completionHandler = self.pendingResponseCompletionHandler;
+    self.pendingResponseCompletionHandler = nil;
+  }
+  if (completionHandler) {
+    completionHandler(NSURLSessionResponseCancel);
+  }
+}
+
+- (void)invalidateSessionAndClearTaskWithCancel:(BOOL)cancel
+{
+  NSURLSessionDataTask *task = nil;
+  NSURLSession *session = nil;
+  @synchronized (self) {
+    task = self.task;
+    session = self.session;
+    self.task = nil;
+    self.session = nil;
+  }
+  if (cancel) {
+    [task cancel];
+    [session invalidateAndCancel];
+  } else {
+    [session finishTasksAndInvalidate];
+  }
 }
 
 - (void)URLSession:(NSURLSession *)session
@@ -131,22 +213,46 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
 didReceiveResponse:(NSURLResponse *)response
  completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
 {
-  [self.client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
-  completionHandler(NSURLSessionResponseAllow);
+  @synchronized (self) {
+    self.pendingResponseCompletionHandler = completionHandler;
+  }
+  NSTimeInterval delay = [self remainingLatencyDelay];
+  if (delay <= 0) {
+    [self deliverResponse:response];
+    return;
+  }
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+    [self deliverResponse:response];
+  });
 }
 
 - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
 {
-  [self.client URLProtocol:self didLoadData:data];
+  if (self.stopped) {
+    return;
+  }
+  if (self.responseDelivered) {
+    [self.client URLProtocol:self didLoadData:data];
+  } else {
+    @synchronized (self) {
+      [self.pendingData addObject:data];
+    }
+  }
 }
 
 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
 {
-  if (error) {
-    [self.client URLProtocol:self didFailWithError:error];
-  } else {
-    [self.client URLProtocolDidFinishLoading:self];
+  if (!self.responseDelivered) {
+    [self cancelPendingResponseCompletionHandler];
   }
+  if (!self.stopped) {
+    if (error) {
+      [self.client URLProtocol:self didFailWithError:error];
+    } else {
+      [self.client URLProtocolDidFinishLoading:self];
+    }
+  }
+  [self invalidateSessionAndClearTaskWithCancel:NO];
 }
 
 @end
@@ -197,9 +303,12 @@ RCT_REMAP_METHOD(getConfig, getConfigWithResolver:(RCTPromiseResolveBlock)resolv
 
 RCT_REMAP_METHOD(setConfig, setConfig:(NSDictionary *)config resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
-  BOOL enabled = [config[@"enabled"] boolValue];
-  NSNumber *latencyValue = config[@"latencyMs"];
-  NSTimeInterval latencyMs = latencyValue != nil ? [latencyValue doubleValue] : OneKeyNetworkThrottleDefaultLatencyMs;
+  id enabledValue = config[@"enabled"];
+  BOOL enabled =
+    enabledValue != nil && enabledValue != [NSNull null] ? [enabledValue boolValue] : [OneKeyNetworkThrottleState isEnabled];
+  id latencyValue = config[@"latencyMs"];
+  NSTimeInterval latencyMs =
+    latencyValue != nil && latencyValue != [NSNull null] ? [latencyValue doubleValue] : [OneKeyNetworkThrottleState latencyMs];
   resolve([OneKeyNetworkThrottleState setEnabled:enabled latencyMs:latencyMs]);
 }
 

package/lib/module/index.js

@@ -7,7 +7,17 @@ const LINKING_ERROR = `The package '@onekeyfe/react-native-network-throttle' doe
   default: ''
 }) + '- rebuild the app after installing the package';
 const nativeModule = NativeModules.OneKeyNetworkThrottle;
-export const NetworkThrottle = nativeModule ? nativeModule : new Proxy({}, {
+export const NetworkThrottle = nativeModule ? {
+  getConfig: () => nativeModule.getConfig(),
+  setConfig: async config => {
+    const currentConfig = await nativeModule.getConfig();
+    return nativeModule.setConfig({
+      enabled: config.enabled ?? currentConfig.enabled,
+      profile: config.profile ?? currentConfig.profile,
+      latencyMs: config.latencyMs ?? currentConfig.latencyMs
+    });
+  }
+} : new Proxy({}, {
   get() {
     throw new Error(LINKING_ERROR);
   }

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

@@ -5,10 +5,10 @@ export type NetworkThrottleConfig = {
     latencyMs: number;
 };
 export declare const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
-type NativeNetworkThrottleModule = {
+export type NetworkThrottleModule = {
     getConfig: () => Promise<NetworkThrottleConfig>;
     setConfig: (config: Partial<NetworkThrottleConfig>) => Promise<NetworkThrottleConfig>;
 };
-export declare const NetworkThrottle: NativeNetworkThrottleModule;
+export declare const NetworkThrottle: NetworkThrottleModule;
 export default NetworkThrottle;
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-network-throttle",
-  "version": "3.0.69",
+  "version": "3.0.73",
   "description": "react-native-network-throttle",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/index.tsx

@@ -11,6 +11,11 @@ export type NetworkThrottleConfig = {
 export const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
 
 type NativeNetworkThrottleModule = {
+  getConfig: () => Promise<NetworkThrottleConfig>;
+  setConfig: (config: NetworkThrottleConfig) => Promise<NetworkThrottleConfig>;
+};
+
+export type NetworkThrottleModule = {
   getConfig: () => Promise<NetworkThrottleConfig>;
   setConfig: (
     config: Partial<NetworkThrottleConfig>
@@ -26,8 +31,18 @@ const nativeModule = NativeModules.OneKeyNetworkThrottle as
   | NativeNetworkThrottleModule
   | undefined;
 
-export const NetworkThrottle: NativeNetworkThrottleModule = nativeModule
-  ? nativeModule
+export const NetworkThrottle: NetworkThrottleModule = nativeModule
+  ? {
+      getConfig: () => nativeModule.getConfig(),
+      setConfig: async (config) => {
+        const currentConfig = await nativeModule.getConfig();
+        return nativeModule.setConfig({
+          enabled: config.enabled ?? currentConfig.enabled,
+          profile: config.profile ?? currentConfig.profile,
+          latencyMs: config.latencyMs ?? currentConfig.latencyMs,
+        });
+      },
+    }
   : (new Proxy(
       {},
       {
@@ -35,6 +50,6 @@ export const NetworkThrottle: NativeNetworkThrottleModule = nativeModule
           throw new Error(LINKING_ERROR);
         },
       }
-    ) as NativeNetworkThrottleModule);
+    ) as NetworkThrottleModule);
 
 export default NetworkThrottle;