@onekeyfe/react-native-network-throttle 3.0.78 → 3.0.80

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

@@ -7,20 +7,34 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.network.OkHttpClientProvider
 import java.io.IOException
+import java.io.InterruptedIOException
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 import okhttp3.Interceptor
+import okhttp3.MediaType
 import okhttp3.OkHttpClient
+import okhttp3.RequestBody
 import okhttp3.Response
+import okhttp3.ResponseBody
+import okio.Buffer
+import okio.BufferedSink
+import okio.BufferedSource
+import okio.ForwardingSink
+import okio.ForwardingSource
+import okio.Source
+import okio.buffer
 
 internal object NetworkThrottle {
     private const val TAG = "OneKeyNetworkThrottle"
     private const val PROFILE_SLOW_4G = "slow4g"
     private const val DEFAULT_LATENCY_MS = 562.5
+    private const val DEFAULT_THROUGHPUT_BPS = 102 * 1024
 
     private val enabled = AtomicBoolean(false)
     private val latencyNanos = AtomicLong((DEFAULT_LATENCY_MS * 1_000_000.0).toLong())
+    private val downloadBps = AtomicLong(DEFAULT_THROUGHPUT_BPS.toLong())
+    private val uploadBps = AtomicLong(DEFAULT_THROUGHPUT_BPS.toLong())
     private val installed = AtomicBoolean(false)
 
     fun install(context: Context) {
@@ -31,15 +45,17 @@ internal object NetworkThrottle {
         OkHttpClientProvider.setOkHttpClientFactory {
             val builder: OkHttpClient.Builder =
                 OkHttpClientProvider.createClientBuilder(applicationContext)
-            builder.addInterceptor(LatencyInterceptor())
+            builder.addInterceptor(ThrottleInterceptor())
             builder.build()
         }
-        Log.i(TAG, "[onekey-network-throttle] installed RN OkHttp latency interceptor")
+        Log.i(TAG, "[onekey-network-throttle] installed RN OkHttp throttle interceptor")
     }
 
     fun setConfig(config: ReadableMap): WritableMap {
         val hasEnabled = config.hasKey("enabled") && !config.isNull("enabled")
         val hasLatencyMs = config.hasKey("latencyMs") && !config.isNull("latencyMs")
+        val hasDownloadBps = config.hasKey("downloadBps") && !config.isNull("downloadBps")
+        val hasUploadBps = config.hasKey("uploadBps") && !config.isNull("uploadBps")
         val nextEnabled =
             if (hasEnabled) config.getBoolean("enabled") else enabled.get()
         var nextLatencyMs =
@@ -51,12 +67,32 @@ internal object NetworkThrottle {
         if (nextLatencyMs <= 0) {
             nextLatencyMs = DEFAULT_LATENCY_MS
         }
+        var nextDownloadBps =
+            if (hasDownloadBps) {
+                config.getDouble("downloadBps").toLong()
+            } else {
+                downloadBps.get()
+            }
+        if (nextDownloadBps <= 0) {
+            nextDownloadBps = DEFAULT_THROUGHPUT_BPS.toLong()
+        }
+        var nextUploadBps =
+            if (hasUploadBps) {
+                config.getDouble("uploadBps").toLong()
+            } else {
+                uploadBps.get()
+            }
+        if (nextUploadBps <= 0) {
+            nextUploadBps = DEFAULT_THROUGHPUT_BPS.toLong()
+        }
 
         enabled.set(nextEnabled)
         latencyNanos.set((nextLatencyMs * 1_000_000.0).toLong())
+        downloadBps.set(nextDownloadBps)
+        uploadBps.set(nextUploadBps)
         Log.i(
             TAG,
-            "[onekey-network-throttle] native config enabled=$nextEnabled profile=$PROFILE_SLOW_4G latencyMs=$nextLatencyMs"
+            "[onekey-network-throttle] native config enabled=$nextEnabled profile=$PROFILE_SLOW_4G latencyMs=$nextLatencyMs downloadBps=$nextDownloadBps uploadBps=$nextUploadBps"
         )
         return getConfig()
     }
@@ -66,34 +102,147 @@ internal object NetworkThrottle {
         map.putBoolean("enabled", enabled.get())
         map.putString("profile", PROFILE_SLOW_4G)
         map.putDouble("latencyMs", latencyNanos.get() / 1_000_000.0)
+        map.putDouble("downloadBps", downloadBps.get().toDouble())
+        map.putDouble("uploadBps", uploadBps.get().toDouble())
         return map
     }
 
     private fun getLatencyNanos(): Long = if (enabled.get()) latencyNanos.get() else 0L
+    private fun getDownloadBps(): Long = if (enabled.get()) downloadBps.get() else 0L
+    private fun getUploadBps(): Long = if (enabled.get()) uploadBps.get() else 0L
+
+    private fun sleepNanos(delayNanos: Long) {
+        if (delayNanos <= 0) {
+            return
+        }
+        try {
+            val delayMs = TimeUnit.NANOSECONDS.toMillis(delayNanos)
+            val remainingNanos =
+                (delayNanos - TimeUnit.MILLISECONDS.toNanos(delayMs)).toInt()
+            Thread.sleep(delayMs, remainingNanos)
+        } catch (error: InterruptedException) {
+            Thread.currentThread().interrupt()
+            val interruptedIOException =
+                InterruptedIOException("Interrupted while applying OneKey network throttle")
+            interruptedIOException.initCause(error)
+            throw interruptedIOException
+        }
+    }
+
+    private class BandwidthLimiter(private val bytesPerSecond: Long) {
+        private val startNanos = System.nanoTime()
+        private var transferredBytes = 0L
+
+        fun throttle(byteCount: Long) {
+            if (bytesPerSecond <= 0 || byteCount <= 0) {
+                return
+            }
+            transferredBytes += byteCount
+            val expectedElapsedNanos =
+                (transferredBytes.toDouble() * 1_000_000_000.0 / bytesPerSecond.toDouble())
+                    .toLong()
+            val elapsedNanos = System.nanoTime() - startNanos
+            sleepNanos(expectedElapsedNanos - elapsedNanos)
+        }
+    }
+
+    private class ThrottledRequestBody(
+        private val delegate: RequestBody,
+        private val bytesPerSecond: Long
+    ) : RequestBody() {
+        override fun contentType(): MediaType? = delegate.contentType()
+
+        override fun contentLength(): Long = delegate.contentLength()
+
+        override fun isDuplex(): Boolean = delegate.isDuplex()
 
-    private class LatencyInterceptor : Interceptor {
+        override fun isOneShot(): Boolean = delegate.isOneShot()
+
+        override fun writeTo(sink: BufferedSink) {
+            val limiter = BandwidthLimiter(bytesPerSecond)
+            val throttledSink = object : ForwardingSink(sink) {
+                override fun write(source: Buffer, byteCount: Long) {
+                    super.write(source, byteCount)
+                    limiter.throttle(byteCount)
+                }
+            }.buffer()
+            delegate.writeTo(throttledSink)
+            throttledSink.flush()
+        }
+    }
+
+    private class ThrottledResponseBody(
+        private val delegate: ResponseBody,
+        private val bytesPerSecond: Long
+    ) : ResponseBody() {
+        private var bufferedSource: BufferedSource? = null
+
+        override fun contentType(): MediaType? = delegate.contentType()
+
+        override fun contentLength(): Long = delegate.contentLength()
+
+        override fun source(): BufferedSource {
+            if (bufferedSource == null) {
+                val limiter = BandwidthLimiter(bytesPerSecond)
+                val throttledSource: Source = object : ForwardingSource(delegate.source()) {
+                    override fun read(sink: Buffer, byteCount: Long): Long {
+                        val bytesRead = super.read(sink, byteCount)
+                        if (bytesRead > 0) {
+                            limiter.throttle(bytesRead)
+                        }
+                        return bytesRead
+                    }
+                }
+                bufferedSource = throttledSource.buffer()
+            }
+            return bufferedSource!!
+        }
+    }
+
+    private class ThrottleInterceptor : Interceptor {
         override fun intercept(chain: Interceptor.Chain): Response {
             val requestStartNanos = System.nanoTime()
             val delayNanos = getLatencyNanos()
-            val response = chain.proceed(chain.request())
+            val request = chain.request()
+            val requestBody = request.body
+            val activeUploadBps = getUploadBps()
+            val throttledRequest =
+                if (activeUploadBps > 0 && requestBody != null) {
+                    request.newBuilder()
+                        .method(
+                            request.method,
+                            ThrottledRequestBody(requestBody, activeUploadBps)
+                        )
+                        .build()
+                } else {
+                    request
+                }
+            val response = chain.proceed(throttledRequest)
             if (delayNanos > 0) {
                 try {
                     val elapsedNanos = System.nanoTime() - requestStartNanos
                     val remainingDelayNanos = delayNanos - elapsedNanos
                     if (remainingDelayNanos <= 0) {
-                        return response
+                        return wrapResponseBody(response)
                     }
-                    val delayMs = TimeUnit.NANOSECONDS.toMillis(remainingDelayNanos)
-                    val remainingNanos =
-                        (remainingDelayNanos - TimeUnit.MILLISECONDS.toNanos(delayMs)).toInt()
-                    Thread.sleep(delayMs, remainingNanos)
-                } catch (error: InterruptedException) {
+                    sleepNanos(remainingDelayNanos)
+                } catch (error: InterruptedIOException) {
                     response.close()
-                    Thread.currentThread().interrupt()
                     throw IOException("Interrupted while applying OneKey network throttle", error)
                 }
             }
-            return response
+            return wrapResponseBody(response)
+        }
+
+        private fun wrapResponseBody(response: Response): Response {
+            val responseBody = response.body ?: return response
+            val activeDownloadBps = getDownloadBps()
+            if (activeDownloadBps <= 0) {
+                return response
+            }
+            return response.newBuilder()
+                .body(ThrottledResponseBody(responseBody, activeDownloadBps))
+                .build()
         }
     }
 }

package/ios/OneKeyNetworkThrottle.m

@@ -7,18 +7,27 @@
 static NSString *const OneKeyNetworkThrottleHandledKey = @"OneKeyNetworkThrottleHandled";
 static NSString *const OneKeyNetworkThrottleProfileSlow4G = @"slow4g";
 static const NSTimeInterval OneKeyNetworkThrottleDefaultLatencyMs = 562.5;
+static const NSInteger OneKeyNetworkThrottleDefaultThroughputBps = 102 * 1024;
+static const NSUInteger OneKeyNetworkThrottleMaxPendingDownloadBytes = 256 * 1024;
 
 @interface OneKeyNetworkThrottleState : NSObject
 + (NSDictionary *)currentConfig;
 + (BOOL)isEnabled;
 + (NSTimeInterval)latencyMs;
-+ (NSDictionary *)setEnabled:(BOOL)enabled latencyMs:(NSTimeInterval)latencyMs;
++ (NSInteger)downloadBps;
++ (NSInteger)uploadBps;
++ (NSDictionary *)setEnabled:(BOOL)enabled
+                    latencyMs:(NSTimeInterval)latencyMs
+                   downloadBps:(NSInteger)downloadBps
+                      uploadBps:(NSInteger)uploadBps;
 @end
 
 @implementation OneKeyNetworkThrottleState
 
 static atomic_bool _oneKeyNetworkThrottleEnabled = ATOMIC_VAR_INIT(false);
 static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500);
+static atomic_llong _oneKeyNetworkThrottleDownloadBps = ATOMIC_VAR_INIT(102 * 1024);
+static atomic_llong _oneKeyNetworkThrottleUploadBps = ATOMIC_VAR_INIT(102 * 1024);
 
 + (NSDictionary *)currentConfig
 {
@@ -28,7 +37,9 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
   return @{
     @"enabled": @(enabled),
     @"profile": OneKeyNetworkThrottleProfileSlow4G,
-    @"latencyMs": @(latencyMs)
+    @"latencyMs": @(latencyMs),
+    @"downloadBps": @([self downloadBps]),
+    @"uploadBps": @([self uploadBps])
   };
 }
 
@@ -42,20 +53,44 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
   return ((NSTimeInterval)atomic_load_explicit(&_oneKeyNetworkThrottleLatencyMicros, memory_order_relaxed)) / 1000.0;
 }
 
-+ (NSDictionary *)setEnabled:(BOOL)enabled latencyMs:(NSTimeInterval)latencyMs
++ (NSInteger)downloadBps
+{
+  return (NSInteger)atomic_load_explicit(&_oneKeyNetworkThrottleDownloadBps, memory_order_relaxed);
+}
+
++ (NSInteger)uploadBps
+{
+  return (NSInteger)atomic_load_explicit(&_oneKeyNetworkThrottleUploadBps, memory_order_relaxed);
+}
+
++ (NSInteger)normalizeThroughputBps:(NSInteger)throughputBps
+{
+  return throughputBps > 0 ? throughputBps : OneKeyNetworkThrottleDefaultThroughputBps;
+}
+
++ (NSDictionary *)setEnabled:(BOOL)enabled
+                    latencyMs:(NSTimeInterval)latencyMs
+                   downloadBps:(NSInteger)downloadBps
+                      uploadBps:(NSInteger)uploadBps
 {
   NSTimeInterval normalizedLatencyMs = latencyMs > 0 ? latencyMs : OneKeyNetworkThrottleDefaultLatencyMs;
+  NSInteger normalizedDownloadBps = [self normalizeThroughputBps:downloadBps];
+  NSInteger normalizedUploadBps = [self normalizeThroughputBps:uploadBps];
   atomic_store_explicit(
     &_oneKeyNetworkThrottleLatencyMicros,
     (long long)llround(normalizedLatencyMs * 1000.0),
     memory_order_relaxed
   );
+  atomic_store_explicit(&_oneKeyNetworkThrottleDownloadBps, (long long)normalizedDownloadBps, memory_order_relaxed);
+  atomic_store_explicit(&_oneKeyNetworkThrottleUploadBps, (long long)normalizedUploadBps, memory_order_relaxed);
   atomic_store_explicit(&_oneKeyNetworkThrottleEnabled, enabled, memory_order_release);
   NSLog(
-    @"[onekey-network-throttle] native config enabled=%@ profile=%@ latencyMs=%.1f",
+    @"[onekey-network-throttle] native config enabled=%@ profile=%@ latencyMs=%.1f downloadBps=%ld uploadBps=%ld",
     enabled ? @"true" : @"false",
     OneKeyNetworkThrottleProfileSlow4G,
-    normalizedLatencyMs
+    normalizedLatencyMs,
+    (long)normalizedDownloadBps,
+    (long)normalizedUploadBps
   );
   return [self currentConfig];
 }
@@ -68,13 +103,27 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
 @property (atomic, assign) BOOL stopped;
 @property (nonatomic, assign) CFAbsoluteTime requestStartTime;
 @property (nonatomic, assign) NSTimeInterval latencySeconds;
+@property (nonatomic, assign) NSInteger downloadBps;
+@property (nonatomic, assign) NSInteger uploadBps;
+@property (nonatomic, assign) CFAbsoluteTime downloadStartTime;
+@property (nonatomic, assign) long long downloadedBytes;
 @property (atomic, assign) BOOL responseDelivered;
+@property (atomic, assign) BOOL flushingData;
+@property (atomic, assign) BOOL upstreamCompleted;
+@property (nonatomic, strong) NSError *upstreamError;
 @property (nonatomic, strong) NSMutableArray<NSData *> *pendingData;
+@property (nonatomic, assign) NSUInteger pendingDataBytes;
 @property (nonatomic, copy) void (^pendingResponseCompletionHandler)(NSURLSessionResponseDisposition disposition);
+@property (atomic, assign) BOOL upstreamSuspendedForBackpressure;
 - (NSTimeInterval)remainingLatencyDelay;
+- (NSTimeInterval)uploadDelayForRequest:(NSURLRequest *)request;
+- (NSTimeInterval)downloadDelayForDataLength:(NSUInteger)dataLength;
 - (void)deliverResponse:(NSURLResponse *)response;
 - (void)flushPendingData;
+- (void)finishIfPossible;
 - (void)cancelPendingResponseCompletionHandler;
+- (void)applyUpstreamBackpressureIfNeeded;
+- (void)clearPendingData;
 - (void)invalidateSessionAndClearTaskWithCancel:(BOOL)cancel;
 @end
 
@@ -104,7 +153,15 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
 
   self.requestStartTime = CFAbsoluteTimeGetCurrent();
   self.latencySeconds = [OneKeyNetworkThrottleState latencyMs] / 1000.0;
+  self.downloadBps = [OneKeyNetworkThrottleState downloadBps];
+  self.uploadBps = [OneKeyNetworkThrottleState uploadBps];
+  self.downloadStartTime = 0;
+  self.downloadedBytes = 0;
+  self.upstreamCompleted = NO;
+  self.upstreamError = nil;
   self.pendingData = [NSMutableArray array];
+  self.pendingDataBytes = 0;
+  self.upstreamSuspendedForBackpressure = NO;
 
   NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
   NSNumber *useWifiOnly = [[NSBundle mainBundle].infoDictionary objectForKey:@"ReactNetworkForceWifiOnly"];
@@ -116,13 +173,23 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
   configuration.HTTPCookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   self.session = [NSURLSession sessionWithConfiguration:configuration delegate:self delegateQueue:nil];
   self.task = [self.session dataTaskWithRequest:request];
-  [self.task resume];
+  NSTimeInterval uploadDelay = [self uploadDelayForRequest:request];
+  if (uploadDelay <= 0) {
+    [self.task resume];
+    return;
+  }
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(uploadDelay * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+    if (!self.stopped) {
+      [self.task resume];
+    }
+  });
 }
 
 - (void)stopLoading
 {
   self.stopped = YES;
   [self cancelPendingResponseCompletionHandler];
+  [self clearPendingData];
   [self invalidateSessionAndClearTaskWithCancel:YES];
 }
 
@@ -133,6 +200,34 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
   return remainingDelay > 0 ? remainingDelay : 0;
 }
 
+- (NSTimeInterval)uploadDelayForRequest:(NSURLRequest *)request
+{
+  if (self.uploadBps <= 0) {
+    return 0;
+  }
+  long long bodyLength = (long long)request.HTTPBody.length;
+  if (bodyLength <= 0) {
+    NSString *contentLength = [request valueForHTTPHeaderField:@"Content-Length"];
+    bodyLength = contentLength != nil ? contentLength.longLongValue : 0;
+  }
+  return bodyLength > 0 ? ((NSTimeInterval)bodyLength) / ((NSTimeInterval)self.uploadBps) : 0;
+}
+
+- (NSTimeInterval)downloadDelayForDataLength:(NSUInteger)dataLength
+{
+  if (self.downloadBps <= 0 || dataLength == 0) {
+    return 0;
+  }
+  if (self.downloadStartTime <= 0) {
+    self.downloadStartTime = CFAbsoluteTimeGetCurrent();
+  }
+  long long bytesAfterData = self.downloadedBytes + (long long)dataLength;
+  NSTimeInterval expectedElapsed = ((NSTimeInterval)bytesAfterData) / ((NSTimeInterval)self.downloadBps);
+  NSTimeInterval actualElapsed = CFAbsoluteTimeGetCurrent() - self.downloadStartTime;
+  NSTimeInterval delay = expectedElapsed - actualElapsed;
+  return delay > 0 ? delay : 0;
+}
+
 - (void)deliverResponse:(NSURLResponse *)response
 {
   void (^completionHandler)(NSURLSessionResponseDisposition disposition) = nil;
@@ -148,24 +243,85 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
     return;
   }
   self.responseDelivered = YES;
+  self.downloadStartTime = CFAbsoluteTimeGetCurrent();
   [self.client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
-  [self flushPendingData];
   completionHandler(NSURLSessionResponseAllow);
+  [self flushPendingData];
+  [self finishIfPossible];
 }
 
 - (void)flushPendingData
 {
-  NSArray<NSData *> *pendingData = nil;
+  if (self.stopped || !self.responseDelivered) {
+    return;
+  }
+  NSData *data = nil;
   @synchronized (self) {
-    pendingData = [self.pendingData copy];
-    [self.pendingData removeAllObjects];
+    if (self.flushingData) {
+      return;
+    }
+    data = self.pendingData.firstObject;
+    if (data) {
+      [self.pendingData removeObjectAtIndex:0];
+      self.flushingData = YES;
+    }
+  }
+  if (!data) {
+    [self finishIfPossible];
+    return;
   }
-  for (NSData *data in pendingData) {
+  NSTimeInterval delay = [self downloadDelayForDataLength:data.length];
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
     if (self.stopped) {
+      @synchronized (self) {
+        self.flushingData = NO;
+      }
       return;
     }
     [self.client URLProtocol:self didLoadData:data];
+    @synchronized (self) {
+      self.downloadedBytes += (long long)data.length;
+      if (self.pendingDataBytes >= data.length) {
+        self.pendingDataBytes -= data.length;
+      } else {
+        self.pendingDataBytes = 0;
+      }
+      self.flushingData = NO;
+    }
+    [self applyUpstreamBackpressureIfNeeded];
+    [self flushPendingData];
+  });
+}
+
+- (void)finishIfPossible
+{
+  NSError *error = nil;
+  BOOL shouldFinish = NO;
+  @synchronized (self) {
+    if (
+      self.stopped ||
+      !self.upstreamCompleted ||
+      !self.responseDelivered ||
+      self.flushingData ||
+      self.pendingData.count > 0
+    ) {
+      return;
+    }
+    error = self.upstreamError;
+    self.upstreamCompleted = NO;
+    shouldFinish = YES;
+  }
+  if (!shouldFinish || self.stopped) {
+    return;
+  }
+  if (error) {
+    [self.client URLProtocol:self didFailWithError:error];
+  } else {
+    [self.client URLProtocolDidFinishLoading:self];
   }
+  self.stopped = YES;
+  [self clearPendingData];
+  [self invalidateSessionAndClearTaskWithCancel:NO];
 }
 
 - (void)cancelPendingResponseCompletionHandler
@@ -180,6 +336,40 @@ static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500
   }
 }
 
+- (void)applyUpstreamBackpressureIfNeeded
+{
+  NSURLSessionDataTask *taskToSuspend = nil;
+  NSURLSessionDataTask *taskToResume = nil;
+  @synchronized (self) {
+    if (self.stopped || !self.task || self.downloadBps <= 0) {
+      return;
+    }
+    BOOL shouldSuspend = self.pendingDataBytes >= OneKeyNetworkThrottleMaxPendingDownloadBytes;
+    if (shouldSuspend && !self.upstreamSuspendedForBackpressure) {
+      self.upstreamSuspendedForBackpressure = YES;
+      taskToSuspend = self.task;
+    } else if (!shouldSuspend && self.upstreamSuspendedForBackpressure) {
+      self.upstreamSuspendedForBackpressure = NO;
+      taskToResume = self.task;
+    }
+  }
+  if (taskToSuspend) {
+    [taskToSuspend suspend];
+  }
+  if (taskToResume) {
+    [taskToResume resume];
+  }
+}
+
+- (void)clearPendingData
+{
+  @synchronized (self) {
+    [self.pendingData removeAllObjects];
+    self.pendingDataBytes = 0;
+    self.upstreamSuspendedForBackpressure = NO;
+  }
+}
+
 - (void)invalidateSessionAndClearTaskWithCancel:(BOOL)cancel
 {
   NSURLSessionDataTask *task = nil;
@@ -231,28 +421,36 @@ didReceiveResponse:(NSURLResponse *)response
   if (self.stopped) {
     return;
   }
+  @synchronized (self) {
+    [self.pendingData addObject:data];
+    self.pendingDataBytes += data.length;
+  }
+  [self applyUpstreamBackpressureIfNeeded];
   if (self.responseDelivered) {
-    [self.client URLProtocol:self didLoadData:data];
-  } else {
-    @synchronized (self) {
-      [self.pendingData addObject:data];
-    }
+    [self flushPendingData];
   }
 }
 
 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
 {
-  if (!self.responseDelivered) {
-    [self cancelPendingResponseCompletionHandler];
-  }
-  if (!self.stopped) {
-    if (error) {
+  if (error) {
+    if (!self.responseDelivered) {
+      [self cancelPendingResponseCompletionHandler];
+    }
+    if (!self.stopped) {
       [self.client URLProtocol:self didFailWithError:error];
-    } else {
-      [self.client URLProtocolDidFinishLoading:self];
+      self.stopped = YES;
     }
+    [self clearPendingData];
+    [self invalidateSessionAndClearTaskWithCancel:NO];
+    return;
   }
-  [self invalidateSessionAndClearTaskWithCancel:NO];
+
+  @synchronized (self) {
+    self.upstreamCompleted = YES;
+    self.upstreamError = error;
+  }
+  [self finishIfPossible];
 }
 
 @end
@@ -309,7 +507,17 @@ RCT_REMAP_METHOD(setConfig, setConfig:(NSDictionary *)config resolver:(RCTPromis
   id latencyValue = config[@"latencyMs"];
   NSTimeInterval latencyMs =
     latencyValue != nil && latencyValue != [NSNull null] ? [latencyValue doubleValue] : [OneKeyNetworkThrottleState latencyMs];
-  resolve([OneKeyNetworkThrottleState setEnabled:enabled latencyMs:latencyMs]);
+  id downloadBpsValue = config[@"downloadBps"];
+  NSInteger downloadBps =
+    downloadBpsValue != nil && downloadBpsValue != [NSNull null]
+      ? [downloadBpsValue integerValue]
+      : [OneKeyNetworkThrottleState downloadBps];
+  id uploadBpsValue = config[@"uploadBps"];
+  NSInteger uploadBps =
+    uploadBpsValue != nil && uploadBpsValue != [NSNull null]
+      ? [uploadBpsValue integerValue]
+      : [OneKeyNetworkThrottleState uploadBps];
+  resolve([OneKeyNetworkThrottleState setEnabled:enabled latencyMs:latencyMs downloadBps:downloadBps uploadBps:uploadBps]);
 }
 
 @end

package/lib/module/index.js

@@ -2,6 +2,9 @@
 
 import { NativeModules, Platform } from 'react-native';
 export const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
+export const NETWORK_THROTTLE_102_KIB_BPS = 102 * 1024;
+export const NETWORK_THROTTLE_SLOW_4G_DOWNLOAD_BPS = NETWORK_THROTTLE_102_KIB_BPS;
+export const NETWORK_THROTTLE_SLOW_4G_UPLOAD_BPS = NETWORK_THROTTLE_102_KIB_BPS;
 const LINKING_ERROR = `The package '@onekeyfe/react-native-network-throttle' doesn't seem to be linked. ` + Platform.select({
   ios: "- run 'pod install'\n",
   default: ''
@@ -14,7 +17,9 @@ export const NetworkThrottle = nativeModule ? {
     return nativeModule.setConfig({
       enabled: config.enabled ?? currentConfig.enabled,
       profile: config.profile ?? currentConfig.profile,
-      latencyMs: config.latencyMs ?? currentConfig.latencyMs
+      latencyMs: config.latencyMs ?? currentConfig.latencyMs,
+      downloadBps: config.downloadBps ?? currentConfig.downloadBps,
+      uploadBps: config.uploadBps ?? currentConfig.uploadBps
     });
   }
 } : new Proxy({}, {

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

@@ -3,8 +3,13 @@ export type NetworkThrottleConfig = {
     enabled: boolean;
     profile: NetworkThrottleProfile;
     latencyMs: number;
+    downloadBps: number;
+    uploadBps: number;
 };
 export declare const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
+export declare const NETWORK_THROTTLE_102_KIB_BPS: number;
+export declare const NETWORK_THROTTLE_SLOW_4G_DOWNLOAD_BPS: number;
+export declare const NETWORK_THROTTLE_SLOW_4G_UPLOAD_BPS: number;
 export type NetworkThrottleModule = {
     getConfig: () => Promise<NetworkThrottleConfig>;
     setConfig: (config: Partial<NetworkThrottleConfig>) => Promise<NetworkThrottleConfig>;

package/package.json

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

package/src/index.tsx

@@ -6,9 +6,15 @@ export type NetworkThrottleConfig = {
   enabled: boolean;
   profile: NetworkThrottleProfile;
   latencyMs: number;
+  downloadBps: number;
+  uploadBps: number;
 };
 
 export const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
+export const NETWORK_THROTTLE_102_KIB_BPS = 102 * 1024;
+export const NETWORK_THROTTLE_SLOW_4G_DOWNLOAD_BPS =
+  NETWORK_THROTTLE_102_KIB_BPS;
+export const NETWORK_THROTTLE_SLOW_4G_UPLOAD_BPS = NETWORK_THROTTLE_102_KIB_BPS;
 
 type NativeNetworkThrottleModule = {
   getConfig: () => Promise<NetworkThrottleConfig>;
@@ -40,6 +46,8 @@ export const NetworkThrottle: NetworkThrottleModule = nativeModule
           enabled: config.enabled ?? currentConfig.enabled,
           profile: config.profile ?? currentConfig.profile,
           latencyMs: config.latencyMs ?? currentConfig.latencyMs,
+          downloadBps: config.downloadBps ?? currentConfig.downloadBps,
+          uploadBps: config.uploadBps ?? currentConfig.uploadBps,
         });
       },
     }