Merge branch '0.8.0' into issue_44

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

     }
 
 }
-

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

 
 import okhttp3.MediaType;
 import okhttp3.RequestBody;
+import okhttp3.FormBody;
 import okio.Buffer;
 import okio.BufferedSink;
 import okio.ForwardingSink;
             case SingleFile:
                 writeOctetData(sink);
                 break;
+			case Encoded:
+				writeEncodedData(sink);
+				break;
         }
         buffer.flush();
     }
 
-    private void writeFormData(BufferedSink sink) throws IOException {
+	private void writeFormData(BufferedSink sink) throws IOException {
         String boundary = "RNFetchBlob-" + mTaskId;
         ArrayList<FormField> fields = countFormDataLength();
         ReactApplicationContext ctx = RNFetchBlob.RCTContext;
 
     }
 
+
+	/**
+     * Write form-encoded data to request body
+     * @param sink
+     */
+	 // This is NOT working since sink.write, creates a Transfer-Encoding: chunked
+	 // header, which is not expected from servers
+	private void writeEncodedData(BufferedSink sink) throws IOException {
+		FormBody.Builder body = new FormBody.Builder();
+
+		// String[] pairs = rawBody.split("&");
+		// for ( String pair : pairs ) {
+		// 	String[] kv = pair.split("=");
+		// 	body.add(kv[0], kv[1]);
+		// }
+		// body.build().writeTo(sink);
+
+		// String header = "Content-Disposition: form-data; \r\n";
+		// String header = "Content-Type: application/x-www-form-urlencoded\r\n\r\n";
+		// sink.write(header.getBytes());
+		// byte[] fieldData = field.data.getBytes();
+		// bytesWritten += fieldData.length;
+		sink.write(rawBody.getBytes());
+
+
+	}
+
     /**
      * Pipe input stream to request body output stream
      * @param stream    The input stream

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

     public static final String FILE_PREFIX = "RNFetchBlob-file://";
     public static final MediaType MIME_OCTET = MediaType.parse("application/octet-stream");
     public static final MediaType MIME_MULTIPART = MediaType.parse("multipart/form-data");
+	public static final MediaType MIME_ENCODED = MediaType.parse("application/x-www-form-urlencoded");
     public static final String FILE_PREFIX_BUNDLE_ASSET = "bundle-assets://";
     public static final String FILE_PREFIX_CONTENT = "content://";
-
 }

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

     }
 
 }
-
-

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

 import android.database.Cursor;
 import android.net.Uri;
 import android.util.Base64;
+import android.util.Log;
 
 import com.RNFetchBlob.Response.RNFetchBlobDefaultResp;
 import com.RNFetchBlob.Response.RNFetchBlobFileResp;
 import okhttp3.RequestBody;
 import okhttp3.Response;
 import okhttp3.ResponseBody;
+import okhttp3.FormBody;
 
 /**
  * Created by wkh237 on 2016/6/21.
 
     enum RequestType  {
         Form,
+		Encoded,
         SingleFile,
         WithoutBody,
         Others
         else
             responseType = ResponseType.KeepInMemory;
 
-        if (body != null)
+        if (body != null && headers.hasKey("content-type") && "application/x-www-form-urlencoded".equals(headers.getString("content-type")))
+			requestType = RequestType.Encoded;
+		else if (body != null)
             requestType = RequestType.SingleFile;
         else if (arrayBody != null)
             requestType = RequestType.Form;
 
         // find cached result if `key` property exists
         String cacheKey = this.taskId;
-//        if (this.options.key != null) {
-//            cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
-//            if (cacheKey == null) {
-//                cacheKey = this.taskId;
-//            }
-//
-//            File file = new File(RNFetchBlobFS.getTmpPath(ctx, cacheKey));
-//            if (file.exists()) {
-//                callback.invoke(null, file.getAbsolutePath());
-//                return;
-//            }
-//        }
+		String ext = this.options.appendExt != "" ? "." + this.options.appendExt : "";
+
+       	if (this.options.key != null) {
+           cacheKey = RNFetchBlobUtils.getMD5(this.options.key);
+           if (cacheKey == null) {
+               cacheKey = this.taskId;
+           }
+
+           File file = new File(RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext);
+
+           if (file.exists()) {
+               callback.invoke(null, file.getAbsolutePath());
+               return;
+           }
+       }
 
         if(this.options.path != null)
             this.destPath = this.options.path;
         else if(this.options.fileCache == true)
-            this.destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey);
+            this.destPath = RNFetchBlobFS.getTmpPath(RNFetchBlob.RCTContext, cacheKey) + ext;
 
         OkHttpClient.Builder clientBuilder;
 
                             MediaType.parse("multipart/form-data; boundary=RNFetchBlob-" + taskId)
                     ));
                     break;
+				case Encoded:
+					// rawRequestBody has an expected format of
+					// key1=value1&key2=value&...
+					FormBody.Builder formBuilder = new FormBody.Builder();
+
+					String[] pairs = rawRequestBody.split("&");
+					for ( String pair : pairs ) {
+						String[] kv = pair.split("=");
+						formBuilder.add(kv[0], kv[1]);
+					}
+
+					RequestBody body = formBuilder.build();
+
+					builder.method(method, body);
+					break;
                 case WithoutBody:
                     builder.method(method, null);
                     break;

src/ios/RNFetchBlob/RNFetchBlob.m

                   form:(NSArray *)form
                   callback:(RCTResponseSenderBlock)callback)
 {
-    
+
     [RNFetchBlobReqBuilder buildMultipartRequest:options taskId:taskId method:method url:url headers:headers form:form onComplete:^(NSURLRequest *req, long bodyLength) {
         // send HTTP request
         RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
         [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
         utils = nil;
     }];
-    
+
 }
 
 // Fetch blob data request
                   headers:(NSDictionary *)headers
                   body:(NSString *)body callback:(RCTResponseSenderBlock)callback)
 {
-    [RNFetchBlobReqBuilder buildOctetRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
-        // send HTTP request
-        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
-        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
-        utils = nil;
-    }];
-    
+	NSString *cType = [headers valueForKey:"content-type"]
+	if (cType != nil && cType == @"application/x-www-form-urlencoded") {
+		[RNFetchBlobReqBuilder buildEncodedRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
+	        // send HTTP request
+	        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+	        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+	        utils = nil;
+	    }];
+	} else {
+		[RNFetchBlobReqBuilder buildOctetRequest:options taskId:taskId method:method url:url headers:headers body:body onComplete:^(NSURLRequest *req, long bodyLength) {
+	        // send HTTP request
+	        RNFetchBlobNetwork * utils = [[RNFetchBlobNetwork alloc] init];
+	        [utils sendRequest:options contentLength:bodyLength bridge:self.bridge taskId:taskId withRequest:req callback:callback];
+	        utils = nil;
+	    }];
+	}
 }
 
 RCT_EXPORT_METHOD(createFile:(NSString *)path data:(NSString *)data encoding:(NSString *)encoding callback:(RCTResponseSenderBlock)callback) {
-    
+
     NSFileManager * fm = [NSFileManager defaultManager];
     NSData * fileContent = nil;
-    
+
     if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
         fileContent = [[NSData alloc] initWithData:[data dataUsingEncoding:NSUTF8StringEncoding allowLossyConversion:YES]];
     }
     else {
         fileContent = [[NSData alloc] initWithData:[data dataUsingEncoding:NSASCIIStringEncoding allowLossyConversion:YES]];
     }
-    
+
     BOOL success = [fm createFileAtPath:path contents:fileContent attributes:NULL];
     if(success == YES)
         callback(@[[NSNull null]]);
     else
         callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
-    
+
 }
 
 // method for create file with ASCII content
 RCT_EXPORT_METHOD(createFileASCII:(NSString *)path data:(NSArray *)dataArray callback:(RCTResponseSenderBlock)callback) {
-    
+
     NSFileManager * fm = [NSFileManager defaultManager];
     NSMutableData * fileContent = [NSMutableData alloc];
     // prevent stack overflow, alloc on heap
         callback(@[[NSNull null]]);
     else
         callback(@[[NSString stringWithFormat:@"failed to create new file at path %@ please ensure the folder exists"]]);
-    
+
 }
 
 
     BOOL exists = NO;
     exists = [[NSFileManager defaultManager] fileExistsAtPath:path isDirectory: &isDir];
     callback(@[@(exists), @(isDir)]);
-    
+
 }
 
 RCT_EXPORT_METHOD(writeFile:(NSString *)path encoding:(NSString *)encoding data:(NSString *)data append:(BOOL)append resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
 RCT_EXPORT_METHOD(removeSession:(NSArray *)paths callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     NSString * tmpPath = nil;
-    
+
     for(NSString * path in paths) {
         [[NSFileManager defaultManager] removeItemAtPath:path error:&error];
         if(error != nil) {
         }
     }
     callback(@[[NSNull null]]);
-    
+
 }
 
 RCT_EXPORT_METHOD(ls:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     }
     NSError * error = nil;
     NSArray * result = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:&error];
-    
+
     if(error == nil)
         callback(@[[NSNull null], result == nil ? [NSNull null] :result ]);
     else
         callback(@[[error localizedDescription], [NSNull null]]);
-    
+
 }
 
 RCT_EXPORT_METHOD(stat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     BOOL exist = nil;
     BOOL isDir = nil;
     NSError * error = nil;
-    
+
     path = [RNFetchBlobFS getPathOfAsset:path];
-    
+
     exist = [fm fileExistsAtPath:path isDirectory:&isDir];
     if(exist == NO) {
         callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not exist", path]]);
         return ;
     }
     NSData * res = [RNFetchBlobFS stat:path error:&error];
-    
+
     if(error == nil)
         callback(@[[NSNull null], res]);
     else
         callback(@[[error localizedDescription], [NSNull null]]);
-    
+
 }
 
 RCT_EXPORT_METHOD(lstat:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
     NSFileManager* fm = [NSFileManager defaultManager];
     BOOL exist = nil;
     BOOL isDir = nil;
-    
+
     path = [RNFetchBlobFS getPathOfAsset:path];
-    
+
     exist = [fm fileExistsAtPath:path isDirectory:&isDir];
     if(exist == NO) {
         callback(@[[NSString stringWithFormat:@"failed to list path `%@` for it is not exist or it is not exist", path]]);
     }
     NSError * error = nil;
     NSArray * files = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:path error:&error];
-    
+
     NSMutableArray * res = [[NSMutableArray alloc] init];
     if(isDir == YES) {
         for(NSString * p in files) {
     else {
         [res addObject:[RNFetchBlobFS stat:path error:&error]];
     }
-    
+
     if(error == nil)
         callback(@[[NSNull null], res == nil ? [NSNull null] :res ]);
     else
         callback(@[[error localizedDescription], [NSNull null]]);
-    
+
 }
 
 RCT_EXPORT_METHOD(cp:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     path = [RNFetchBlobFS getPathOfAsset:path];
     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]);
-    
+
 }
 
 RCT_EXPORT_METHOD(mv:(NSString *)path toPath:(NSString *)dest callback:(RCTResponseSenderBlock) callback) {
     NSError * error = nil;
     BOOL result = [[NSFileManager defaultManager] moveItemAtURL:[NSURL fileURLWithPath:path] toURL:[NSURL fileURLWithPath:dest] error:&error];
-    
+
     if(error == nil)
         callback(@[[NSNull null], @YES]);
     else
         callback(@[[error localizedDescription], @NO]);
-    
+
 }
 
 RCT_EXPORT_METHOD(mkdir:(NSString *)path callback:(RCTResponseSenderBlock) callback) {
 }
 
 RCT_EXPORT_METHOD(readFile:(NSString *)path encoding:(NSString *)encoding resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
-    
+
     [RNFetchBlobFS readFile:path encoding:encoding resolver:resolve rejecter:reject onComplete:nil];
 })
 
 RCT_EXPORT_METHOD(readStream:(NSString *)path withEncoding:(NSString *)encoding bufferSize:(int)bufferSize) {
-    
+
     RNFetchBlobFS *fileStream = [[RNFetchBlobFS alloc] initWithBridgeRef:self.bridge];
     if(bufferSize == nil) {
         if([[encoding lowercaseString] isEqualToString:@"base64"])
 }
 
 RCT_EXPORT_METHOD(getEnvironmentDirs:(RCTResponseSenderBlock) callback) {
-    
+
     callback(@[
                [RNFetchBlobFS getDocumentDir],
                [RNFetchBlobFS getCacheDir],
 RCT_EXPORT_METHOD(cancelRequest:(NSString *)taskId callback:(RCTResponseSenderBlock)callback) {
     [RNFetchBlobNetwork cancelRequest:taskId];
     callback(@[[NSNull null], taskId]);
-    
+
 }
 
 #pragma mark RNFetchBlob private methods

src/ios/RNFetchBlobConst.h

 extern NSString *const CONFIG_FILE_EXT;
 extern NSString *const CONFIG_TRUSTY;
 extern NSString *const CONFIG_INDICATOR;
+extern NSString *const CONFIG_KEY;
 
 // fs events
 extern NSString *const FS_EVENT_DATA;

src/ios/RNFetchBlobConst.m

 extern NSString *const CONFIG_FILE_EXT = @"appendExt";
 extern NSString *const CONFIG_TRUSTY = @"trusty";
 extern NSString *const CONFIG_INDICATOR = @"indicator";
+extern NSString *const CONFIG_KEY = "@key";
 
 extern NSString *const EVENT_STATE_CHANGE = @"RNFetchBlobState";
 extern NSString *const MSG_EVENT = @"RNFetchBlobMessage";

src/ios/RNFetchBlobNetwork.m

 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
+#import <CommonCrypto/CommonDigest.h>
 
 ////////////////////////////////////////
 //
 
 // removing case from headers
 + (NSMutableDictionary *) normalizeHeaders:(NSDictionary *)headers {
-    
+
     NSMutableDictionary * mheaders = [[NSMutableDictionary alloc]init];
     for(NSString * key in headers) {
         [mheaders setValue:[headers valueForKey:key] forKey:[key lowercaseString]];
     }
-    
+
     return mheaders;
 }
 
+- (NSString *)md5 {
+    const char* str = [self UTF8String];
+    unsigned char result[CC_MD5_DIGEST_LENGTH];
+    CC_MD5(str, (CC_LONG)strlen(str), result);
+
+    NSMutableString *ret = [NSMutableString stringWithCapacity:CC_MD5_DIGEST_LENGTH*2];
+    for(int i = 0; i<CC_MD5_DIGEST_LENGTH; i++) {
+        [ret appendFormat:@"%02x",result[i]];
+    }
+    return ret;
+}
+
 // send HTTP request
 - (void) sendRequest:(NSDictionary  * _Nullable )options
        contentLength:(long) contentLength
     self.expectedBytes = 0;
     self.receivedBytes = 0;
     self.options = options;
-    
+
     NSString * path = [self.options valueForKey:CONFIG_FILE_PATH];
     NSString * ext = [self.options valueForKey:CONFIG_FILE_EXT];
+	NSString * key = [self.options valueForKey:CONFIG_KEY];
     NSURLSession * session;
-    
+
     bodyLength = contentLength;
-    
+
     // the session trust any SSL certification
 
     NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
     session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:[NSOperationQueue mainQueue]];
-    
+
     if(path != nil || [self.options valueForKey:CONFIG_USE_TEMP]!= nil)
     {
         respFile = YES;
+
+		NSString* cacheKey = taskId;
+		if (key != nil) {
+			cacheKey = [key md5];
+			if (cacheKey == nil) {
+				cacheKey = taskId;
+			}
+
+			destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
+            if ([[NSFileManager defaultManager] fileExistsAtPath:destPath]) {
+				callback([NSNull null], destPath]);
+                return;
+            }
+		}
+
         if(path != nil)
             destPath = path;
-        else
-            destPath = [RNFetchBlobFS getTempPath:taskId withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
+        // else
+        //     destPath = [RNFetchBlobFS getTempPath:cacheKey withExtension:[self.options valueForKey:CONFIG_FILE_EXT]];
     }
     else
     {
     NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
     [taskTable setValue:task forKey:taskId];
     [task resume];
-    
+
     // network status indicator
     if([[options objectForKey:CONFIG_INDICATOR] boolValue] == YES)
         [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
             }
          ];
     }
-    
+
     if(respFile == YES)
     {
         NSFileManager * fm = [NSFileManager defaultManager];
     {
         [writeStream write:[data bytes] maxLength:[data length]];
     }
-    
+
     [self.bridge.eventDispatcher
      sendDeviceEventWithName:@"RNFetchBlobProgress"
      body:@{
             @"total": [NSString stringWithFormat:@"%d", expectedBytes]
             }
      ];
-    
+
 }
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
 }
 
 //- (void) application:(UIApplication *)application handleEventsForBackgroundURLSession:(NSString *)identifier completionHandler:(void (^)())completionHandler {
-//    
+//
 //}
 
 //- (void) URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
     }
 }
 
-@end
+@end

src/ios/RNFetchBlobReqBuilder.h

                      body:(NSString *)body
                onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
 
++(void) buildEncodedRequest:(NSDictionary *)options
+                      taskId:(NSString *)taskId
+                      method:(NSString *)method
+                         url:(NSString *)url
+                     headers:(NSDictionary *)headers
+                        form:(NSString *)body
+                  onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
+
+
 @end
 
 #endif /* RNFetchBlobReqBuilder_h */

src/ios/RNFetchBlobReqBuilder.m

 
 @interface RNFetchBlobReqBuilder()
 {
-    
+
 }
 @end
 
     NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
     NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
     NSNumber * timeStampObj = [NSNumber numberWithDouble: timeStamp];
-    
+
     // generate boundary
     NSString * boundary = [NSString stringWithFormat:@"RNFetchBlob%d", timeStampObj];
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
             [request setAllHTTPHeaderFields:mheaders];
             onComplete(request, [formData length]);
         }];
-        
+
     });
 }
 
     NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
                                     initWithURL:[NSURL
                                                  URLWithString: encodedUrl]];
-    
+
     NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
     // move heavy task to another thread
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         if([[method lowercaseString] isEqualToString:@"post"] || [[method lowercaseString] isEqualToString:@"put"]) {
             // generate octet-stream body
             if(body != nil) {
-                
+
                 // when body is a string contains file path prefix, try load file from the path
                 if([body hasPrefix:FILE_PREFIX]) {
                     NSString * orgPath = [body substringFromIndex:[FILE_PREFIX length]];
                 
             }
         }
-        
+
         [request setHTTPMethod: method];
         [request setAllHTTPHeaderFields:mheaders];
-        
+
         onComplete(request, size);
     });
 }
 
++(void) buildEncodedRequest:(NSDictionary *)options
+                   taskId:(NSString *)taskId
+                   method:(NSString *)method
+                      url:(NSString *)url
+                  headers:(NSDictionary *)headers
+                     body:(NSString *)body
+               onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
+{
+	NSMutableData * formData = [[NSMutableData alloc] init];
+	[formData appendData:[[NSString stringWithFormat:@"%@", body] dataUsingEncoding:NSUTF8StringEncoding]];
+	onComplete(formData);
+}
+
+
 +(void) buildFormBody:(NSArray *)form boundary:(NSString *)boundary onComplete:(void(^)(NSData * formData))onComplete
 {
     NSMutableData * formData = [[NSMutableData alloc] init];
             }
             else
                 onComplete(formData);
-            
+
         };
         getFieldData([form objectAtIndex:i]);
     }