Add XMLHttpRequest automatic response data handling strategy #44

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

     public Boolean trusty;
     public String key;
     public String mime;
+    public Boolean auto;
 
     RNFetchBlobConfig(ReadableMap options) {
         if(options == null)
         }
         this.key = options.hasKey("key") ? options.getString("key") : null;
         this.mime = options.hasKey("contentType") ? options.getString("contentType") : null;
+        this.auto = options.hasKey("auto") ? options.getBoolean("auto") : false;
     }
 
 }

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

 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
         switch (responseType) {
             case KeepInMemory:
                 try {
-                    byte [] b = resp.body().bytes();
-                    callback.invoke(null, getResponseInfo(resp), android.util.Base64.encodeToString(b,Base64.NO_WRAP));
+                    // For XMLHttpRequest, automatic response data storing strategy, when response
+                    // header is not `application/json` or `text/plain`, write response data to
+                    // file system.
+                    if(isBlobResponse(resp) && options.auto == true) {
+                        String dest = RNFetchBlobFS.getTmpPath(ctx, taskId);
+                        InputStream ins = resp.body().byteStream();
+                        FileOutputStream os = new FileOutputStream(new File(dest));
+                        byte [] buffer = new byte[10240];
+                        int read = ins.read(buffer);
+                        os.write(buffer,0,read);
+                        while(read > 0) {
+                            os.write(buffer,0,read);
+                            read = ins.read(buffer);
+                        }
+                        ins.close();
+                        os.close();
+                        WritableMap info = getResponseInfo(resp);
+                        callback.invoke(null, info, dest);
+                    }
+                    else {
+                        byte[] b = resp.body().bytes();
+                        callback.invoke(null, getResponseInfo(resp), android.util.Base64.encodeToString(b, Base64.NO_WRAP));
+                    }
                 } catch (IOException e) {
                     callback.invoke("RNFetchBlob failed to encode response data to BASE64 string.", null);
                 }
         return info;
     }
 
+    private boolean isBlobResponse(Response resp) {
+        Headers h = resp.headers();
+        boolean isText = !getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("text/plain");
+        boolean isJSON = !getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("application/json");
+        return  !(isJSON || isText);
+    }
+
     private String getHeaderIgnoreCases(Headers headers, String field) {
         String val = headers.get(field);
         if(val != null) return val;

src/index.js

       else {
         let rnfbEncode = 'base64'
         // response data is saved to storage
-        if(options.path || options.fileCache || options.addAndroidDownloads || options.key) {
+        if(options.path || options.fileCache || options.addAndroidDownloads
+          || options.key || options.auto && info.respType === 'blob') {
           rnfbEncode = 'path'
           if(options.session)
             session(options.session).add(data)

src/ios/RNFetchBlobNetwork.m

             else
             {
                 respType = @"blob";
+                // for XMLHttpRequest, switch response data handling strategy automatically
+                if([options valueForKey:@"auto"] == YES) {
+                    respFile = YES;
+                    destPath = [RNFetchBlobFS getTempPath:taskId withExtension:@""];
+                }
             }
         }
         else

src/polyfill/XMLHttpRequest.js

   _statusText : string;
   _timeout : number = 0;
   _upload : XMLHttpRequestEventTarget;
+  _sendFlag : boolean = false;
 
   // RNFetchBlob compatible data structure
   _config : RNFetchBlobConfig;
    * @param  {any} body Body in RNfetchblob flavor
    */
   send(body) {
+    this._sendFlag = true
     log.verbose('XMLHttpRequest send ', body)
     let {_method, _url, _headers } = this
     log.verbose('sending request with args', _method, _url, _headers, body)
     if(this.onloadstart)
       this.onloadstart()
 
-    this._task = RNFetchBlob.fetch(_method, _url, _headers, body)
+    this._task = RNFetchBlob.config({ auto: true })
+                            .fetch(_method, _url, _headers, body)
     this._task
         .stateChange(this._headerReceived.bind(this))
         .uploadProgress(this._progressEvent.bind(this))
 
   setRequestHeader(name, value) {
     log.verbose('XMLHttpRequest set header', name, value)
+    if(this._readyState !== OPENED && this._sendFlag) {
+      throw `InvalidStateError : Calling setRequestHeader in wrong state  ${this._readyState}`
+    }
+    if(/[^\u0000-\u00ff]/.test(name) || typeof name !== 'string') {
+      throw `TypeError : Invalid header field name ${name}`
+    }
     this._headers[name] = value
   }
 

src/types.js

   state : number,
   headers : any,
   status : number,
+  respType : 'text' | 'blob' | '' | 'json'
   rnfbEncode : 'path' | 'base64' | 'ascii' | 'utf8'
 }