Fix XMLHttpRequest module bugs #44

Add Event and ProgressEvent class #44

Add timeout support #44

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

     public String key;
     public String mime;
     public Boolean auto;
+    public long timeout = -1;
 
     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;
+        if(options.hasKey("timeout")) {
+            this.timeout = options.getInt("timeout");
+        }
     }
 
 }

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

 import java.io.IOException;
 import java.io.InputStream;
 import java.net.MalformedURLException;
+import java.net.SocketTimeoutException;
 import java.net.URL;
 import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
 
 import okhttp3.Call;
 import okhttp3.Headers;
     long downloadManagerId;
     RequestType requestType;
     ResponseType responseType;
+    boolean timeout = false;
 
     public RNFetchBlobReq(ReadableMap options, String taskId, String method, String url, ReadableMap headers, String body, ReadableArray arrayBody, final Callback callback) {
         this.method = method;
             clientBuilder.addInterceptor(new Interceptor() {
                 @Override
                 public Response intercept(Chain chain) throws IOException {
-                Response originalResponse = chain.proceed(req);
-                    ResponseBody extended;
-                switch (responseType) {
-                    case KeepInMemory:
-                        extended = new RNFetchBlobDefaultResp(
-                                RNFetchBlob.RCTContext,
-                                taskId,
-                                originalResponse.body());
-                        break;
-                    case FileStorage:
-                        extended = new RNFetchBlobFileResp(
-                                RNFetchBlob.RCTContext,
-                                taskId,
-                                originalResponse.body(),
-                                destPath);
-                        break;
-                    default:
-                        extended = new RNFetchBlobDefaultResp(
-                                RNFetchBlob.RCTContext,
-                                taskId,
-                                originalResponse.body());
-                        break;
-                }
-                return originalResponse.newBuilder().body(extended).build();
+                    try {
+                        Response originalResponse = chain.proceed(req);
+                        ResponseBody extended;
+                        switch (responseType) {
+                            case KeepInMemory:
+                                extended = new RNFetchBlobDefaultResp(
+                                        RNFetchBlob.RCTContext,
+                                        taskId,
+                                        originalResponse.body());
+                                break;
+                            case FileStorage:
+                                extended = new RNFetchBlobFileResp(
+                                        RNFetchBlob.RCTContext,
+                                        taskId,
+                                        originalResponse.body(),
+                                        destPath);
+                                break;
+                            default:
+                                extended = new RNFetchBlobDefaultResp(
+                                        RNFetchBlob.RCTContext,
+                                        taskId,
+                                        originalResponse.body());
+                                break;
+                        }
+                        return originalResponse.newBuilder().body(extended).build();
+                    } catch(SocketTimeoutException ex) {
+                        timeout = true;
+                    }
+                    return chain.proceed(chain.request());
                 }
             });
+            
+            if(options.timeout != -1) {
+                clientBuilder.connectTimeout(options.timeout, TimeUnit.SECONDS);
+            }
 
             OkHttpClient client = clientBuilder.build();
             Call call = client.newCall(req);
         info.putInt("status", resp.code());
         info.putString("state", "2");
         info.putString("taskId", this.taskId);
+        info.putBoolean("timeout", timeout);
         WritableMap headers = Arguments.createMap();
         for(int i =0;i< resp.headers().size();i++) {
             headers.putString(resp.headers().name(i), resp.headers().value(i));
         }
         info.putMap("headers", headers);
         Headers h = resp.headers();
-        if(getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("text/plain"))
-        {
+        if(getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("text/plain")) {
             info.putString("respType", "text");
         }
-        else if(getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("application/json"))
-        {
+        else if(getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("application/json")) {
             info.putString("respType", "json");
         }
-        else if(getHeaderIgnoreCases(h, "content-type").length() < 1)
-        {
+        else if(getHeaderIgnoreCases(h, "content-type").length() < 1) {
             info.putString("respType", "blob");
         }
-        else
-        {
+        else {
             info.putString("respType", "text");
         }
         return info;
 
     private boolean isBlobResponse(Response resp) {
         Headers h = resp.headers();
-        boolean isText = !getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("text/plain");
+        boolean isText = !getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("text/");
         boolean isJSON = !getHeaderIgnoreCases(h, "content-type").equalsIgnoreCase("application/json");
         return  !(isJSON || isText);
     }

src/index.js

 import fs from './fs'
 import getUUID from './utils/uuid'
 import base64 from 'base-64'
+import polyfill from './polyfill'
 const {
   RNFetchBlobSession,
   readStream,
   mv,
   cp
 } = fs
-import polyfill from './polyfill'
 
 const Blob = polyfill.Blob
 const emitter = DeviceEventEmitter
       subscriptionUpload.remove()
       stateEvent.remove()
       if(err)
-        reject(new Error(err, data))
+        reject(new Error(err, info))
       else {
         let rnfbEncode = 'base64'
         // response data is saved to storage
         }
         info = info || {}
         info.rnfbEncode = rnfbEncode
-
         resolve(new FetchBlobResponse(taskId, info, data))
       }
+
     })
 
   })
       return this.respInfo
     }
     /**
-     * Convert result to javascript Blob object.
-     * @param  {string} contentType MIME type of the blob object.
-     * @param  {number} sliceSize   Slice size.
-     * @return {blob}             Return Blob object.
+     * Convert result to javascript RNFetchBlob object.
+     * @return {Promise<Blob>} Return a promise resolves Blob object.
      */
-    this.blob = (contentType:string, sliceSize:number) => {
-      console.warn('FetchBlobResponse.blob() is deprecated and has no funtionality.')
-      return this
+    this.blob = ():Promise<Blob> => {
+      return new Promise((resolve, reject) => {
+        if(this.type === 'base64') {
+          try {
+            let b = new polyfill.Blob(this.data, 'application/octet-stream;BASE64')
+            b.onCreated(() => {
+              console.log('####', b)
+              resolve(b)
+            })
+          } catch(err) {
+            reject(err)
+          }
+        }
+      })
     }
     /**
      * Convert result to text.

src/ios/RNFetchBlobNetwork.m

 #import "RNFetchBlobFS.h"
 #import "RNFetchBlobNetwork.h"
 #import "RNFetchBlobConst.h"
+#import "RNFetchBlobReqBuilder.h"
 #import <CommonCrypto/CommonDigest.h>
 
 ////////////////////////////////////////
     // the session trust any SSL certification
 
     NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration defaultSessionConfiguration];
+    if([options valueForKey:@"timeout"] != nil)
+    {
+        defaultConfigObject.timeoutIntervalForRequest = [[options valueForKey:@"timeout"] floatValue];
+    }
     session = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue:taskQueue];
-
+    
     if(path != nil || [self.options valueForKey:CONFIG_USE_TEMP]!= nil)
     {
         respFile = YES;
     if ([response respondsToSelector:@selector(allHeaderFields)])
     {
         NSDictionary *headers = [httpResponse allHeaderFields];
-        NSString * respType = [[headers valueForKey:@"Content-Type"] lowercaseString];
+        NSString * respType = [[RNFetchBlobReqBuilder getHeaderIgnoreCases:@"content-type"
+                                                               fromHeaders:headers]
+                               lowercaseString];
         if([headers valueForKey:@"Content-Type"] != nil)
         {
-            if([respType containsString:@"text/plain"])
+            if([respType containsString:@"text/"])
             {
                 respType = @"text";
             }
                      @"state": @"2",
                      @"headers": headers,
                      @"respType" : respType,
+                     @"timeout" : @NO,
                      @"status": [NSString stringWithFormat:@"%d", statusCode ]
                      };
         [self.bridge.eventDispatcher
 }
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
-    NSLog([error localizedDescription]);
+    
     self.error = error;
     [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
     
     NSString * respType = [respInfo valueForKey:@"respType"];
+    if(error != nil) {
+        NSLog([error localizedDescription]);
+    }
     
     if(respFile == YES)
     {
-        if(error != nil) {
-            NSLog([error localizedDescription]);
-        }
         [writeStream close];
         callback(@[error == nil ? [NSNull null] : [error localizedDescription],
                    respInfo == nil ? [NSNull null] : respInfo,
                    destPath
-                   ]);
+                ]);
     }
     // base64 response
     else {
     }
 }
 
+
 @end

src/ios/RNFetchBlobReqBuilder.h

                         form:(NSString *)body
                   onComplete:(void(^)(NSURLRequest * req, long bodyLength))onComplete;
 
++(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSMutableArray *) headers;
+
 
 @end
 

src/polyfill/Event.js

+// Copyright 2016 wkh237@github. All rights reserved.
+// Use of this source code is governed by a MIT-style license that can be
+// found in the LICENSE file.
+
+export default class Event {
+
+  constructor() {
+
+  }
+
+}

src/polyfill/EventTarget.js

 // Copyright 2016 wkh237@github. All rights reserved.
 // Use of this source code is governed by a MIT-style license that can be
 // found in the LICENSE file.
+
 import Log from '../utils/log.js'
 
 const log = new Log('EventTarget')
     this.listeners = {}
   }
 
+  /**
+   * Add an event listener to given event type
+   * @param {string} type Event type string
+   * @param {(Event) => void} cb   Event handler function
+   */
   addEventListener(type:string, cb : () => void) {
     log.info('add event listener', type, cb)
     if(!(type in this.listeners)) {
     this.listeners[type].push(cb)
   }
 
-  removeEventListener(type:string, cb:() => any) {
+  /**
+   * Remove an event listener
+   * @param  {string} type Type of the event listener
+   * @param  {()=>void} cb Event listener function.
+   * @return {[type]}             [description]
+   */
+  removeEventListener(type:string, cb:() => void) {
     log.info('remove event listener', type, cb)
     if(!(type in this.listeners))
       return
     }
   }
 
+  /**
+   * Dispatch an event
+   * @param {Evnet} event Event data payload.
+   */
   dispatchEvent(event:Event) {
     log.info('dispatch event', event)
     if(!(event.type in this.listeners))
 
   }
 
+  /**
+   * Remove all registered listeners from this object.
+   * @nonstandard
+   * @return {[type]} [description]
+   */
+  clearEventListeners() {
+    for(let i in this.listeners) {
+      delete listeners[i]
+    }
+  }
+
 }

src/polyfill/ProgressEvent.js

+// Copyright 2016 wkh237@github. All rights reserved.
+// Use of this source code is governed by a MIT-style license that can be
+// found in the LICENSE file.
+
+import Event from './Event'
+
+export default class ProgressEvent extends Event {
+
+  _lengthComputable : boolean = false;
+  _loaded : number = -1;
+  _total : numver = -1;
+
+  constructor(lengthComputable, loaded, total) {
+    super()
+    this._lengthComputable = lengthComputable;
+    this._loaded = loaded
+    this._total = total
+  }
+
+  get lengthComputable() {
+    return this._lengthComputable
+  }
+
+  get loaded() {
+    return this._loaded
+  }
+
+  get total() {
+    return this._total
+  }
+
+}

src/polyfill/XMLHttpRequest.js

 import XMLHttpRequestEventTarget from './XMLHttpRequestEventTarget.js'
 import Log from '../utils/log.js'
 import Blob from './Blob.js'
+import ProgressEvent from './ProgressEvent.js'
 
 const log = new Log('XMLHttpRequest')
 
 
   _onreadystatechange : () => void;
 
+  upload : XMLHttpRequestEventTarget = new XMLHttpRequestEventTarget();
+
+  // readonly
   _readyState : number = UNSENT;
   _response : any = '';
-  _responseText : any = '';
+  _responseText : any = null;
   _responseHeaders : any = {};
   _responseType : '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' = '';
-  // TODO : not suppoted for now
+  // TODO : not suppoted ATM
   _responseURL : null = '';
   _responseXML : null = '';
   _status : number = 0;
   _statusText : string = '';
   _timeout : number = 0;
-  _upload : XMLHttpRequestEventTarget;
   _sendFlag : boolean = false;
+  _uploadStarted : boolean = false;
 
   // RNFetchBlob compatible data structure
-  _config : RNFetchBlobConfig;
+  _config : RNFetchBlobConfig = {};
   _url : any;
   _method : string;
-  _headers: any;
+  _headers: any = {
+    'Content-Type' : 'text/plain'
+  };
   _body: any;
 
   // RNFetchBlob promise object, which has `progress`, `uploadProgress`, and
   // `cancel` methods.
   _task: any;
 
+  // constants
+  get UNSENT() { return UNSENT }
+  get OPENED() { return OPENED }
+  get HEADERS_RECEIVED() { return HEADERS_RECEIVED }
+  get LOADING() { return LOADING }
+  get DONE() { return DONE }
+
   static get UNSENT() {
     return UNSENT
   }
     return DONE
   }
 
-  constructor(...args) {
+  constructor() {
     super()
-    log.verbose('XMLHttpRequest constructor called', args)
-    this._config = {}
-    this._args = {}
-    this._headers = {}
+    log.verbose('XMLHttpRequest constructor called')
   }
 
 
     this._method = method
     this._url = url
     this._headers = {}
-    this.readyState = XMLHttpRequest.OPENED
+    this._dispatchReadStateChange(XMLHttpRequest.OPENED)
   }
 
   /**
     log.verbose('XMLHttpRequest send ', body)
     let {_method, _url, _headers } = this
     log.verbose('sending request with args', _method, _url, _headers, body)
-
-    this._upload = new XMLHttpRequestEventTarget()
     log.verbose(typeof body, body instanceof FormData)
 
     if(body instanceof Blob) {
       body = RNFetchBlob.wrap(body.getRNFetchBlobRef())
     }
+    else if(typeof body === 'object') {
+      body = JSON.stringify(body)
+    }
 
-    this.dispatchEvent('loadstart')
-    if(this.onloadstart)
-      this.onloadstart()
-
-    this._task = RNFetchBlob.config({ auto: true })
-                            .fetch(_method, _url, _headers, body)
+    this._task = RNFetchBlob
+                  .config({ auto: true, timeout : this._timeout })
+                  .fetch(_method, _url, _headers, body)
+    this.dispatchEvent('load')
     this._task
         .stateChange(this._headerReceived.bind(this))
-        .uploadProgress(this._progressEvent.bind(this))
+        .uploadProgress(this._uploadProgressEvent.bind(this))
         .progress(this._progressEvent.bind(this))
         .catch(this._onError.bind(this))
         .then(this._onDone.bind(this))
 
   overrideMimeType(mime:string) {
     log.verbose('XMLHttpRequest overrideMimeType', mime)
-    this._headers['content-type'] = mime
+    this._headers['Content-Type'] = mime
   }
 
   setRequestHeader(name, value) {
     log.verbose('XMLHttpRequest set header', name, value)
-    if(this._readyState !== OPENED && this._sendFlag) {
+    if(this._readyState !== OPENED || this._sendFlag) {
       throw `InvalidStateError : Calling setRequestHeader in wrong state  ${this._readyState}`
     }
     // UNICODE SHOULD NOT PASS
   _headerReceived(e) {
     log.verbose('header received ', this._task.taskId, e)
     this.responseURL = this._url
+    this.upload.dispatchEvent('loadend')
+    this.dispatchEvent('load')
     if(e.state === "2") {
-      this._readyState = XMLHttpRequest.HEADERS_RECEIVED
       this._responseHeaders = e.headers
-      this._responseText = e.status
+      this._statusText = e.status
       this._responseType = e.respType || ''
       this._status = Math.floor(e.status)
+      this._dispatchReadStateChange(XMLHttpRequest.HEADERS_RECEIVED)
     }
   }
 
+  _uploadProgressEvent(send:number, total:number) {
+    console.log('_upload', this.upload)
+    if(!this._uploadStarted) {
+      this.upload.dispatchEvent('loadstart')
+      this._uploadStarted = true
+    }
+    if(send >= total)
+      this.upload.dispatchEvent('load')
+    this.upload.dispatchEvent('progress', new ProgressEvent(true, send, total))
+  }
+
   _progressEvent(send:number, total:number) {
     log.verbose(this.readyState)
-    if(this.readyState === XMLHttpRequest.HEADERS_RECEIVED)
-      this.readyState = XMLHttpRequest.LOADING
+    if(this._readyState === XMLHttpRequest.HEADERS_RECEIVED)
+      this._dispatchReadStateChange(XMLHttpRequest.LOADING)
     let lengthComputable = false
-    let e = { lengthComputable }
     if(total && total >= 0)
-        e.lengthComputable = true
-    else {
-      Object.assign(e, { loaded : send, total })
-    }
-
-    if(this.onprogress)
-      this.onprogress(e)
+        lengthComputable = true
+    let e = new ProgressEvent(lengthComputable, send, total)
     this.dispatchEvent('progress', e)
   }
 
     this._statusText = err
     this._status = String(err).match(/\d+/)
     this._status = this._status ? Math.floor(this.status) : 404
-    this._readyState = XMLHttpRequest.DONE
-    if(String(err).match('timeout') !== null) {
+    this._dispatchReadStateChange(XMLHttpRequest.DONE)
+    if(err && String(err.message).match(/(timed\sout|timedout)/)) {
       this.dispatchEvent('timeout')
-      if(this.ontimeout)
-        this.ontimeout()
-    }
-    else if(this.onerror) {
-      this.dispatchEvent('error')
-      this.onerror({
-        type : 'error',
-        detail : err
-      })
     }
+    this.dispatchEvent('loadend')
+    this.dispatchEvent('error', {
+      type : 'error',
+      detail : err
+    })
+    this.clearEventListeners()
   }
 
   _onDone(resp) {
-    log.verbose('XMLHttpRequest done', this._task.taskId, this)
-    this.statusText = '200 OK'
-    switch(resp.type) {
-      case 'base64' :
-        if(this.responseType === 'json') {
+    log.verbose('XMLHttpRequest done', this._url, resp)
+    this._statusText = this._status
+    if(resp) {
+      switch(resp.type) {
+        case 'base64' :
+          if(this._responseType === 'json') {
+              this._responseText = resp.text()
+              this._response = resp.json()
+          }
+          else {
             this._responseText = resp.text()
-            this._response = resp.json()
-        }
-        else {
+            this._response = this.responseText
+          }
+        break;
+        case 'path' :
+          this.response = resp.blob()
+        break;
+        default :
           this._responseText = resp.text()
           this._response = this.responseText
-        }
-      break;
-      case 'path' :
-        this.response = resp.blob()
-      break;
+        break;
+      }
+      this.dispatchEvent('loadend')
+      this._dispatchReadStateChange(XMLHttpRequest.DONE)
     }
-    this.dispatchEvent('loadend')
-    if(this.onloadend)
-      this.onloadend()
-    this.dispatchEvent('load')
-    if(this._onload)
-      this._onload()
-    this.readyState = XMLHttpRequest.DONE
+    this.clearEventListeners()
+  }
+
+  _dispatchReadStateChange(state) {
+    this._readyState = state
+    if(typeof this._onreadystatechange === 'function')
+      this._onreadystatechange()
   }
 
   set onreadystatechange(fn:() => void) {
     this._onreadystatechange = fn
   }
 
-  set readyState(val:number) {
-
-    log.verbose('XMLHttpRequest ready state changed to ', val)
-    this._readyState = val
-    if(this._onreadystatechange) {
-      log.verbose('trigger onreadystatechange event', this._readyState)
-      log.verbose(this._onreadystatechange)
-      this.dispatchEvent('readystatechange', )
-      if(this._onreadystatechange)
-        this._onreadystatechange()
-    }
+  get onreadystatechange(fn:() => void) {
+    return this._onreadystatechange
   }
 
   get readyState() {
     return this._status
   }
 
-  set statusText(val) {
-    this._statusText = val
-  }
-
   get statusText() {
     log.verbose('get statusText', this._statusText)
     return this._statusText
   }
 
-  set response(val) {
-    log.verbose('set response', val)
-    this._response = val
-  }
-
   get response() {
     log.verbose('get response', this._response)
     return this._response
     return this._timeout
   }
 
-  get upload() {
-    log.verbose('get upload', this._upload)
-    return this._upload
-  }
-
   get responseType() {
     log.verbose('get response type', this._responseType)
     return this._responseType

src/polyfill/XMLHttpRequestEventTarget.js

 // Copyright 2016 wkh237@github. All rights reserved.
 // Use of this source code is governed by a MIT-style license that can be
 // found in the LICENSE file.
+
 import EventTarget from './EventTarget.js'
 import Log from '../utils/log.js'
 
 
 export default class XMLHttpRequestEventTarget extends EventTarget {
 
-  _onabort : (e:Event) => void;
-  _onerror : (e:Event) => void;
-  _onload : (e:Event) => void;
-  _onloadstart : (e:Event) => void;
-  _onprogress : (e:Event) => void;
-  _ontimeout : (e:Event) => void;
-  _onloadend : (e:Event) => void;
+  _onabort : (e:Event) => void = () => {};
+  _onerror : (e:Event) => void = () => {};
+  _onload : (e:Event) => void = () => {};
+  _onloadstart : (e:Event) => void = () => {};
+  _onprogress : (e:Event) => void = () => {};
+  _ontimeout : (e:Event) => void = () => {};
+  _onloadend : (e:Event) => void = () => {};
 
   constructor() {
     super()
     log.info('constructor called')
   }
 
+  dispatchEvent(event:string, e:Event) {
+    super.dispatchEvent(event, e)
+    switch(event) {
+      case 'abort' :
+        this._onabort(e)
+      break;
+      case 'error' :
+        this._onerror(e)
+      break;
+      case 'load' :
+        this._onload(e)
+      break;
+      case 'loadstart' :
+        this._onloadstart(e)
+      break;
+      case 'loadend' :
+        this._onloadend(e)
+      break;
+      case 'progress' :
+        this._onprogress(e)
+      break;
+      case 'timeout' :
+        this._ontimeout(e)
+      break;
+    }
+  }
+
   set onabort(fn:(e:Event) => void) {
     log.info('set onabort')
     this._onabort = fn

src/polyfill/index.js

 import File from './File.js'
 import XMLHttpRequest from './XMLHttpRequest.js'
 import FormData from './FormData.js'
+import ProgressEvent from './ProgressEvent'
 
 export default {
-  Blob, File, XMLHttpRequest, FormData
+  Blob, File, XMLHttpRequest, FormData, ProgressEvent
 }