Add new attribute to fs.readStream #118

Introduce new argument which can limit readStream event frequency

src/android/src/main/java/com/RNFetchBlob/RNFetchBlob.java

      * @param encoding Stream encoding, should be one of `base64`, `ascii`, and `utf8`
      * @param bufferSize Stream buffer size, default to 4096 or 4095(base64).
      */
-    public void readStream(final String path, final String encoding, final int bufferSize, final String streamId) {
+    public void readStream(final String path, final String encoding, final int bufferSize, final int tick, final String streamId) {
         final ReactApplicationContext ctx = this.getReactApplicationContext();
         threadPool.execute(new Runnable() {
             @Override
             public void run() {
                 RNFetchBlobFS fs = new RNFetchBlobFS(ctx);
-                fs.readStream(path, encoding, bufferSize, streamId);
+                fs.readStream(path, encoding, bufferSize, tick, streamId);
             }
         });
     }

src/android/src/main/java/com/RNFetchBlob/RNFetchBlobFS.java

 import android.os.AsyncTask;
 import android.os.Environment;
 import android.os.Looper;
+import android.os.SystemClock;
 import android.provider.MediaStore;
 import android.util.Base64;
 
      * @param encoding  File stream decoder, should be one of `base64`, `utf8`, `ascii`
      * @param bufferSize    Buffer size of read stream, default to 4096 (4095 when encode is `base64`)
      */
-    public void readStream(String path, String encoding, int bufferSize, final String streamId) {
+    public void readStream(String path, String encoding, int bufferSize, int tick, final String streamId) {
         path = normalizePath(path);
         try {
 
                 while ((cursor = fs.read(buffer)) != -1) {
                     String chunk = new String(buffer, 0, cursor, "UTF-8");
                     emitStreamEvent(streamId, "data", chunk);
+                    if(tick > 0)
+                        SystemClock.sleep(tick);
                 }
             } else if (encoding.equalsIgnoreCase("ascii")) {
                 while ((cursor = fs.read(buffer)) != -1) {
                         chunk.pushInt((int)buffer[i]);
                     }
                     emitStreamEvent(streamId, "data", chunk);
+                    if(tick > 0)
+                        SystemClock.sleep(tick);
                 }
             } else if (encoding.equalsIgnoreCase("base64")) {
                 while ((cursor = fs.read(buffer)) != -1) {
                     }
                     else
                         emitStreamEvent(streamId, "data", Base64.encodeToString(buffer, Base64.NO_WRAP));
+                    if(tick > 0)
+                        SystemClock.sleep(tick);
                 }
             } else {
                 String msg = "unrecognized encoding `" + encoding + "`";

src/android/src/main/java/com/RNFetchBlob/RNFetchBlobReq.java

 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.concurrent.TimeUnit;
 
     ResponseType responseType;
     WritableMap respInfo;
     boolean timeout = false;
+    ArrayList<String> redirects = new ArrayList<>();
 
     public RNFetchBlobReq(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, ReadableArray arrayBody, final Callback callback) {
         this.method = method.toUpperCase();
             }
 
             final Request req = builder.build();
-
+            clientBuilder.addNetworkInterceptor(new Interceptor() {
+                @Override
+                public Response intercept(Chain chain) throws IOException {
+                        redirects.add(chain.request().url().toString());
+                        return chain.proceed(chain.request());
+                    }
+            });
             // Add request interceptor for upload progress event
             clientBuilder.addInterceptor(new Interceptor() {
                 @Override
             clientBuilder.retryOnConnectionFailure(false);
             clientBuilder.followRedirects(true);
 
+
             OkHttpClient client = clientBuilder.retryOnConnectionFailure(true).build();
             Call call =  client.newCall(req);
             taskTable.put(taskId, call);
         for(int i =0;i< resp.headers().size();i++) {
             headers.putString(resp.headers().name(i), resp.headers().value(i));
         }
+        WritableArray redirectList = Arguments.createArray();
+        for(String r : redirects) {
+                redirectList.pushString(r);
+        }
+        info.putArray("redirects", redirectList);
         info.putMap("headers", headers);
         Headers h = resp.headers();
         if(isBlobResp) {

src/fs.js

   path : string,
   encoding : 'utf8' | 'ascii' | 'base64',
   bufferSize? : ?number
+  tick? : ?number
 ):Promise<RNFetchBlobReadStream> {
-  return Promise.resolve(new RNFetchBlobReadStream(path, encoding, bufferSize))
+  if(!tick)
+    tick = -1
+  return Promise.resolve(new RNFetchBlobReadStream(path, encoding, bufferSize, tick))
 }
 
 /**

src/ios/RNFetchBlob/RNFetchBlob.m

 })
 
 #pragma mark - fs.readStream
-RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize streamId:(NSString *)streamId
+RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize tick:(int)tick streamId:(NSString *)streamId
 {
 
 //    RNFetchBlobFS *fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     }
     
 //    [fileStream readWithPath:path useEncoding:encoding bufferSize:bufferSize];
-    [RNFetchBlobFS readStream:path encoding:encoding bufferSize:bufferSize streamId:streamId bridgeRef:_bridge];
+    [RNFetchBlobFS readStream:path encoding:encoding bufferSize:bufferSize tick:tick streamId:streamId bridgeRef:_bridge];
 })
 
 #pragma mark - fs.getEnvionmentDirs

src/ios/RNFetchBlobFS.h

      rejecter:(RCTPromiseRejectBlock)reject;
 //+ (void) writeFileFromFile:(NSString *)src toFile:(NSString *)dest append:(BOOL)append;
 + (void) writeAssetToPath:(ALAssetRepresentation * )rep dest:(NSString *)dest;
-+ (void) readStream:(NSString *)uri encoding:(NSString * )encoding bufferSize:(int)bufferSize streamId:(NSString *)streamId bridgeRef:(RCTBridge *)bridgeRef;
++ (void) readStream:(NSString *)uri encoding:(NSString * )encoding bufferSize:(int)bufferSize tick:(int)tick streamId:(NSString *)streamId bridgeRef:(RCTBridge *)bridgeRef;
 
 // constructor
 - (id) init;

src/ios/RNFetchBlobFS.m

 + (void) readStream:(NSString *)uri
            encoding:(NSString * )encoding
          bufferSize:(int)bufferSize
+               tick:(int)tick
            streamId:(NSString *)streamId
           bridgeRef:(RCTBridge *)bridgeRef
 {