Merge branch '0.10.5'

android.js

     return Promise.reject('RNFetchBlob.actionViewIntent only supports Android.')
 }
 
+function getContentIntent(mime:string) {
+  if(Platform.OS === 'android')
+    return RNFetchBlob.getContentIntent(mime)
+  else
+    return Promise.reject('RNFetchBlob.getContentIntent only supports Android.')
+}
+
 
 export default {
-  actionViewIntent
+  actionViewIntent,
+  getContentIntent
 }

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

 package com.RNFetchBlob;
 
+import android.app.Activity;
 import android.content.Intent;
 import android.net.Uri;
+import android.util.Log;
 
 import com.RNFetchBlob.Utils.RNFBCookieJar;
+import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 
+import java.util.HashMap;
 import java.util.Map;
+import java.util.UUID;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 
+import static android.app.Activity.RESULT_OK;
+import static com.RNFetchBlob.RNFetchBlobConst.GET_CONTENT_INTENT;
+
 public class RNFetchBlob extends ReactContextBaseJavaModule {
 
     static ReactApplicationContext RCTContext;
     static LinkedBlockingQueue<Runnable> fsTaskQueue = new LinkedBlockingQueue<>();
     static ThreadPoolExecutor fsThreadPool = new ThreadPoolExecutor(2, 10, 5000, TimeUnit.MILLISECONDS, taskQueue);
     static public boolean ActionViewVisible = false;
+    static HashMap<Integer, Promise> promiseTable = new HashMap<>();
 
     public RNFetchBlob(ReactApplicationContext reactContext) {
 
         super(reactContext);
 
         RCTContext = reactContext;
+        reactContext.addActivityEventListener(new ActivityEventListener() {
+            @Override
+            public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+                if(requestCode == GET_CONTENT_INTENT && resultCode == RESULT_OK) {
+                    Uri d = data.getData();
+                    promiseTable.get(GET_CONTENT_INTENT).resolve(d.toString());
+                    promiseTable.remove(GET_CONTENT_INTENT);
+                }
+            }
+
+            @Override
+            public void onNewIntent(Intent intent) {
+
+            }
+        });
     }
 
     @Override
         new RNFetchBlobReq(options, taskId, method, url, headers, null, body, callback).run();
     }
 
+    @ReactMethod
+    public void getContentIntent(String mime, Promise promise) {
+        Intent i = new Intent(Intent.ACTION_GET_CONTENT);
+        if(mime != null)
+            i.setType(mime);
+        else
+            i.setType("*/*");
+        promiseTable.put(GET_CONTENT_INTENT, promise);
+        this.getReactApplicationContext().startActivityForResult(i, GET_CONTENT_INTENT, null);
+
+    }
+
 }

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

     public static final String RNFB_RESPONSE_BASE64 = "base64";
     public static final String RNFB_RESPONSE_UTF8  = "utf8";
     public static final String RNFB_RESPONSE_PATH  = "path";
+    public static final Integer GET_CONTENT_INTENT = 99900;
 
 }

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

 
             InputStream fs;
             if(path.startsWith(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET)) {
-                fs = RNFetchBlob.RCTContext.getAssets().open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
+                fs = RNFetchBlob.RCTContext.getAssets()
+                        .open(path.replace(RNFetchBlobConst.FILE_PREFIX_BUNDLE_ASSET, ""));
             }
             else {
                 fs = new FileInputStream(new File(path));
                 while ((cursor = fs.read(buffer)) != -1) {
                     encoder.encode(ByteBuffer.wrap(buffer).asCharBuffer());
                     String chunk = new String(buffer);
-                    if(cursor != bufferSize)
+                    if(cursor != bufferSize) {
                         chunk = chunk.substring(0, cursor);
+                    }
                     emitStreamEvent(streamId, "data", chunk);
                     if(tick > 0)
                         SystemClock.sleep(tick);
             buffer = null;
 
         } catch (Exception err) {
-            emitStreamEvent(streamId, "error", "Failed to convert data to "+encoding+" encoded string, this might due to the source data is not able to convert using this encoding.");
+            emitStreamEvent(streamId, "warn", "Failed to convert data to "+encoding+" encoded string, this might due to the source data is not able to convert using this encoding.");
+            err.printStackTrace();
         }
     }
 

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

                 DownloadManager dm = (DownloadManager) appCtx.getSystemService(Context.DOWNLOAD_SERVICE);
                 dm.query(query);
                 Cursor c = dm.query(query);
-                String error = null;
+
+
                 String filePath = null;
                 // the file exists in media content database
                 if (c.moveToFirst()) {
+                    // #297 handle failed request
+                    int statusCode = c.getInt(c.getColumnIndex(DownloadManager.COLUMN_STATUS));
+                    if(statusCode == DownloadManager.STATUS_FAILED) {
+                        this.callback.invoke("Download manager failed to download from  " + this.url + ". Statu Code = " + statusCode, null, null);
+                        return;
+                    }
                     String contentUri = c.getString(c.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI));
-                    Uri uri = Uri.parse(contentUri);
-                    Cursor cursor = appCtx.getContentResolver().query(uri, new String[]{android.provider.MediaStore.Images.ImageColumns.DATA}, null, null, null);
-                    // use default destination of DownloadManager
-                    if (cursor != null) {
-                        cursor.moveToFirst();
-                        filePath = cursor.getString(0);
+                    if (contentUri != null) {
+                        Uri uri = Uri.parse(contentUri);
+                        Cursor cursor = appCtx.getContentResolver().query(uri, new String[]{android.provider.MediaStore.Images.ImageColumns.DATA}, null, null, null);
+                        // use default destination of DownloadManager
+                        if (cursor != null) {
+                            cursor.moveToFirst();
+                            filePath = cursor.getString(0);
+                        }
                     }
                 }
                 // When the file is not found in media content database, check if custom path exists
                             this.callback.invoke(null, RNFetchBlobConst.RNFB_RESPONSE_PATH, customDest);
 
                     } catch(Exception ex) {
-                        error = ex.getLocalizedMessage();
+                        ex.printStackTrace();
+                        this.callback.invoke(ex.getLocalizedMessage(), null);
                     }
                 }
                 else {

ios/RNFetchBlob/RNFetchBlob.m

 #pragma mark - fs.stat
 RCT_EXPORT_METHOD(stat:(NSString *)target callback:(RCTResponseSenderBlock) callback)
 {
-    
+
     [RNFetchBlobFS getPathFromUri:target completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
         __block NSMutableArray * result;
         if(path != nil)
             BOOL exist = nil;
             BOOL isDir = nil;
             NSError * error = nil;
-            
+
             exist = [fm fileExistsAtPath:path isDirectory:&isDir];
             if(exist == NO) {
                 callback(@[[NSString stringWithFormat:@"failed to stat path `%@` for it is not exist or it is not exist", path]]);
                 return ;
             }
             result = [RNFetchBlobFS stat:path error:&error];
-            
+
             if(error == nil)
                 callback(@[[NSNull null], result]);
             else
 #pragma mark - fs.cp
 RCT_EXPORT_METHOD(cp:(NSString*)src toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback)
 {
-    
+
 //    path = [RNFetchBlobFS getPathOfAsset:path];
     [RNFetchBlobFS getPathFromUri:src completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
         NSError * error = nil;
         else
         {
             BOOL result = [[NSFileManager defaultManager] copyItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
-            
+
             if(error == nil)
                 callback(@[[NSNull null], @YES]);
             else
                 callback(@[[error localizedDescription], @NO]);
         }
     }];
-    
+
 }
 
 
         else
             bufferSize = 4096;
     }
-    
+
     dispatch_async(fsQueue, ^{
         [RNFetchBlobFS readStream:path encoding:encoding bufferSize:bufferSize tick:tick streamId:streamId bridgeRef:_bridge];
     });
 #pragma mark - net.enableProgressReport
 RCT_EXPORT_METHOD(enableProgressReport:(NSString *)taskId interval:(nonnull NSNumber*)interval count:(nonnull NSNumber*)count)
 {
-    
+
     RNFetchBlobProgress * cfg = [[RNFetchBlobProgress alloc] initWithType:Download interval:interval count:count];
     [RNFetchBlobNetwork enableProgressReport:taskId config:cfg];
 }
     UIViewController *rootCtrl = [[[[UIApplication sharedApplication] delegate] window] rootViewController];
     documentController.delegate = self;
     if(scheme == nil || [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:scheme]]) {
-        dispatch_sync(dispatch_get_main_queue(), ^{
-            [documentController  presentOptionsMenuFromRect:rootCtrl.view.bounds inView:rootCtrl.view animated:YES];
-        });
+      CGRect rect = CGRectMake(0.0, 0.0, 0.0, 0.0);
+      dispatch_sync(dispatch_get_main_queue(), ^{
+          [documentController  presentOptionsMenuFromRect:rect inView:rootCtrl.view animated:YES];
+      });
         resolve(@[[NSNull null]]);
     } else {
         reject(@"RNFetchBlob could not open document", @"scheme is not supported", nil);
     // NSURL * url = [[NSURL alloc] initWithString:uri];
     documentController = [UIDocumentInteractionController interactionControllerWithURL:url];
     documentController.delegate = self;
-    
+
     if(scheme == nil || [[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:scheme]]) {
         dispatch_sync(dispatch_get_main_queue(), ^{
             [documentController presentPreviewAnimated:YES];
     } else {
         reject(@"RNFetchBlob could not open document", [error description], nil);
     }
-    
+
 }
 
 
 }
 
 # pragma mark - getCookies
+
 RCT_EXPORT_METHOD(getCookies:(NSString *)url resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     resolve([RNFetchBlobNetwork getCookies:url]);
 }
 
+# pragma mark - removeCookie
+
+RCT_EXPORT_METHOD(removeCookies:(NSString *)domain resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSError * err = nil;
+    [RNFetchBlobNetwork removeCookies:domain error:&err];
+    if(err)
+        reject(@"RNFetchBlob failed to remove cookie", @"RNFetchBlob failed to remove cookie", nil);
+    else
+        resolve(@[[NSNull null]]);
+}
+
 # pragma mark - check expired network events
 
 RCT_EXPORT_METHOD(emitExpiredEvent:(RCTResponseSenderBlock)callback)
 }
 
 
+
+
 @end

ios/RNFetchBlobFS.m

 
 +(void) df:(RCTResponseSenderBlock)callback
 {
-    uint64_t totalSpace = 0;
-    uint64_t totalFreeSpace = 0;
     NSError *error = nil;
     NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
     NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error: &error];
     if (dictionary) {
         NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];
         NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
-        totalSpace = [fileSystemSizeInBytes unsignedLongLongValue];
-        totalFreeSpace = [freeFileSystemSizeInBytes unsignedLongLongValue];
+        
         callback(@[[NSNull null], @{
-                  @"free" : [NSString stringWithFormat:@"%ld", totalFreeSpace],
-                  @"total" : [NSString stringWithFormat:@"%ld", totalSpace]
+                  @"free" : freeFileSystemSizeInBytes,
+                  @"total" : fileSystemSizeInBytes,
                 }]);
     } else {
         callback(@[@"failed to get storage usage."]);

ios/RNFetchBlobNetwork.h

 - (nullable id) init;
 - (void) sendRequest;
 - (void) sendRequest:(NSDictionary  * _Nullable )options contentLength:(long)contentLength bridge:(RCTBridge * _Nullable)bridgeRef taskId:(NSString * _Nullable)taskId withRequest:(NSURLRequest * _Nullable)req callback:(_Nullable RCTResponseSenderBlock) callback;
++ (void) removeCookies:(NSString *) domain error:(NSError **)error;
 + (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config;
 + (void) enableUploadProgress:(NSString *) taskId config:(RNFetchBlobProgress *)config;
-+ (NSArray *) getCookies:(NSString *) url;
++ (NSDictionary *) getCookies:(NSString *) url;
 
 
 

ios/RNFetchBlobNetwork.m

 
 NSMapTable * taskTable;
 NSMapTable * expirationTable;
-NSMapTable * cookiesTable;
 NSMutableDictionary * progressTable;
 NSMutableDictionary * uploadProgressTable;
 
     {
         uploadProgressTable = [[NSMutableDictionary alloc] init];
     }
-    if(cookiesTable == nil)
-    {
-        cookiesTable = [[NSMapTable alloc] init];
-    }
 }
 
 
     return self;
 }
 
-+ (NSArray *) getCookies:(NSString *) url
-{
-    NSString * hostname = [[NSURL URLWithString:url] host];
-    NSMutableArray * cookies = [NSMutableArray new];
-    NSArray * list = [cookiesTable objectForKey:hostname];
-    for(NSHTTPCookie * cookie in list)
-    {
-        NSMutableString * cookieStr = [[NSMutableString alloc] init];
-        [cookieStr appendString:cookie.name];
-        [cookieStr appendString:@"="];
-        [cookieStr appendString:cookie.value];
-
-        if(cookie.expiresDate == nil) {
-            [cookieStr appendString:@"; max-age=0"];
-        }
-        else {
-            [cookieStr appendString:@"; expires="];
-            NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
-            [dateFormatter setDateFormat:@"EEE, dd MM yyyy HH:mm:ss ZZZ"];
-            NSString *strDate = [dateFormatter stringFromDate:cookie.expiresDate];
-            [cookieStr appendString:strDate];
-        }
-
-
-        [cookieStr appendString:@"; domain="];
-        [cookieStr appendString:hostname];
-        [cookieStr appendString:@"; path="];
-        [cookieStr appendString:cookie.path];
-
-
-        if (cookie.isSecure) {
-            [cookieStr appendString:@"; secure"];
-        }
-
-        if (cookie.isHTTPOnly) {
-            [cookieStr appendString:@"; httponly"];
-        }
-        [cookies addObject:cookieStr];
-    }
-    return cookies;
-}
-
 + (void) enableProgressReport:(NSString *) taskId config:(RNFetchBlobProgress *)config
 {
     if(progressTable == nil)
         // # 153 get cookies
         if(response.URL != nil)
         {
+            NSHTTPCookieStorage * cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
             NSArray<NSHTTPCookie *> * cookies = [NSHTTPCookie cookiesWithResponseHeaderFields: headers forURL:response.URL];
             if(cookies != nil && [cookies count] > 0) {
-                [cookiesTable setObject:cookies forKey:response.URL.host];
+                [cookieStore setCookies:cookies forURL:response.URL mainDocumentURL:nil];
             }
         }
 
     }
 }
 
+# pragma mark - cookies handling API
+
++ (NSDictionary *) getCookies:(NSString *) domain
+{
+    NSMutableDictionary * result = [NSMutableDictionary new];
+    NSHTTPCookieStorage * cookieStore = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+    for(NSHTTPCookie * cookie in [cookieStore cookies])
+    {
+        NSString * cDomain = [cookie domain];
+        if([result objectForKey:cDomain] == nil)
+        {
+            [result setObject:[NSMutableArray new] forKey:cDomain];
+        }
+        if([cDomain isEqualToString:domain] || [domain length] == 0)
+        {
+            NSMutableString * cookieStr = [[NSMutableString alloc] init];
+            cookieStr = [[self class] getCookieString:cookie];
+            NSMutableArray * ary = [result objectForKey:cDomain];
+            [ary addObject:cookieStr];
+            [result setObject:ary forKey:cDomain];
+        }
+    }
+    return result;
+}
+
+// remove cookies for given domain, if domain is empty remove all cookies in shared cookie storage.
++ (void) removeCookies:(NSString *) domain error:(NSError **)error
+{
+    @try
+    {
+        NSHTTPCookieStorage * cookies = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+        for(NSHTTPCookie * cookie in [cookies cookies])
+        {
+            BOOL shouldRemove = domain == nil || [domain length] < 1 || [[cookie domain] isEqualToString:domain];
+            if(shouldRemove)
+            {
+                [cookies deleteCookie:cookie];
+            }
+        }
+    }
+    @catch(NSError * err)
+    {
+        *error = err;
+    }
+}
+
+// convert NSHTTPCookie to string
++ (NSString *) getCookieString:(NSHTTPCookie *) cookie
+{
+    NSMutableString * cookieStr = [[NSMutableString alloc] init];
+    [cookieStr appendString:cookie.name];
+    [cookieStr appendString:@"="];
+    [cookieStr appendString:cookie.value];
+    
+    if(cookie.expiresDate == nil) {
+        [cookieStr appendString:@"; max-age=0"];
+    }
+    else {
+        [cookieStr appendString:@"; expires="];
+        NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
+        [dateFormatter setDateFormat:@"EEE, dd MM yyyy HH:mm:ss ZZZ"];
+        NSString *strDate = [dateFormatter stringFromDate:cookie.expiresDate];
+        [cookieStr appendString:strDate];
+    }
+    
+    
+    [cookieStr appendString:@"; domain="];
+    [cookieStr appendString: [cookie domain]];
+    [cookieStr appendString:@"; path="];
+    [cookieStr appendString:cookie.path];
+    
+    
+    if (cookie.isSecure) {
+        [cookieStr appendString:@"; secure"];
+    }
+    
+    if (cookie.isHTTPOnly) {
+        [cookieStr appendString:@"; httponly"];
+    }
+    return cookieStr;
+
+}
+
 + (void) cancelRequest:(NSString *)taskId
 {
     NSURLSessionDataTask * task = [taskTable objectForKey:taskId];

ios/RNFetchBlobReqBuilder.m

     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         NSMutableData * blobData;
         long size = -1;
-        // if method is POST or PUT, convert data string format
-        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
+        // if method is POST, PUT or PATCH, convert data string format
+        if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"] || [[method lowercaseString] isEqualToString:@"patch"]) {
             // generate octet-stream body
             if(body != nil) {
                 __block NSString * cType = [[self class] getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                 RCTLogWarn(@"RNFetchBlob multipart request builder has found a field without `data` or `name` property, the field will be removed implicitly.");
                 return;
             }
-            contentType = contentType == nil ? @"application/octet-stream" : contentType;
+
             // field is a text field
             if([field valueForKey:@"filename"] == nil || content == nil) {
+                contentType = contentType == nil ? @"text/plain" : contentType;
                 [formData appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
                 [formData appendData:[[NSString stringWithFormat:@"Content-Disposition: form-data; name=\"%@\"\r\n", name] dataUsingEncoding:NSUTF8StringEncoding]];
-                [formData appendData:[[NSString stringWithFormat:@"Content-Type: text/plain\r\n\r\n"] dataUsingEncoding:NSUTF8StringEncoding]];
+                [formData appendData:[[NSString stringWithFormat:@"Content-Type: %@\r\n\r\n", contentType] dataUsingEncoding:NSUTF8StringEncoding]];
                 [formData appendData:[[NSString stringWithFormat:@"%@\r\n", content] dataUsingEncoding:NSUTF8StringEncoding]];
             }
             // field contains a file
             else {
+                contentType = contentType == nil ? @"application/octet-stream" : contentType;
                 NSMutableData * blobData;
                 if(content != nil)
                 {