Fix url encoding issue #44

Fix missing content type handling #44

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

             case SingleFile:
                 writeOctetData(sink);
                 break;
-			case Encoded:
-				writeEncodedData(sink);
+            case AsIs:
+				writeRawData(sink);
 				break;
         }
         buffer.flush();
 
 
 	/**
-     * Write form-encoded data to request body
+     * Write data to request body as-is
      * @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;
+	private void writeRawData(BufferedSink sink) throws IOException {
 		sink.write(rawBody.getBytes());
-
-
 	}
 
     /**

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

 public class RNFetchBlobConst {
     public static final String EVENT_UPLOAD_PROGRESS = "RNFetchBlobProgress-upload";
     public static final String EVENT_PROGRESS = "RNFetchBlobProgress";
+    public static final String EVENT_HTTP_STATE = "RNFetchBlobState";
     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");

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

 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import java.io.ByteArrayInputStream;
 import java.io.File;
 import okhttp3.ResponseBody;
 import okhttp3.FormBody;
 import okhttp3.internal.framed.Header;
+import okhttp3.internal.http.OkHeaders;
 
 /**
  * Created by wkh237 on 2016/6/21.
 
     enum RequestType  {
         Form,
-		Encoded,
         SingleFile,
+        AsIs,
         WithoutBody,
         Others
     };
         this.rawRequestBody = body;
         this.rawRequestBodyArray = arrayBody;
 
-        if(this.options.fileCache == true || this.options.path != null)
+        if(this.options.fileCache || this.options.path != null)
             responseType = ResponseType.FileStorage;
         else
             responseType = ResponseType.KeepInMemory;
 
-        if (body != null && headers.hasKey("content-type") && "application/x-www-form-urlencoded".equals(headers.getString("content-type")))
-			requestType = RequestType.Encoded;
-		else if (body != null)
+
+		if (body != null)
             requestType = RequestType.SingleFile;
         else if (arrayBody != null)
             requestType = RequestType.Form;
             } catch (MalformedURLException e) {
                 e.printStackTrace();
             }
+
+            HashMap<String, String> mheaders = new HashMap<>();
             // set headers
             if (headers != null) {
                 ReadableMapKeySetIterator it = headers.keySetIterator();
                     String key = it.nextKey();
                     String value = headers.getString(key);
                     builder.header(key, value);
+                    mheaders.put(key,value);
                 }
             }
 
+            if(method.equalsIgnoreCase("post") || method.equalsIgnoreCase("put")) {
+                String cType = getHeaderIgnoreCases(mheaders, "content-type").toLowerCase();
+
+                if(cType == null) {
+                    builder.header("Content-Type", "application/octet-stream");
+                    requestType = RequestType.SingleFile;
+                }
+                if(rawRequestBody != null) {
+                    if(rawRequestBody.startsWith(RNFetchBlobConst.FILE_PREFIX)) {
+                        requestType = RequestType.SingleFile;
+                    }
+                    else if (cType.contains(";base64") || cType.startsWith("application/octet")) {
+                        requestType = RequestType.SingleFile;
+                    } else {
+                        requestType = RequestType.AsIs;
+                    }
+                }
+            }
+            else {
+                requestType = RequestType.WithoutBody;
+            }
+
+
             // set request body
             switch (requestType) {
                 case SingleFile:
                     builder.method(method, new RNFetchBlobBody(
                             taskId,
-                            RequestType.SingleFile,
+                            requestType,
                             rawRequestBody,
-                            RNFetchBlobConst.MIME_OCTET
+                            MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type"))
+                    ));
+                    break;
+                case AsIs:
+                    builder.method(method, new RNFetchBlobBody(
+                            taskId,
+                            requestType,
+                            rawRequestBody,
+                            MediaType.parse(getHeaderIgnoreCases(mheaders, "content-type"))
                     ));
                     break;
                 case Form:
                     builder.method(method, new RNFetchBlobBody(
                             taskId,
-                            RequestType.Form,
+                            requestType,
                             rawRequestBodyArray,
                             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;
      * @param resp OkHttp response object
      */
     private void done(Response resp) {
+        emitStateEvent(getResponseInfo(resp));
         switch (responseType) {
             case KeepInMemory:
                 try {
         return headers.get(field.toLowerCase()) == null ? "" : headers.get(field.toLowerCase());
     }
 
-    /**
-     * Build request body by given string
-     * @param body Content of request body in UTF8 string format.
-     * @return
-     */
-    RequestBody buildRawBody(String body) {
-        if(body != null) {
-            this.contentType = MediaType.parse(options.mime);
-            return RequestBody.create(this.contentType, body);
-        }
-        return null;
+    private String getHeaderIgnoreCases(HashMap<String,String> headers, String field) {
+        String val = headers.get(field);
+        if(val != null) return val;
+        return headers.get(field.toLowerCase()) == null ? "" : headers.get(field.toLowerCase());
+    }
 
+    private void emitStateEvent(WritableMap args) {
+        RNFetchBlob.RCTContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit(RNFetchBlobConst.EVENT_HTTP_STATE, args);
     }
 
     @Override
                         cursor.moveToFirst();
                         String filePath = cursor.getString(0);
                         cursor.close();
-                        this.callback.invoke(null, filePath);
+                        this.callback.invoke(null, null, filePath);
                     }
                     else
-                        this.callback.invoke(null, null);
+                        this.callback.invoke(null, null, null);
                 }
             }
         }

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

  * Created by wkh237 on 2016/7/11.
  */
 public class RNFetchBlobUtils {
+
     public static String getMD5(String input) {
         String result = null;
 

src/fs.js

 
 function appendFile(path:string, data:string | Array<number>, encoding:?string):Promise {
   encoding = encoding || 'utf8'
-  console.log('fs append file', data, encoding)
   if(typeof path !== 'string')
     return Promise.reject('Invalid argument "path" ')
   if(encoding.toLocaleLowerCase() === 'ascii') {

src/index.js

     }
 
     let req = RNFetchBlob[nativeMethodName]
+
     req(options, taskId, method, url, headers || {}, body, (err, info, data) => {
 
       // task done, remove event listener
           if(options.session)
             session(options.session).add(data)
         }
-        info = Object.assign({}, info, { rnfbEncode })
+        info = info || {}
+        info.rnfbEncode = rnfbEncode
 
         resolve(new FetchBlobResponse(taskId, info, data))
       }
     stateEvent.remove()
     RNFetchBlob.cancelRequest(taskId, fn)
   }
+  promise.taskId = taskId
 
   return promise
 

src/ios/RNFetchBlobFS.m

             return;
         }
         else {
-            content = [data dataUsingEncoding:NSUTF8StringEncoding];
+            content = [data dataUsingEncoding:NSISOLatin1StringEncoding];
         }
         if(append == YES) {
             [fileHandle seekToEndOfFile];

src/ios/RNFetchBlobReqBuilder.m

                          form:(NSArray *)form
                    onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
 {
-    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+    //    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+    NSString * encodedUrl = url;
+    
     // send request
     NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString: encodedUrl]];
     NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
                      body:(NSString *)body
                onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete
 {
-    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+//    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+    NSString * encodedUrl = url;
     // send request
     NSMutableURLRequest *request = [[NSMutableURLRequest alloc]
-                                    initWithURL:[NSURL
-                                                 URLWithString: encodedUrl]];
+                                    initWithURL:[NSURL URLWithString: encodedUrl]];
 
     NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
     // move heavy task to another thread
                     
                     NSString * cType = [[self class]getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                     // when content-type is application/octet* decode body string using BASE64 decoder
-                    if([[cType lowercaseString] hasPrefix:@"application/octet"])
+                    if([[cType lowercaseString] hasPrefix:@"application/octet"] || [[cType lowercaseString] containsString:@";base64"])
                     {
                         blobData = [[NSData alloc] initWithBase64EncodedString:body options:0];
                         [request setHTTPBody:blobData];

src/polyfill/XMLHttpRequest.js

 
   getResponseHeader(field:string):string | null {
     log.verbose('XMLHttpRequest get header', field)
-    if(!this.responseHeaders)
+    if(!this._responseHeaders)
       return null
     return this.responseHeaders[field] || null
 
   }
 
   getAllResponseHeaders():string | null {
-    log.verbose('XMLHttpRequest get all headers')
-    if(!this.responseHeaders)
+    log.verbose('XMLHttpRequest get all headers',this._task.taskId, this._responseHeaders)
+    if(!this._responseHeaders)
       return null
     let result = ''
     let respHeaders = this.responseHeaders
   }
 
   _headerReceived(e) {
-    log.verbose('header received ', e)
+    log.verbose('header received ', this._task.taskId, e)
     this.responseURL = this._url
     if(e.state === "2") {
-      this.readyState = XMLHttpRequest.HEADERS_RECEIVED
-      this.responseHeaders = e.headers
+      this._readyState = XMLHttpRequest.HEADERS_RECEIVED
+      this._responseHeaders = e.headers
       this._responseText = e.status
       this._responseType = e.respType || ''
-      this.status = Math.floor(e.status)
+      this._status = Math.floor(e.status)
     }
   }
 
   }
 
   _onDone(resp) {
-    log.verbose('XMLHttpRequest done', this)
+    log.verbose('XMLHttpRequest done', this._task.taskId, this)
     this.statusText = '200 OK'
     this._status = 200
     switch(resp.type) {
   }
 
   get responseHeaders() {
-    log.verbose('get responseHeaders', this._responseHeaders)
+    log.verbose('get responseHeaders', this._task.taskId, this._responseHeaders)
     return this._responseHeaders
   }