Fix #66

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

 
 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
-    String filePathPrefix = "RNFetchBlob-file://";
     static ReactApplicationContext RCTContext;
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
         RNFetchBlobFS.slice(src, dest, start, end, encode, callback);
     }
 
+    @ReactMethod
+    public void enableProgressReport(String taskId) {
+        RNFetchBlobReq.progressReport.put(taskId, true);
+    }
+
+    @ReactMethod
+    public void enableUploadProgressReport(String taskId) {
+        RNFetchBlobReq.uploadProgressReport.put(taskId, true);
+    }
+
     @ReactMethod
     public void fetchBlob(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, final Callback callback) {
         new RNFetchBlobReq(options, taskId, method, url, headers, body, null, callback).run();

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

             args.putString("written", String.valueOf(bytesWritten));
             args.putString("total", String.valueOf(contentLength));
 
-            // emit event to js context
-            RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                    .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+            if(RNFetchBlobReq.isReportUploadProgress(mTaskId)) {
+                // emit event to js context
+                RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                        .emit(RNFetchBlobConst.EVENT_UPLOAD_PROGRESS, args);
+            }
         }
     }
 }

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

         FileStorage
     };
 
-    static HashMap<String, Call> taskTable = new HashMap<>();
+    public static HashMap<String, Call> taskTable = new HashMap<>();
+    static HashMap<String, Boolean> progressReport = new HashMap<>();
+    static HashMap<String, Boolean> uploadProgressReport = new HashMap<>();
 
     MediaType contentType = RNFetchBlobConst.MIME_OCTET;
     ReactApplicationContext ctx;
     long downloadManagerId;
     RequestType requestType;
     ResponseType responseType;
-    boolean timeout = false;
     WritableMap respInfo;
+    boolean timeout = false;
+    public boolean reportProgress = false;
+    public boolean reportUploadProgress = false;
 
     public RNFetchBlobReq(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, ReadableArray arrayBody, final Callback callback) {
         this.method = method;
             }
 
             OkHttpClient client = clientBuilder.build();
-            Call call = client.newCall(req);
+            Call call =  client.newCall(req);
             taskTable.put(taskId, call);
             call.enqueue(new okhttp3.Callback() {
 
                     }
                     else
                         callback.invoke(e.getLocalizedMessage(), respInfo, null);
+                    removeTaskInfo();
                 }
 
                 @Override
         }
     }
 
+    /**
+     * Remove cached information of the HTTP task
+     */
+    private void removeTaskInfo() {
+        if(taskTable.containsKey(taskId))
+            taskTable.remove(taskId);
+        if(uploadProgressReport.containsKey(taskId))
+            uploadProgressReport.remove(taskId);
+        if(progressReport.containsKey(taskId))
+            progressReport.remove(taskId);
+    }
+
     /**
      * Send response data back to javascript context.
      * @param resp OkHttp response object
                 }
                 break;
         }
-        if(taskTable.containsKey(taskId))
-            taskTable.remove(taskId);
+        removeTaskInfo();
+    }
+
+    public static boolean isReportProgress(String taskId) {
+        if(!progressReport.containsKey(taskId)) return false;
+        return progressReport.get(taskId);
+    }
+
+    public static boolean isReportUploadProgress(String taskId) {
+        if(!uploadProgressReport.containsKey(taskId)) return false;
+        return uploadProgressReport.get(taskId);
     }
 
     private WritableMap getResponseInfo(Response resp) {

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

 package com.RNFetchBlob.Response;
 
 import com.RNFetchBlob.RNFetchBlob;
+import com.RNFetchBlob.RNFetchBlobReq;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.WritableMap;
 
             long read =  mOriginalSource.read(sink, byteCount);
             bytesRead += read > 0 ? read : 0;
-            WritableMap args = Arguments.createMap();
-            args.putString("taskId", mTaskId);
-            args.putString("written", String.valueOf(bytesRead));
-            args.putString("total", String.valueOf(contentLength()));
-            rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                    .emit("RNFetchBlobProgress", args);
+            if(RNFetchBlobReq.isReportProgress(mTaskId)) {
+                WritableMap args = Arguments.createMap();
+                args.putString("taskId", mTaskId);
+                args.putString("written", String.valueOf(bytesRead));
+                args.putString("total", String.valueOf(contentLength()));
+                rctContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                        .emit("RNFetchBlobProgress", args);
+            }
             return read;
         }
 

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

 
 import android.util.Log;
 
+import com.RNFetchBlob.RNFetchBlobReq;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.WritableMap;
             long read = originalBody.byteStream().read(bytes, 0, (int) byteCount);
             bytesDownloaded += read > 0 ? read : 0;
             Log.i("bytes downloaded", String.valueOf(byteCount) +"/"+ String.valueOf(read) + "=" + String.valueOf(bytesDownloaded));
-            if(read > 0) {
+            if(read > 0 ) {
                 ofStream.write(bytes, 0, (int) read);
+            }
+            if(RNFetchBlobReq.isReportProgress(mTaskId)) {
                 WritableMap args = Arguments.createMap();
                 args.putString("taskId", mTaskId);
                 args.putString("written", String.valueOf(bytesDownloaded));

src/index.js

   // method for register progress event handler and cancel request.
   promise.progress = (fn) => {
     promise.onProgress = fn
+    RNFetchBlob.enableProgressReport(taskId)
     return promise
   }
   promise.uploadProgress = (fn) => {
     promise.onUploadProgress = fn
+    RNFetchBlob.enableUploadProgressReport(taskId)
     return promise
   }
   promise.stateChange = (fn) => {

src/ios/RNFetchBlob/RNFetchBlob.m

 
 }
 
+RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId {
+    [RNFetchBlobNetwork enableProgressReport:taskId];
+})
+
+RCT_EXPORT_METHOD(enableUploadProgressReport:(NSString *)taskId {
+    [RNFetchBlobNetwork enableUploadProgress:taskId];
+})
+
 RCT_EXPORT_METHOD(slice:(NSString *)src dest:(NSString *)dest start:(NSNumber *)start end:(NSNumber *)end resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject
 {
     [RNFetchBlobFS slice:src dest:dest start:start end:end encode:@"" resolver:resolve rejecter:reject];

src/ios/RNFetchBlobConst.h

 extern NSString *const FS_EVENT_WARN;
 extern NSString *const FS_EVENT_ERROR;
 
+extern NSString *const KEY_REPORT_PROGRESS;
+extern NSString *const KEY_REPORT_UPLOAD_PROGRESS;
+
 
 
 #endif /* RNFetchBlobConst_h */

src/ios/RNFetchBlobConst.m

 extern NSString *const FS_EVENT_END = @"end";
 extern NSString *const FS_EVENT_WARN = @"warn";
 extern NSString *const FS_EVENT_ERROR = @"error";
+
+extern NSString *const KEY_REPORT_PROGRESS = @"reportProgress";
+extern NSString *const KEY_REPORT_UPLOAD_PROGRESS = @"reportUploadProgress";

src/ios/RNFetchBlobNetwork.h

 
 + (NSMutableDictionary  * _Nullable ) normalizeHeaders:(NSDictionary * _Nullable)headers;
 + (void) cancelRequest:(NSString *)taskId;
++ (void) enableProgressReport:(NSString *) taskId;
++ (void) enableUploadProgress:(NSString *) taskId;
 - (void) sendRequest:(NSDictionary  * _Nullable )options contentLength:(long)contentLength bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
 
 

src/ios/RNFetchBlobNetwork.m

 ////////////////////////////////////////
 
 NSMutableDictionary * taskTable;
+NSMutableDictionary * progressTable;
+NSMutableDictionary * uploadProgressTable;
 
 @interface RNFetchBlobNetwork ()
 {
     if(taskTable == nil) {
         taskTable = [[NSMutableDictionary alloc] init];
     }
+    if(progressTable == nil)
+    {
+        progressTable = [[NSMutableDictionary alloc] init];
+    }
+    if(uploadProgressTable == nil)
+    {
+        uploadProgressTable = [[NSMutableDictionary alloc] init];
+    }
     return self;
 }
 
++ (void) enableProgressReport:(NSString *) taskId
+{
+    [progressTable setValue:@YES forKey:taskId];
+}
+
++ (void) enableUploadProgress:(NSString *) taskId
+{
+    [uploadProgressTable setValue:@YES forKey:taskId];
+}
 
 // removing case from headers
-+ (NSMutableDictionary *) normalizeHeaders:(NSDictionary *)headers {
++ (NSMutableDictionary *) normalizeHeaders:(NSDictionary *)headers
+{
 
     NSMutableDictionary * mheaders = [[NSMutableDictionary alloc]init];
     for(NSString * key in headers) {
         respFile = NO;
     }
     NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
-    [taskTable setValue:task forKey:taskId];
+    [taskTable setValue:@{ @"task": task, KEY_REPORT_PROGRESS : @NO, KEY_REPORT_UPLOAD_PROGRESS : @NO} forKey:taskId];
     [task resume];
 
     // network status indicator
     {
         [writeStream write:[data bytes] maxLength:[data length]];
     }
-
-    [self.bridge.eventDispatcher
-     sendDeviceEventWithName:@"RNFetchBlobProgress"
-     body:@{
-            @"taskId": taskId,
-            @"written": [NSString stringWithFormat:@"%d", receivedBytes],
-            @"total": [NSString stringWithFormat:@"%d", expectedBytes]
-            }
-     ];
+    
+    if([progressTable valueForKey:taskId] == @YES)
+    {
+        [self.bridge.eventDispatcher
+         sendDeviceEventWithName:@"RNFetchBlobProgress"
+         body:@{
+                @"taskId": taskId,
+                @"written": [NSString stringWithFormat:@"%d", receivedBytes],
+                @"total": [NSString stringWithFormat:@"%d", expectedBytes]
+                }
+         ];
+    }
 
 }
 
                    [respData base64EncodedStringWithOptions:0]
                    ]);
     }
+    
+    [taskTable removeObjectForKey:taskId];
+    [uploadProgressTable removeObjectForKey:taskId];
+    [progressTable removeObjectForKey:taskId];
 }
 
 // upload progress handler
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didSendBodyData:(int64_t)bytesSent totalBytesSent:(int64_t)totalBytesWritten totalBytesExpectedToSend:(int64_t)totalBytesExpectedToWrite
 {
-    [self.bridge.eventDispatcher
-     sendDeviceEventWithName:@"RNFetchBlobProgress-upload"
-     body:@{
-            @"taskId": taskId,
-            @"written": [NSString stringWithFormat:@"%d", totalBytesWritten],
-            @"total": [NSString stringWithFormat:@"%d", bodyLength]
-            }
-     ];
+    if([uploadProgressTable valueForKey:taskId] == @YES) {
+        [self.bridge.eventDispatcher
+         sendDeviceEventWithName:@"RNFetchBlobProgress-upload"
+         body:@{
+                @"taskId": taskId,
+                @"written": [NSString stringWithFormat:@"%d", totalBytesWritten],
+                @"total": [NSString stringWithFormat:@"%d", bodyLength]
+                }
+         ];
+    }
 }
 
 + (void) cancelRequest:(NSString *)taskId
 {
-    NSURLSessionDataTask * task = (NSURLSessionDataTask *)[taskTable objectForKey:taskId];
+    NSURLSessionDataTask * task = (NSURLSessionDataTask *)[[taskTable objectForKey:taskId] objectForKey:@"task"];
     if(task != nil && task.state == NSURLSessionTaskStateRunning)
         [task cancel];
 }