release v2.0.8

- fix #198 : Cookie header is always passed even if there is no cookie
- some cleanup
2026-02-22 00:00:04 +08:00 · 2019-04-10 12:06:17 +02:00 · 2019-04-09 17:25:55 +02:00 · 2019-04-08 20:16:24 +02:00 · 2019-04-08 20:12:36 +02:00 · 2019-04-08 19:14:39 +02:00
65 changed files with 2555 additions and 2321 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,5 @@
 node_modules/**
-test/app-template/www/certificates/*.cer
+test/e2e-app-template/www/certificates/*.cer
 tags
 .zedstate
 npm-debug.log
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,24 @@
 # Changelog

+## 2.0.8
+
+- Fixed #198: cookie header is always passed even if there is no cookie
+- Fixed #201: browser implementation is broken due to broken dependency
+- Fixed #197: iOS crashes when multiple request are done simultaneously (reverted a8e3637)
+- Fixed #189: error code mappings are not precise
+- Fixed #200: compatibility with Java 6 is broken due to string switch on Android
+
+- :warning: **Deprecation**: Deprecated "setSSLCertMode" in favor of "setServerTrustMode"
+
+## 2.0.7
+
+- Fixed #195: URLs are double-encoded on Android
+
+## 2.0.6
+
+- Fixed #187: setSSLCertMode with "default" throws an error on Android
+- Fixed #115: HTTP connections are not kept alive on iOS (thanks MorpheusDe97)
+
 ## 2.0.5

 - Fixed #185: need more detailed SSL error message
--- a/README.md
+++ b/README.md
@@ -128,13 +128,13 @@ cordova.plugin.http.clearCookies();
 ## Asynchronous Functions
 These functions all take success and error callbacks as their last 2 arguments.

-### setSSLCertMode<a name="setSSLCertMode"></a>
-Set SSL Cert handling mode, being one of the following values:
+### setServerTrustMode<a name="setServerTrustMode"></a>
+Set server trust mode, being one of the following values:

-* `default`: default SSL cert handling using system's CA certs
+* `default`: default SSL trustship and hostname verification handling using system's CA certs
 * `legacy`: use legacy default behavior (< 2.0.3), excluding user installed CA certs (only for Android)
-* `nocheck`: disable SSL cert checking, trusting all certs (meant to be used only for testing purposes)
-* `pinned`: trust only provided certs
+* `nocheck`: disable SSL certificate checking and hostname verification, trusting all certs (meant to be used only for testing purposes)
+* `pinned`: trust only provided certificates

 To use SSL pinning you must include at least one `.cer` SSL certificate in your app project.  You can pin to your server certificate or to one of the issuing CA certificates. Include your certificate in the `www/certificates` folder. All `.cer` files found there will be loaded automatically.

@@ -142,32 +142,38 @@ To use SSL pinning you must include at least one `.cer` SSL certificate in your

 ```js
 // enable SSL pinning
-cordova.plugin.http.setSSLCertMode('pinned', function() {
+cordova.plugin.http.setServerTrustMode('pinned', function() {
  console.log('success!');
 }, function() {
  console.log('error :(');
 });

 // use system's default CA certs
-cordova.plugin.http.setSSLCertMode('default', function() {
+cordova.plugin.http.setServerTrustMode('default', function() {
  console.log('success!');
 }, function() {
  console.log('error :(');
 });

 // disable SSL cert checking, only meant for testing purposes, do NOT use in production!
-cordova.plugin.http.setSSLCertMode('nocheck', function() {
+cordova.plugin.http.setServerTrustMode('nocheck', function() {
  console.log('success!');
 }, function() {
  console.log('error :(');
 });
 ```

+### setSSLCertMode (deprecated)
+This function was deprecated in 2.0.8. Use ["setServerTrustMode"](#setServerTrustMode) instead.
+
 ### enableSSLPinning (obsolete)
-This function was removed in 2.0.0. Use ["setSSLCertMode"](#setSSLCertMode) to enable SSL pinning (mode "pinned").
+This function was removed in 2.0.0. Use ["setServerTrustMode"](#setServerTrustMode) to enable SSL pinning (mode "pinned").

 ### acceptAllCerts (obsolete)
-This function was removed in 2.0.0. Use ["setSSLCertMode"](#setSSLCertMode) to disable checking certs (mode "nocheck").
+This function was removed in 2.0.0. Use ["setServerTrustMode"](#setServerTrustMode) to disable checking certs (mode "nocheck").
+
+### validateDomainName (obsolete)
+This function was removed in v1.6.2. Domain name validation is disabled automatically when you set server trust mode to "nocheck".

 ### disableRedirect
 If set to `true`, it won't follow redirects automatically. This defaults to false.
@@ -180,9 +186,6 @@ cordova.plugin.http.disableRedirect(true, function() {
 });
 ```

-### validateDomainName (obsolete)
-This function was removed in v1.6.2. Domain name validation is disabled automatically when you set SSL cert mode to "nocheck".
-
 ### removeCookies
 Remove all cookies associated with a given URL.

--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
  "name": "cordova-plugin-advanced-http",
-  "version": "2.0.5",
+  "version": "2.0.8",
  "lockfileVersion": 1,
  "requires": true,
  "dependencies": {
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "cordova-plugin-advanced-http",
-  "version": "2.0.5",
+  "version": "2.0.8",
  "description": "Cordova / Phonegap plugin for communicating with HTTP servers using SSL pinning",
  "scripts": {
    "updatecert": "node ./scripts/update-test-cert.js",
@@ -8,7 +8,7 @@
    "testandroid": "npm run updatecert && ./scripts/build-test-app.sh --android --emulator && ./scripts/test-app.sh --android --emulator",
    "testios": "npm run updatecert && ./scripts/build-test-app.sh --ios --emulator && ./scripts/test-app.sh --ios --emulator",
    "testapp": "npm run testandroid && npm run testios",
-    "testjs": "mocha ./test/js-mocha-specs.js",
+    "testjs": "mocha ./test/js-specs.js",
    "test": "npm run testjs && npm run testapp",
    "release": "npm run test && ./scripts/release.sh"
  },
--- a/plugin.xml
+++ b/plugin.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<plugin xmlns="http://www.phonegap.com/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android" id="cordova-plugin-advanced-http" version="2.0.5">
+<plugin xmlns="http://www.phonegap.com/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android" id="cordova-plugin-advanced-http" version="2.0.8">
  <name>Advanced HTTP plugin</name>
  <description>
        Cordova / Phonegap plugin for communicating with HTTP servers using SSL pinning
@@ -8,12 +8,16 @@
    <engine name="cordova" version=">=4.0.0"/>
  </engines>
  <dependency id="cordova-plugin-file" version=">=2.0.0"/>
-  <js-module src="www/lodash.js" name="lodash"/>
-  <js-module src="www/umd-tough-cookie.js" name="tough-cookie"/>
-  <js-module src="www/messages.js" name="messages"/>
-  <js-module src="www/local-storage-store.js" name="local-storage-store"/>
  <js-module src="www/cookie-handler.js" name="cookie-handler"/>
+  <js-module src="www/global-configs.js" name="global-configs"/>
  <js-module src="www/helpers.js" name="helpers"/>
+  <js-module src="www/js-util.js" name="js-util"/>
+  <js-module src="www/local-storage-store.js" name="local-storage-store"/>
+  <js-module src="www/lodash.js" name="lodash"/>
+  <js-module src="www/messages.js" name="messages"/>
+  <js-module src="www/public-interface.js" name="public-interface"/>
+  <js-module src="www/umd-tough-cookie.js" name="tough-cookie"/>
+  <js-module src="www/url-util.js" name="url-util"/>
  <js-module src="www/advanced-http.js" name="http">
    <clobbers target="cordova.plugin.http"/>
  </js-module>
@@ -50,25 +54,27 @@
  <platform name="android">
    <config-file target="res/xml/config.xml" parent="/*">
      <feature name="CordovaHttpPlugin">
-        <param name="android-package" value="com.synconset.cordovahttp.CordovaHttpPlugin"/>
+        <param name="android-package" value="com.silkimen.cordovahttp.CordovaHttpPlugin"/>
      </feature>
    </config-file>
    <config-file target="AndroidManifest.xml" parent="/manifest">
      <uses-permission android:name="android.permission.INTERNET"/>
    </config-file>
-    <source-file src="src/android/com/github/kevinsawicki/http/HttpRequest.java" target-dir="src/com/github/kevinsawicki/http"/>
-    <source-file src="src/android/com/github/kevinsawicki/http/OkConnectionFactory.java" target-dir="src/com/github/kevinsawicki/http"/>
-    <source-file src="src/android/com/github/kevinsawicki/http/TLSSocketFactory.java" target-dir="src/com/github/kevinsawicki/http"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttp.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpDelete.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpDownload.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpGet.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpHead.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpPlugin.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpPost.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpPut.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpPatch.java" target-dir="src/com/synconset/cordovahttp"/>
-    <source-file src="src/android/com/synconset/cordovahttp/CordovaHttpUpload.java" target-dir="src/com/synconset/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaClientAuth.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaHttpBase.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaHttpDownload.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaHttpOperation.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaHttpPlugin.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaHttpResponse.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaHttpUpload.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/cordovahttp/CordovaServerTrust.java" target-dir="src/com/silkimen/cordovahttp"/>
+    <source-file src="src/android/com/silkimen/http/HttpBodyDecoder.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/HttpRequest.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/JsonUtils.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/KeyChainKeyManager.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/OkConnectionFactory.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/TLSConfiguration.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/TLSSocketFactory.java" target-dir="src/com/silkimen/http"/>
    <framework src="com.squareup.okhttp3:okhttp-urlconnection:3.10.0"/>
  </platform>
  <platform name="browser">
--- a/scripts/build-test-app.sh
+++ b/scripts/build-test-app.sh
@@ -35,10 +35,11 @@ while :; do
   shift
 done

+printf 'Building test app for %s\n' $PLATFORM
 rm -rf $ROOT/temp
 mkdir $ROOT/temp
-cp -r $ROOT/test/app-template/. $ROOT/temp/
-cp $ROOT/test/app-test-definitions.js $ROOT/temp/www/
+cp -r $ROOT/test/e2e-app-template/. $ROOT/temp/
+cp $ROOT/test/e2e-specs.js $ROOT/temp/www/
 rsync -ax --exclude node_modules --exclude scripts --exclude temp --exclude test $ROOT/. $WORKINGCOPY
 cd $ROOT/temp
 $CDV prepare
--- a/scripts/setup-android-sdk.sh
+++ b/scripts/setup-android-sdk.sh
@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-while getopts a:b: option; do
-  case "${option}" in
-    a) API_LEVEL=${OPTARG};;
-    b) BUILD_TOOLS_VERSION=${OPTARG};;
-  esac
-done
-
-curl http://dl.google.com/android/android-sdk_r24.4-macosx.zip -o android-sdk-macosx.zip
-tar -xvf android-sdk-macosx.zip
-
-echo y | ./android-sdk-macosx/tools/android update sdk --no-ui --all --filter platform-tools
-echo y | ./android-sdk-macosx/tools/android update sdk --no-ui --all --filter build-tools-${BUILD_TOOLS_VERSION}
-echo y | ./android-sdk-macosx/tools/android update sdk --no-ui --all --filter android-${API_LEVEL}
-echo y | ./android-sdk-macosx/tools/android update sdk --no-ui --all --filter extra-android-support
-echo y | ./android-sdk-macosx/tools/android update sdk --no-ui --all --filter extra-android-m2repository
-echo y | ./android-sdk-macosx/tools/android update sdk --no-ui --all --filter extra-google-m2repository
--- a/scripts/test-app.sh
+++ b/scripts/test-app.sh
@@ -8,6 +8,7 @@ if [ $CI == "true" ] && ([ -z $SAUCE_USERNAME ] || [ -z $SAUCE_ACCESS_KEY ]); th
  exit 0;
 fi

+printf 'Running e2e tests\n'
 pushd $ROOT
-./node_modules/.bin/mocha ./test/app-mocha-specs/test.js "$@"
+./node_modules/.bin/mocha ./test/e2e-tooling/test.js "$@"
 popd
--- a/scripts/update-test-cert.js
+++ b/scripts/update-test-cert.js
@@ -3,7 +3,7 @@ const https = require('https');
 const path = require('path');

 const SOURCE_HOST = 'httpbin.org';
-const TARGET_PATH = path.join(__dirname, '../test/app-template/www/certificates/httpbin.org.cer');
+const TARGET_PATH = path.join(__dirname, '../test/e2e-app-template/www/certificates/httpbin.org.cer');

 const getCert = hostname => new Promise((resolve, reject) => {
  const options = {
--- a/src/android/com/github/kevinsawicki/http/OkConnectionFactory.java
+++ b/src/android/com/github/kevinsawicki/http/OkConnectionFactory.java
@@ -1,26 +0,0 @@
-package com.github.kevinsawicki.http;
-
-import okhttp3.OkUrlFactory;
-import okhttp3.OkHttpClient;
-
-import java.net.URL;
-import java.net.HttpURLConnection;
-import java.net.URLStreamHandler;
-import java.net.Proxy;
-
-
-public class OkConnectionFactory implements HttpRequest.ConnectionFactory {
-    
-    protected OkHttpClient okHttpClient = new OkHttpClient();
-
-    public HttpURLConnection create(URL url) {
-        OkUrlFactory okUrlFactory = new OkUrlFactory(okHttpClient);
-        return (HttpURLConnection) okUrlFactory.open(url);
-    }
-
-    public HttpURLConnection create(URL url, Proxy proxy) {
-        OkHttpClient okHttpClientWithProxy = okHttpClient.newBuilder().proxy(proxy).build();
-        OkUrlFactory okUrlFactory = new OkUrlFactory(okHttpClientWithProxy);
-        return (HttpURLConnection) okUrlFactory.open(url);
-    }
-}
--- a/src/android/com/github/kevinsawicki/http/TLSSocketFactory.java
+++ b/src/android/com/github/kevinsawicki/http/TLSSocketFactory.java
@@ -1,61 +0,0 @@
-package com.github.kevinsawicki.http;
-
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.Socket;
-import java.net.UnknownHostException;
-
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLSocket;
-import javax.net.ssl.SSLSocketFactory;
-
-public class TLSSocketFactory extends SSLSocketFactory {
-
-    private SSLSocketFactory delegate;
-
-    public TLSSocketFactory(SSLContext context) {
-        delegate = context.getSocketFactory();
-    }
-
-    @Override
-    public String[] getDefaultCipherSuites() {
-        return delegate.getDefaultCipherSuites();
-    }
-
-    @Override
-    public String[] getSupportedCipherSuites() {
-        return delegate.getSupportedCipherSuites();
-    }
-
-    @Override
-    public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException {
-        return enableTLSOnSocket(delegate.createSocket(s, host, port, autoClose));
-    }
-
-    @Override
-    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
-        return enableTLSOnSocket(delegate.createSocket(host, port));
-    }
-
-    @Override
-    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
-        return enableTLSOnSocket(delegate.createSocket(host, port, localHost, localPort));
-    }
-
-    @Override
-    public Socket createSocket(InetAddress host, int port) throws IOException {
-        return enableTLSOnSocket(delegate.createSocket(host, port));
-    }
-
-    @Override
-    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
-        return enableTLSOnSocket(delegate.createSocket(address, port, localAddress, localPort));
-    }
-
-    private Socket enableTLSOnSocket(Socket socket) {
-        if(socket != null && (socket instanceof SSLSocket)) {
-            ((SSLSocket)socket).setEnabledProtocols(new String[] {"TLSv1", "TLSv1.1", "TLSv1.2"});
-        }
-        return socket;
-    }
-}
--- a/src/android/com/silkimen/cordovahttp/CordovaClientAuth.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaClientAuth.java
@@ -0,0 +1,72 @@
+package com.silkimen.cordovahttp;
+
+import android.app.Activity;
+import android.content.Context;
+import android.security.KeyChain;
+import android.security.KeyChainAliasCallback;
+import android.util.Log;
+
+import java.security.KeyStore;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.KeyManager;
+
+import org.apache.cordova.CallbackContext;
+
+import com.silkimen.http.KeyChainKeyManager;
+import com.silkimen.http.TLSConfiguration;
+
+class CordovaClientAuth implements Runnable, KeyChainAliasCallback {
+  private static final String TAG = "Cordova-Plugin-HTTP";
+
+  private String mode;
+  private String filePath;
+  private Activity activity;
+  private Context context;
+  private TLSConfiguration tlsConfiguration;
+  private CallbackContext callbackContext;
+
+  public CordovaClientAuth(final String mode, final String filePath, final Activity activity, final Context context,
+      final TLSConfiguration configContainer, final CallbackContext callbackContext) {
+
+    this.mode = mode;
+    this.filePath = filePath;
+    this.activity = activity;
+    this.tlsConfiguration = configContainer;
+    this.context = context;
+    this.callbackContext = callbackContext;
+  }
+
+  @Override
+  public void run() {
+    if ("systemstore".equals(this.mode)) {
+      KeyChain.choosePrivateKeyAlias(this.activity, this, null, null, null, -1, null);
+    } else if ("file".equals(this.mode)) {
+      this.callbackContext.error("Not implemented, yet");
+    } else {
+      this.tlsConfiguration.setKeyManagers(null);
+      this.callbackContext.success();
+    }
+  }
+
+  @Override
+  public void alias(final String alias) {
+    try {
+      if (alias == null) {
+        throw new Exception("Couldn't get a consent for private key access");
+      }
+
+      PrivateKey key = KeyChain.getPrivateKey(this.context, alias);
+      X509Certificate[] chain = KeyChain.getCertificateChain(this.context, alias);
+      KeyManager keyManager = new KeyChainKeyManager(alias, key, chain);
+
+      this.tlsConfiguration.setKeyManagers(new KeyManager[] { keyManager });
+
+      this.callbackContext.success();
+    } catch (Exception e) {
+      Log.e(TAG, "Couldn't load private key and certificate pair for authentication", e);
+      this.callbackContext.error("Couldn't load private key and certificate pair for authentication");
+    }
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaHttpBase.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaHttpBase.java
@@ -0,0 +1,174 @@
+package com.silkimen.cordovahttp;
+
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+
+import java.nio.ByteBuffer;
+
+import javax.net.ssl.SSLException;
+
+import com.silkimen.http.HttpBodyDecoder;
+import com.silkimen.http.HttpRequest;
+import com.silkimen.http.HttpRequest.HttpRequestException;
+import com.silkimen.http.JsonUtils;
+import com.silkimen.http.OkConnectionFactory;
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.util.Log;
+
+abstract class CordovaHttpBase implements Runnable {
+  protected static final String TAG = "Cordova-Plugin-HTTP";
+
+  protected String method;
+  protected String url;
+  protected String serializer = "none";
+  protected Object data;
+  protected JSONObject headers;
+  protected int timeout;
+  protected boolean followRedirects;
+  protected TLSConfiguration tlsConfiguration;
+  protected CallbackContext callbackContext;
+
+  public CordovaHttpBase(String method, String url, String serializer, Object data, JSONObject headers, int timeout,
+      boolean followRedirects, TLSConfiguration tlsConfiguration, CallbackContext callbackContext) {
+
+    this.method = method;
+    this.url = url;
+    this.serializer = serializer;
+    this.data = data;
+    this.headers = headers;
+    this.timeout = timeout;
+    this.followRedirects = followRedirects;
+    this.tlsConfiguration = tlsConfiguration;
+    this.callbackContext = callbackContext;
+  }
+
+  public CordovaHttpBase(String method, String url, JSONObject headers, int timeout, boolean followRedirects,
+      TLSConfiguration tlsConfiguration, CallbackContext callbackContext) {
+
+    this.method = method;
+    this.url = url;
+    this.headers = headers;
+    this.timeout = timeout;
+    this.followRedirects = followRedirects;
+    this.tlsConfiguration = tlsConfiguration;
+    this.callbackContext = callbackContext;
+  }
+
+  @Override
+  public void run() {
+    CordovaHttpResponse response = new CordovaHttpResponse();
+
+    try {
+      HttpRequest request = this.createRequest();
+      this.prepareRequest(request);
+      this.sendBody(request);
+      this.processResponse(request, response);
+    } catch (HttpRequestException e) {
+      if (e.getCause() instanceof SSLException) {
+        response.setStatus(-2);
+        response.setErrorMessage("TLS connection could not be established: " + e.getMessage());
+        Log.w(TAG, "TLS connection could not be established", e);
+      } else if (e.getCause() instanceof UnknownHostException) {
+        response.setStatus(-3);
+        response.setErrorMessage("Host could not be resolved: " + e.getMessage());
+        Log.w(TAG, "Host could not be resolved", e);
+      } else if (e.getCause() instanceof SocketTimeoutException) {
+        response.setStatus(-4);
+        response.setErrorMessage("Request timed out: " + e.getMessage());
+        Log.w(TAG, "Request timed out", e);
+      } else {
+        response.setStatus(-1);
+        response.setErrorMessage("There was an error with the request: " + e.getCause().getMessage());
+        Log.w(TAG, "Generic request error", e);
+      }
+    } catch (Exception e) {
+      response.setStatus(-1);
+      response.setErrorMessage(e.getMessage());
+      Log.e(TAG, "An unexpected error occured", e);
+    }
+
+    try {
+      if (response.hasFailed()) {
+        this.callbackContext.error(response.toJSON());
+      } else {
+        this.callbackContext.success(response.toJSON());
+      }
+    } catch (JSONException e) {
+      Log.e(TAG, "An unexpected error occured while creating HTTP response object", e);
+    }
+  }
+
+  protected HttpRequest createRequest() throws JSONException {
+    return new HttpRequest(this.url, this.method);
+  }
+
+  protected void prepareRequest(HttpRequest request) throws JSONException, IOException {
+    request.followRedirects(this.followRedirects);
+    request.readTimeout(this.timeout);
+    request.acceptCharset("UTF-8");
+    request.uncompress(true);
+    request.setConnectionFactory(new OkConnectionFactory());
+
+    if (this.tlsConfiguration.getHostnameVerifier() != null) {
+      request.setHostnameVerifier(this.tlsConfiguration.getHostnameVerifier());
+    }
+
+    request.setSSLSocketFactory(this.tlsConfiguration.getTLSSocketFactory());
+
+    // setup content type before applying headers, so user can override it
+    this.setContentType(request);
+
+    request.headers(JsonUtils.getStringMap(this.headers));
+  }
+
+  protected void setContentType(HttpRequest request) {
+    if ("json".equals(this.serializer)) {
+      request.contentType("application/json", "UTF-8");
+    } else if ("utf8".equals(this.serializer)) {
+      request.contentType("text/plain", "UTF-8");
+    } else if ("urlencoded".equals(this.serializer)) {
+      // intentionally left blank, because content type is set in HttpRequest.form()
+    }
+  }
+
+  protected void sendBody(HttpRequest request) throws Exception {
+    if (this.data == null) {
+      return;
+    }
+
+    if ("json".equals(this.serializer)) {
+      request.send(this.data.toString());
+    } else if ("utf8".equals(this.serializer)) {
+      request.send(((JSONObject) this.data).getString("text"));
+    } else if ("urlencoded".equals(this.serializer)) {
+      request.form(JsonUtils.getObjectMap((JSONObject) this.data));
+    }
+  }
+
+  protected void processResponse(HttpRequest request, CordovaHttpResponse response) throws Exception {
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+    request.receive(outputStream);
+
+    ByteBuffer rawOutput = ByteBuffer.wrap(outputStream.toByteArray());
+    String decodedBody = HttpBodyDecoder.decodeBody(rawOutput, request.charset());
+
+    response.setStatus(request.code());
+    response.setUrl(request.url().toString());
+    response.setHeaders(request.headers());
+
+    if (request.code() >= 200 && request.code() < 300) {
+      response.setBody(decodedBody);
+    } else {
+      response.setErrorMessage(decodedBody);
+    }
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaHttpDownload.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaHttpDownload.java
@@ -0,0 +1,42 @@
+package com.silkimen.cordovahttp;
+
+import java.io.File;
+import java.net.URI;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+import com.silkimen.http.HttpRequest;
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.file.FileUtils;
+import org.json.JSONObject;
+
+class CordovaHttpDownload extends CordovaHttpBase {
+  private String filePath;
+
+  public CordovaHttpDownload(String url, JSONObject headers, String filePath, int timeout, boolean followRedirects,
+      TLSConfiguration tlsConfiguration, CallbackContext callbackContext) {
+
+    super("GET", url, headers, timeout, followRedirects, tlsConfiguration, callbackContext);
+    this.filePath = filePath;
+  }
+
+  @Override
+  protected void processResponse(HttpRequest request, CordovaHttpResponse response) throws Exception {
+    response.setStatus(request.code());
+    response.setUrl(request.url().toString());
+    response.setHeaders(request.headers());
+
+    if (request.code() >= 200 && request.code() < 300) {
+      File file = new File(new URI(this.filePath));
+      JSONObject fileEntry = FileUtils.getFilePlugin().getEntryForFile(file);
+
+      request.receive(file);
+      response.setFileEntry(fileEntry);
+    } else {
+      response.setErrorMessage("There was an error downloading the file");
+    }
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaHttpOperation.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaHttpOperation.java
@@ -0,0 +1,23 @@
+package com.silkimen.cordovahttp;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONObject;
+
+class CordovaHttpOperation extends CordovaHttpBase {
+  public CordovaHttpOperation(String method, String url, String serializer, Object data, JSONObject headers,
+      int timeout, boolean followRedirects, TLSConfiguration tlsConfiguration, CallbackContext callbackContext) {
+
+    super(method, url, serializer, data, headers, timeout, followRedirects, tlsConfiguration, callbackContext);
+  }
+
+  public CordovaHttpOperation(String method, String url, JSONObject headers, int timeout, boolean followRedirects,
+      TLSConfiguration tlsConfiguration, CallbackContext callbackContext) {
+
+    super(method, url, headers, timeout, followRedirects, tlsConfiguration, callbackContext);
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaHttpPlugin.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaHttpPlugin.java
@@ -0,0 +1,167 @@
+package com.silkimen.cordovahttp;
+
+import java.security.KeyStore;
+
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.util.Log;
+
+import javax.net.ssl.TrustManagerFactory;
+
+public class CordovaHttpPlugin extends CordovaPlugin {
+  private static final String TAG = "Cordova-Plugin-HTTP";
+
+  private boolean followRedirects = true;
+  private TLSConfiguration tlsConfiguration;
+
+  @Override
+  public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+    super.initialize(cordova, webView);
+
+    this.tlsConfiguration = new TLSConfiguration();
+
+    try {
+      KeyStore store = KeyStore.getInstance("AndroidCAStore");
+      String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+      TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
+
+      store.load(null);
+      tmf.init(store);
+
+      this.tlsConfiguration.setHostnameVerifier(null);
+      this.tlsConfiguration.setTrustManagers(tmf.getTrustManagers());
+    } catch (Exception e) {
+      Log.e(TAG, "An error occured while loading system's CA certificates", e);
+    }
+  }
+
+  @Override
+  public boolean execute(String action, final JSONArray args, final CallbackContext callbackContext)
+      throws JSONException {
+
+    if (action == null) {
+      return false;
+    }
+
+    if ("get".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("head".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("delete".equals(action)) {
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    } else if ("post".equals(action)) {
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    } else if ("put".equals(action)) {
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    } else if ("patch".equals(action)) {
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    } else if ("uploadFile".equals(action)) {
+      return this.uploadFile(args, callbackContext);
+    } else if ("downloadFile".equals(action)) {
+      return this.downloadFile(args, callbackContext);
+    } else if ("setServerTrustMode".equals(action)) {
+      return this.setServerTrustMode(args, callbackContext);
+    } else if ("setClientAuthMode".equals(action)) {
+      return this.setClientAuthMode(args, callbackContext);
+    } else if ("disableRedirect".equals(action)) {
+      return this.disableRedirect(args, callbackContext);
+    } else {
+      return false;
+    }
+  }
+
+  private boolean executeHttpRequestWithoutData(final String method, final JSONArray args,
+      final CallbackContext callbackContext) throws JSONException {
+
+    String url = args.getString(0);
+    JSONObject headers = args.getJSONObject(1);
+    int timeout = args.getInt(2) * 1000;
+
+    CordovaHttpOperation request = new CordovaHttpOperation(method.toUpperCase(), url, headers, timeout,
+        this.followRedirects, this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(request);
+
+    return true;
+  }
+
+  private boolean executeHttpRequestWithData(final String method, final JSONArray args,
+      final CallbackContext callbackContext) throws JSONException {
+
+    String url = args.getString(0);
+    Object data = args.get(1);
+    String serializer = args.getString(2);
+    JSONObject headers = args.getJSONObject(3);
+    int timeout = args.getInt(4) * 1000;
+
+    CordovaHttpOperation request = new CordovaHttpOperation(method.toUpperCase(), url, serializer, data, headers,
+        timeout, this.followRedirects, this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(request);
+
+    return true;
+  }
+
+  private boolean uploadFile(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    String url = args.getString(0);
+    JSONObject headers = args.getJSONObject(1);
+    String filePath = args.getString(2);
+    String uploadName = args.getString(3);
+    int timeout = args.getInt(4) * 1000;
+
+    CordovaHttpUpload upload = new CordovaHttpUpload(url, headers, filePath, uploadName, timeout, this.followRedirects,
+        this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(upload);
+
+    return true;
+  }
+
+  private boolean downloadFile(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    String url = args.getString(0);
+    JSONObject headers = args.getJSONObject(1);
+    String filePath = args.getString(2);
+    int timeout = args.getInt(3) * 1000;
+
+    CordovaHttpDownload download = new CordovaHttpDownload(url, headers, filePath, timeout, this.followRedirects,
+        this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(download);
+
+    return true;
+  }
+
+  private boolean setServerTrustMode(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    CordovaServerTrust runnable = new CordovaServerTrust(args.getString(0), this.cordova.getActivity(),
+        this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(runnable);
+
+    return true;
+  }
+
+  private boolean setClientAuthMode(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    CordovaClientAuth runnable = new CordovaClientAuth(args.getString(0), args.getString(1), this.cordova.getActivity(),
+        this.cordova.getContext(), this.tlsConfiguration, callbackContext);
+
+    cordova.getThreadPool().execute(runnable);
+
+    return true;
+  }
+
+  private boolean disableRedirect(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    this.followRedirects = !args.getBoolean(0);
+
+    callbackContext.success();
+
+    return true;
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaHttpResponse.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaHttpResponse.java
@@ -0,0 +1,90 @@
+package com.silkimen.cordovahttp;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+class CordovaHttpResponse {
+  private int status;
+  private String url;
+  private Map<String, List<String>> headers;
+  private String body;
+  private JSONObject fileEntry;
+  private boolean hasFailed;
+  private boolean isFileOperation;
+  private String error;
+
+  public void setStatus(int status) {
+    this.status = status;
+  }
+
+  public void setUrl(String url) {
+    this.url = url;
+  }
+
+  public void setHeaders(Map<String, List<String>> headers) {
+    this.headers = headers;
+  }
+
+  public void setBody(String body) {
+    this.body = body;
+  }
+
+  public void setFileEntry(JSONObject entry) {
+    this.isFileOperation = true;
+    this.fileEntry = entry;
+  }
+
+  public void setErrorMessage(String message) {
+    this.hasFailed = true;
+    this.error = message;
+  }
+
+  public boolean hasFailed() {
+    return this.hasFailed;
+  }
+
+  public JSONObject toJSON() throws JSONException {
+    JSONObject json = new JSONObject();
+
+    json.put("status", this.status);
+    json.put("url", this.url);
+
+    if (this.hasFailed) {
+      json.put("error", this.error);
+    } else if (this.isFileOperation) {
+      json.put("headers", new JSONObject(getFilteredHeaders()));
+      json.put("file", this.fileEntry);
+    } else {
+      json.put("headers", new JSONObject(getFilteredHeaders()));
+      json.put("data", this.body);
+    }
+
+    return json;
+  }
+
+  private Map<String, String> getFilteredHeaders() throws JSONException {
+    Map<String, String> filteredHeaders = new HashMap<String, String>();
+
+    if (this.headers == null || this.headers.isEmpty()) {
+      return filteredHeaders;
+    }
+
+    for (Map.Entry<String, List<String>> entry : this.headers.entrySet()) {
+      String key = entry.getKey();
+      List<String> value = entry.getValue();
+
+      if ((key != null) && (!value.isEmpty())) {
+        filteredHeaders.put(key.toLowerCase(), TextUtils.join(", ", value));
+      }
+    }
+
+    return filteredHeaders;
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaHttpUpload.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaHttpUpload.java
@@ -0,0 +1,43 @@
+package com.silkimen.cordovahttp;
+
+import android.webkit.MimeTypeMap;
+
+import com.silkimen.http.HttpRequest;
+
+import java.io.File;
+import java.net.URI;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+import org.json.JSONObject;
+
+class CordovaHttpUpload extends CordovaHttpBase {
+  private String filePath;
+  private String uploadName;
+
+  public CordovaHttpUpload(String url, JSONObject headers, String filePath, String uploadName, int timeout,
+      boolean followRedirects, TLSConfiguration tlsConfiguration, CallbackContext callbackContext) {
+
+    super("POST", url, headers, timeout, followRedirects, tlsConfiguration, callbackContext);
+    this.filePath = filePath;
+    this.uploadName = uploadName;
+  }
+
+  @Override
+  protected void sendBody(HttpRequest request) throws Exception {
+    int filenameIndex = this.filePath.lastIndexOf('/');
+    String filename = this.filePath.substring(filenameIndex + 1);
+
+    int extIndex = this.filePath.lastIndexOf('.');
+    String ext = this.filePath.substring(extIndex + 1);
+
+    MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
+    String mimeType = mimeTypeMap.getMimeTypeFromExtension(ext);
+
+    request.part(this.uploadName, filename, mimeType, new File(new URI(this.filePath)));
+  }
+}
--- a/src/android/com/silkimen/cordovahttp/CordovaServerTrust.java
+++ b/src/android/com/silkimen/cordovahttp/CordovaServerTrust.java
@@ -0,0 +1,124 @@
+package com.silkimen.cordovahttp;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+
+import com.silkimen.http.TLSConfiguration;
+
+import org.apache.cordova.CallbackContext;
+
+import android.app.Activity;
+import android.util.Log;
+import android.content.res.AssetManager;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+class CordovaServerTrust implements Runnable {
+  private static final String TAG = "Cordova-Plugin-HTTP";
+
+  private final TrustManager[] noOpTrustManagers;
+  private final HostnameVerifier noOpVerifier;
+
+  private String mode;
+  private Activity activity;
+  private TLSConfiguration tlsConfiguration;
+  private CallbackContext callbackContext;
+
+  public CordovaServerTrust(final String mode, final Activity activity, final TLSConfiguration configContainer,
+      final CallbackContext callbackContext) {
+
+    this.mode = mode;
+    this.activity = activity;
+    this.tlsConfiguration = configContainer;
+    this.callbackContext = callbackContext;
+
+    this.noOpTrustManagers = new TrustManager[] { new X509TrustManager() {
+      public X509Certificate[] getAcceptedIssuers() {
+        return new X509Certificate[0];
+      }
+
+      public void checkClientTrusted(X509Certificate[] chain, String authType) {
+        // intentionally left blank
+      }
+
+      public void checkServerTrusted(X509Certificate[] chain, String authType) {
+        // intentionally left blank
+      }
+    } };
+
+    this.noOpVerifier = new HostnameVerifier() {
+      public boolean verify(String hostname, SSLSession session) {
+        return true;
+      }
+    };
+  }
+
+  @Override
+  public void run() {
+    try {
+      if ("legacy".equals(this.mode)) {
+        this.tlsConfiguration.setHostnameVerifier(null);
+        this.tlsConfiguration.setTrustManagers(null);
+      } else if ("nocheck".equals(this.mode)) {
+        this.tlsConfiguration.setHostnameVerifier(this.noOpVerifier);
+        this.tlsConfiguration.setTrustManagers(this.noOpTrustManagers);
+      } else if ("pinned".equals(this.mode)) {
+        this.tlsConfiguration.setHostnameVerifier(null);
+        this.tlsConfiguration.setTrustManagers(this.getTrustManagers(this.getCertsFromBundle("www/certificates")));
+      } else {
+        this.tlsConfiguration.setHostnameVerifier(null);
+        this.tlsConfiguration.setTrustManagers(this.getTrustManagers(this.getCertsFromKeyStore("AndroidCAStore")));
+      }
+
+      callbackContext.success();
+    } catch (Exception e) {
+      Log.e(TAG, "An error occured while configuring SSL cert mode", e);
+      callbackContext.error("An error occured while configuring SSL cert mode");
+    }
+  }
+
+  private TrustManager[] getTrustManagers(KeyStore store) throws GeneralSecurityException {
+    String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+    TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
+    tmf.init(store);
+
+    return tmf.getTrustManagers();
+  }
+
+  private KeyStore getCertsFromBundle(String path) throws GeneralSecurityException, IOException {
+    AssetManager assetManager = this.activity.getAssets();
+    String[] files = assetManager.list(path);
+
+    CertificateFactory cf = CertificateFactory.getInstance("X.509");
+    String keyStoreType = KeyStore.getDefaultType();
+    KeyStore keyStore = KeyStore.getInstance(keyStoreType);
+
+    keyStore.load(null, null);
+
+    for (int i = 0; i < files.length; i++) {
+      int index = files[i].lastIndexOf('.');
+
+      if (index == -1 || !files[i].substring(index).equals(".cer")) {
+        continue;
+      }
+
+      keyStore.setCertificateEntry("CA" + i, cf.generateCertificate(assetManager.open(path + "/" + files[i])));
+    }
+
+    return keyStore;
+  }
+
+  private KeyStore getCertsFromKeyStore(String storeType) throws GeneralSecurityException, IOException {
+    KeyStore store = KeyStore.getInstance(storeType);
+    store.load(null);
+
+    return store;
+  }
+}
--- a/src/android/com/silkimen/http/HttpBodyDecoder.java
+++ b/src/android/com/silkimen/http/HttpBodyDecoder.java
@@ -0,0 +1,48 @@
+package com.silkimen.http;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.MalformedInputException;
+
+public class HttpBodyDecoder {
+  private static final String[] ACCEPTED_CHARSETS = new String[] { "UTF-8", "ISO-8859-1" };
+
+  public static String decodeBody(ByteBuffer rawOutput, String charsetName)
+      throws CharacterCodingException, MalformedInputException {
+
+    if (charsetName == null) {
+      return tryDecodeByteBuffer(rawOutput);
+    }
+
+    return decodeByteBuffer(rawOutput, charsetName);
+  }
+
+  private static String tryDecodeByteBuffer(ByteBuffer rawOutput) throws CharacterCodingException, MalformedInputException {
+
+    for (int i = 0; i < ACCEPTED_CHARSETS.length - 1; i++) {
+      try {
+        return decodeByteBuffer(rawOutput, ACCEPTED_CHARSETS[i]);
+      } catch (MalformedInputException e) {
+        continue;
+      } catch (CharacterCodingException e) {
+        continue;
+      }
+    }
+
+    return decodeBody(rawOutput, ACCEPTED_CHARSETS[ACCEPTED_CHARSETS.length - 1]);
+  }
+
+  private static String decodeByteBuffer(ByteBuffer rawOutput, String charsetName)
+      throws CharacterCodingException, MalformedInputException {
+
+    return createCharsetDecoder(charsetName).decode(rawOutput).toString();
+  }
+
+  private static CharsetDecoder createCharsetDecoder(String charsetName) {
+    return Charset.forName(charsetName).newDecoder().onMalformedInput(CodingErrorAction.REPORT)
+        .onUnmappableCharacter(CodingErrorAction.REPORT);
+  }
+}
--- a/src/android/com/github/kevinsawicki/http/HttpRequest.java
+++ b/src/android/com/github/kevinsawicki/http/HttpRequest.java
--- a/src/android/com/silkimen/http/JsonUtils.java
+++ b/src/android/com/silkimen/http/JsonUtils.java
@@ -0,0 +1,58 @@
+package com.silkimen.http;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class JsonUtils {
+  public static HashMap<String, String> getStringMap(JSONObject object) throws JSONException {
+    HashMap<String, String> map = new HashMap<String, String>();
+
+    if (object == null) {
+      return map;
+    }
+
+    Iterator<?> i = object.keys();
+
+    while (i.hasNext()) {
+      String key = (String) i.next();
+      map.put(key, object.getString(key));
+    }
+    return map;
+  }
+
+  public static HashMap<String, Object> getObjectMap(JSONObject object) throws JSONException {
+    HashMap<String, Object> map = new HashMap<String, Object>();
+
+    if (object == null) {
+      return map;
+    }
+
+    Iterator<?> i = object.keys();
+
+    while (i.hasNext()) {
+      String key = (String) i.next();
+      Object value = object.get(key);
+
+      if (value instanceof JSONArray) {
+        map.put(key, getObjectList((JSONArray) value));
+      } else {
+        map.put(key, object.get(key));
+      }
+    }
+    return map;
+  }
+
+  public static ArrayList<Object> getObjectList(JSONArray array) throws JSONException {
+    ArrayList<Object> list = new ArrayList<Object>();
+
+    for (int i = 0; i < array.length(); i++) {
+      list.add(array.get(i));
+    }
+    return list;
+  }
+}
--- a/src/android/com/silkimen/http/KeyChainKeyManager.java
+++ b/src/android/com/silkimen/http/KeyChainKeyManager.java
@@ -0,0 +1,57 @@
+package com.silkimen.http;
+
+import android.content.Context;
+import android.security.KeyChain;
+
+import java.net.Socket;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.X509ExtendedKeyManager;
+
+public class KeyChainKeyManager extends X509ExtendedKeyManager {
+  private final String alias;
+  private final X509Certificate[] chain;
+  private final PrivateKey key;
+
+  public KeyChainKeyManager(String alias, PrivateKey key, X509Certificate[] chain) {
+    this.alias = alias;
+    this.key = key;
+    this.chain = chain;
+  }
+
+  @Override
+  public String chooseClientAlias(String[] keyTypes, Principal[] issuers, Socket socket) {
+    return this.alias;
+  }
+
+  @Override
+  public X509Certificate[] getCertificateChain(String alias) {
+    return chain;
+  }
+
+  @Override
+  public PrivateKey getPrivateKey(String alias) {
+    return key;
+  }
+
+  @Override
+  public final String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
+    // not a client SSLSocket callback
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public final String[] getClientAliases(String keyType, Principal[] issuers) {
+    // not a client SSLSocket callback
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public final String[] getServerAliases(String keyType, Principal[] issuers) {
+    // not a client SSLSocket callback
+    throw new UnsupportedOperationException();
+  }
+}
--- a/src/android/com/silkimen/http/OkConnectionFactory.java
+++ b/src/android/com/silkimen/http/OkConnectionFactory.java
@@ -0,0 +1,26 @@
+package com.silkimen.http;
+
+import okhttp3.OkHttpClient;
+import okhttp3.OkUrlFactory;
+
+import java.net.URL;
+import java.net.HttpURLConnection;
+import java.net.URLStreamHandler;
+import java.net.Proxy;
+
+public class OkConnectionFactory implements HttpRequest.ConnectionFactory {
+  private final OkHttpClient client = new OkHttpClient();
+
+  public HttpURLConnection create(URL url) {
+    OkUrlFactory urlFactory = new OkUrlFactory(this.client);
+
+    return (HttpURLConnection) urlFactory.open(url);
+  }
+
+  public HttpURLConnection create(URL url, Proxy proxy) {
+    OkHttpClient clientWithProxy = new OkHttpClient.Builder().proxy(proxy).build();
+    OkUrlFactory urlFactory = new OkUrlFactory(clientWithProxy);
+
+    return (HttpURLConnection) urlFactory.open(url);
+  }
+}
--- a/src/android/com/silkimen/http/TLSConfiguration.java
+++ b/src/android/com/silkimen/http/TLSConfiguration.java
@@ -0,0 +1,69 @@
+package com.silkimen.http;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+import com.silkimen.http.TLSSocketFactory;
+
+public class TLSConfiguration {
+  private TrustManager[] trustManagers;
+  private KeyManager[] keyManagers;
+  private HostnameVerifier hostnameVerifier;
+
+  private SSLSocketFactory socketFactory;
+
+  public void setHostnameVerifier(HostnameVerifier hostnameVerifier) {
+    this.hostnameVerifier = hostnameVerifier;
+  }
+
+  public void setKeyManagers(KeyManager[] keyManagers) {
+    this.keyManagers = keyManagers;
+    this.socketFactory = null;
+  }
+
+  public void setTrustManagers(TrustManager[] trustManagers) {
+    this.trustManagers = trustManagers;
+    this.socketFactory = null;
+  }
+
+  public HostnameVerifier getHostnameVerifier() {
+    return this.hostnameVerifier;
+  }
+
+  public SSLSocketFactory getTLSSocketFactory() throws IOException {
+    if (this.socketFactory != null) {
+      return this.socketFactory;
+    }
+
+    try {
+      SSLContext context = SSLContext.getInstance("TLS");
+
+      context.init(this.keyManagers, this.trustManagers, new SecureRandom());
+
+      if (android.os.Build.VERSION.SDK_INT < 20) {
+        this.socketFactory = new TLSSocketFactory(context);
+      } else {
+        this.socketFactory = context.getSocketFactory();
+      }
+
+      return this.socketFactory;
+    } catch (GeneralSecurityException e) {
+      IOException ioException = new IOException("Security exception occured while configuring TLS context");
+      ioException.initCause(e);
+      throw ioException;
+    }
+  }
+}
--- a/src/android/com/silkimen/http/TLSSocketFactory.java
+++ b/src/android/com/silkimen/http/TLSSocketFactory.java
@@ -0,0 +1,63 @@
+package com.silkimen.http;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class TLSSocketFactory extends SSLSocketFactory {
+
+  private SSLSocketFactory delegate;
+
+  public TLSSocketFactory(SSLContext context) {
+    delegate = context.getSocketFactory();
+  }
+
+  @Override
+  public String[] getDefaultCipherSuites() {
+    return delegate.getDefaultCipherSuites();
+  }
+
+  @Override
+  public String[] getSupportedCipherSuites() {
+    return delegate.getSupportedCipherSuites();
+  }
+
+  @Override
+  public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
+    return enableTLSOnSocket(delegate.createSocket(socket, host, port, autoClose));
+  }
+
+  @Override
+  public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
+    return enableTLSOnSocket(delegate.createSocket(host, port));
+  }
+
+  @Override
+  public Socket createSocket(String host, int port, InetAddress localHost, int localPort)
+      throws IOException, UnknownHostException {
+    return enableTLSOnSocket(delegate.createSocket(host, port, localHost, localPort));
+  }
+
+  @Override
+  public Socket createSocket(InetAddress host, int port) throws IOException {
+    return enableTLSOnSocket(delegate.createSocket(host, port));
+  }
+
+  @Override
+  public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+      throws IOException {
+    return enableTLSOnSocket(delegate.createSocket(address, port, localAddress, localPort));
+  }
+
+  private Socket enableTLSOnSocket(Socket socket) {
+    if (socket != null && (socket instanceof SSLSocket)) {
+      ((SSLSocket) socket).setEnabledProtocols(new String[] { "TLSv1", "TLSv1.1", "TLSv1.2" });
+    }
+    return socket;
+  }
+}
--- a/src/android/com/synconset/cordovahttp/CordovaHttp.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttp.java
@@ -1,282 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import org.apache.cordova.CallbackContext;
-
-import org.json.JSONException;
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import java.nio.ByteBuffer;
-
-import java.nio.charset.CharacterCodingException;
-import java.nio.charset.Charset;
-import java.nio.charset.CharsetDecoder;
-import java.nio.charset.CodingErrorAction;
-import java.nio.charset.MalformedInputException;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.Iterator;
-
-import android.text.TextUtils;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-abstract class CordovaHttp {
-    protected static final String TAG = "CordovaHTTP";
-    protected static final String[] ACCEPTED_CHARSETS = new String[] { HttpRequest.CHARSET_UTF8, HttpRequest.CHARSET_LATIN1 };
-    private static AtomicBoolean disableRedirect = new AtomicBoolean(false);
-
-    private String urlString;
-    private Object params;
-    private String serializerName;
-    private JSONObject headers;
-    private int timeoutInMilliseconds;
-    private CallbackContext callbackContext;
-
-    public CordovaHttp(String urlString, Object params, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        this(urlString, params, "default", headers, timeout, callbackContext);
-    }
-
-    public CordovaHttp(String urlString, Object params, String serializerName, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        this.urlString = urlString;
-        this.params = params;
-        this.serializerName = serializerName;
-        this.headers = headers;
-        this.timeoutInMilliseconds = timeout;
-        this.callbackContext = callbackContext;
-    }
-
-    public static void disableRedirect(boolean disable) {
-        disableRedirect.set(disable);
-    }
-
-    protected String getUrlString() {
-        return this.urlString;
-    }
-
-    protected Object getParamsObject() {
-        return this.params;
-    }
-
-    protected String getSerializerName() {
-        return this.serializerName;
-    }
-
-    protected HashMap<String, Object> getParamsMap() throws JSONException, Exception {
-        if (this.params instanceof JSONObject) {
-          return this.getMapFromJSONObject((JSONObject) this.params);
-        } else {
-          throw new Exception("unsupported params type, needs to be a JSON object");
-        }
-    }
-
-    protected JSONObject getHeadersObject() {
-        return this.headers;
-    }
-
-    protected HashMap<String, String> getHeadersMap() throws JSONException {
-        return this.getStringMapFromJSONObject(this.headers);
-    }
-
-    protected int getRequestTimeout() {
-        return this.timeoutInMilliseconds;
-    }
-
-    protected CallbackContext getCallbackContext() {
-        return this.callbackContext;
-    }
-
-    protected HttpRequest setupRedirect(HttpRequest request) {
-        if (disableRedirect.get()) {
-            request.followRedirects(false);
-        }
-
-        return request;
-    }
-
-    protected void setupDataSerializer(HttpRequest request) throws JSONException, Exception {
-      if ("json".equals(this.getSerializerName())) {
-          request.contentType(request.CONTENT_TYPE_JSON, request.CHARSET_UTF8);
-      } else if ("utf8".equals(this.getSerializerName())) {
-          request.contentType("text/plain", request.CHARSET_UTF8);
-      }
-    }
-
-    protected void respondWithError(int status, String msg) {
-        try {
-            JSONObject response = new JSONObject();
-            response.put("status", status);
-            response.put("error", msg);
-            this.callbackContext.error(response);
-        } catch (JSONException e) {
-            this.callbackContext.error(msg);
-        }
-    }
-
-    protected void respondWithError(String msg) {
-        this.respondWithError(-1, msg);
-    }
-
-    protected void addResponseHeaders(HttpRequest request, JSONObject response) throws JSONException {
-        Map<String, List<String>> headers = request.headers();
-        Map<String, String> filteredHeaders = new HashMap<String, String>();
-
-        for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
-            String key = entry.getKey();
-            List<String> value = entry.getValue();
-
-            if ((key != null) && (!value.isEmpty())) {
-                filteredHeaders.put(key.toLowerCase(), TextUtils.join(", ", value));
-            }
-        }
-
-        response.put("headers", new JSONObject(filteredHeaders));
-    }
-
-    protected HashMap<String, String> getStringMapFromJSONObject(JSONObject object) throws JSONException {
-        HashMap<String, String> map = new HashMap<String, String>();
-        Iterator<?> i = object.keys();
-
-        while (i.hasNext()) {
-            String key = (String)i.next();
-            map.put(key, object.getString(key));
-        }
-        return map;
-    }
-
-    protected ArrayList<Object> getListFromJSONArray(JSONArray array) throws JSONException {
-      ArrayList<Object> list = new ArrayList<Object>();
-
-      for (int i = 0; i < array.length(); i++) {
-          list.add(array.get(i));
-      }
-      return list;
-    }
-
-    protected HashMap<String, Object> getMapFromJSONObject(JSONObject object) throws JSONException {
-        HashMap<String, Object> map = new HashMap<String, Object>();
-        Iterator<?> i = object.keys();
-
-        while(i.hasNext()) {
-            String key = (String)i.next();
-            Object value = object.get(key);
-
-            if (value instanceof JSONArray) {
-                map.put(key, getListFromJSONArray((JSONArray)value));
-            } else {
-                map.put(key, object.get(key));
-            }
-        }
-        return map;
-    }
-
-    protected void prepareRequest(HttpRequest request) throws HttpRequestException, JSONException {
-      this.setupRedirect(request);
-
-      request.readTimeout(this.getRequestTimeout());
-      request.acceptCharset(ACCEPTED_CHARSETS);
-      request.headers(this.getHeadersMap());
-      request.uncompress(true);
-    }
-
-    protected void prepareRequestBody(HttpRequest request) throws JSONException, Exception {
-      if ("json".equals(this.getSerializerName())) {
-          request.send(this.getParamsObject().toString());
-      } else if ("utf8".equals(this.getSerializerName())) {
-          request.send(this.getParamsMap().get("text").toString());
-      } else {
-          request.form(this.getParamsMap());
-      }
-    }
-
-    private CharsetDecoder createCharsetDecoder(final String charsetName) {
-      return Charset.forName(charsetName).newDecoder()
-        .onMalformedInput(CodingErrorAction.REPORT)
-        .onUnmappableCharacter(CodingErrorAction.REPORT);
-    }
-
-    private String decodeBody(AtomicReference<ByteBuffer> rawOutput, String charsetName)
-      throws CharacterCodingException, MalformedInputException {
-
-      if (charsetName == null) {
-        return tryDecodeByteBuffer(rawOutput);
-      }
-
-      return decodeByteBuffer(rawOutput, charsetName);
-    }
-
-    private String tryDecodeByteBuffer(AtomicReference<ByteBuffer> rawOutput)
-      throws CharacterCodingException, MalformedInputException {
-
-      for (int i = 0; i < ACCEPTED_CHARSETS.length - 1; i++) {
-        try {
-          return decodeByteBuffer(rawOutput, ACCEPTED_CHARSETS[i]);
-        } catch (MalformedInputException e) {
-          continue;
-        } catch (CharacterCodingException e) {
-          continue;
-        }
-      }
-
-      return decodeBody(rawOutput, ACCEPTED_CHARSETS[ACCEPTED_CHARSETS.length - 1]);
-    }
-
-    private String decodeByteBuffer(AtomicReference<ByteBuffer> rawOutput, String charsetName)
-      throws CharacterCodingException, MalformedInputException {
-
-      return createCharsetDecoder(charsetName).decode(rawOutput.get()).toString();
-    }
-
-    protected void returnResponseObject(HttpRequest request) throws HttpRequestException {
-      try {
-        JSONObject response = new JSONObject();
-        int code = request.code();
-        AtomicReference<ByteBuffer> rawOutputReference = new AtomicReference<ByteBuffer>();
-
-        request.body(rawOutputReference);
-        response.put("status", code);
-        response.put("url", request.url().toString());
-        this.addResponseHeaders(request, response);
-
-        if (code >= 200 && code < 300) {
-            response.put("data", decodeBody(rawOutputReference, request.charset()));
-            this.getCallbackContext().success(response);
-        } else {
-            response.put("error", decodeBody(rawOutputReference, request.charset()));
-            this.getCallbackContext().error(response);
-        }
-      } catch(JSONException e) {
-        this.respondWithError("There was an error generating the response");
-      } catch(MalformedInputException e) {
-        this.respondWithError("Could not decode response data due to malformed data");
-      } catch(CharacterCodingException e) {
-        this.respondWithError("Could not decode response data due to invalid or unknown charset encoding");
-      }
-    }
-
-    protected void handleHttpRequestException(HttpRequestException e) {
-      if (e.getCause() instanceof UnknownHostException) {
-          this.respondWithError(0, "The host could not be resolved: " + e.getMessage());
-      } else if (e.getCause() instanceof SocketTimeoutException) {
-          this.respondWithError(1, "The request timed out: " + e.getMessage());
-      } else if (e.getCause() instanceof SSLHandshakeException) {
-          this.respondWithError(-2, "SSL handshake failed: " + e.getMessage());
-      } else {
-          this.respondWithError("There was an error with the request: " + e.getMessage());
-      }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpDelete.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpDelete.java
@@ -1,37 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import org.apache.cordova.CallbackContext;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpDelete extends CordovaHttp implements Runnable {
-    public CordovaHttpDelete(String urlString, Object data, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        super(urlString, data, headers, timeout, callbackContext);
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.delete(this.getUrlString(), this.getParamsMap(), false);
-
-            this.prepareRequest(request);
-            this.returnResponseObject(request);
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-            this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpDownload.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpDownload.java
@@ -1,66 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-import java.io.File;
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-import java.net.URI;
-import java.net.URISyntaxException;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import org.apache.cordova.CallbackContext;
-import org.apache.cordova.file.FileUtils;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-class CordovaHttpDownload extends CordovaHttp implements Runnable {
-    private String filePath;
-
-    public CordovaHttpDownload(String urlString, Object params, JSONObject headers, String filePath, int timeout, CallbackContext callbackContext) {
-        super(urlString, params, headers, timeout, callbackContext);
-        this.filePath = filePath;
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.get(this.getUrlString(), this.getParamsMap(), false);
-
-            this.prepareRequest(request);
-
-            JSONObject response = new JSONObject();
-            int code = request.code();
-
-            response.put("status", code);
-            response.put("url", request.url().toString());
-            this.addResponseHeaders(request, response);
-
-            if (code >= 200 && code < 300) {
-                URI uri = new URI(filePath);
-                File file = new File(uri);
-                request.receive(file);
-                JSONObject fileEntry = FileUtils.getFilePlugin().getEntryForFile(file);
-                response.put("file", fileEntry);
-                this.getCallbackContext().success(response);
-            } else {
-                response.put("error", "There was an error downloading the file");
-                this.getCallbackContext().error(response);
-            }
-        } catch(URISyntaxException e) {
-            this.respondWithError("There was an error with the given filePath");
-        } catch (JSONException e) {
-            this.respondWithError("There was an error generating the response");
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-          this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpGet.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpGet.java
@@ -1,37 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import org.apache.cordova.CallbackContext;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpGet extends CordovaHttp implements Runnable {
-    public CordovaHttpGet(String urlString, Object params, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        super(urlString, params, headers, timeout, callbackContext);
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.get(this.getUrlString(), this.getParamsMap(), false);
-
-            this.prepareRequest(request);
-            this.returnResponseObject(request);
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-            this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpHead.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpHead.java
@@ -1,36 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import org.apache.cordova.CallbackContext;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpHead extends CordovaHttp implements Runnable {
-    public CordovaHttpHead(String urlString, Object params, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        super(urlString, params, headers, timeout, callbackContext);
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.head(this.getUrlString(), this.getParamsMap(), false);
-
-            this.prepareRequest(request);
-            this.returnResponseObject(request);
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-            this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpPatch.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpPatch.java
@@ -1,38 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import org.apache.cordova.CallbackContext;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpPatch extends CordovaHttp implements Runnable {
-    public CordovaHttpPatch(String urlString, Object params, String serializerName, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        super(urlString, params, serializerName, headers, timeout, callbackContext);
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.patch(this.getUrlString());
-
-            this.setupDataSerializer(request);
-            this.prepareRequest(request);
-            this.prepareRequestBody(request);
-            this.returnResponseObject(request);
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-            this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpPlugin.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpPlugin.java
@@ -1,179 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.io.BufferedInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-import java.security.GeneralSecurityException;
-import java.security.KeyStore;
-import java.security.cert.Certificate;
-
-import java.util.ArrayList;
-import java.util.Enumeration;
-
-import org.apache.cordova.CallbackContext;
-import org.apache.cordova.CordovaInterface;
-import org.apache.cordova.CordovaPlugin;
-import org.apache.cordova.CordovaWebView;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import android.content.res.AssetManager;
-
-import com.github.kevinsawicki.http.HttpRequest;
-
-public class CordovaHttpPlugin extends CordovaPlugin {
-    private static final String TAG = "CordovaHTTP";
-
-    @Override
-    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
-        super.initialize(cordova, webView);
-    }
-
-    @Override
-    public boolean execute(String action, final JSONArray args, final CallbackContext callbackContext) throws JSONException {
-        if (action.equals("post")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            String serializerName = args.getString(2);
-            JSONObject headers = args.getJSONObject(3);
-            int timeoutInMilliseconds = args.getInt(4) * 1000;
-            CordovaHttpPost post = new CordovaHttpPost(urlString, params, serializerName, headers, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(post);
-        } else if (action.equals("get")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            JSONObject headers = args.getJSONObject(2);
-            int timeoutInMilliseconds = args.getInt(3) * 1000;
-            CordovaHttpGet get = new CordovaHttpGet(urlString, params, headers, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(get);
-        } else if (action.equals("put")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            String serializerName = args.getString(2);
-            JSONObject headers = args.getJSONObject(3);
-            int timeoutInMilliseconds = args.getInt(4) * 1000;
-            CordovaHttpPut put = new CordovaHttpPut(urlString, params, serializerName, headers, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(put);
-        } else if (action.equals("patch")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            String serializerName = args.getString(2);
-            JSONObject headers = args.getJSONObject(3);
-            int timeoutInMilliseconds = args.getInt(4) * 1000;
-            CordovaHttpPatch patch = new CordovaHttpPatch(urlString, params, serializerName, headers, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(patch);
-        }
-         else if (action.equals("delete")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            JSONObject headers = args.getJSONObject(2);
-            int timeoutInMilliseconds = args.getInt(3) * 1000;
-            CordovaHttpDelete delete = new CordovaHttpDelete(urlString, params, headers, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(delete);
-        } else if (action.equals("head")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            JSONObject headers = args.getJSONObject(2);
-            int timeoutInMilliseconds = args.getInt(3) * 1000;
-            CordovaHttpHead head = new CordovaHttpHead(urlString, params, headers, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(head);
-        } else if (action.equals("setSSLCertMode")) {
-            String mode = args.getString(0);
-
-            if (mode.equals("legacy")) {
-                HttpRequest.setSSLCertMode(HttpRequest.CERT_MODE_DEFAULT);
-                callbackContext.success();
-            } else if (mode.equals("nocheck")) {
-                HttpRequest.setSSLCertMode(HttpRequest.CERT_MODE_TRUSTALL);
-                callbackContext.success();
-            } else if (mode.equals("pinned")) {
-                try {
-                    this.loadSSLCerts();
-                    HttpRequest.setSSLCertMode(HttpRequest.CERT_MODE_PINNED);
-                    callbackContext.success();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    callbackContext.error("There was an error setting up ssl pinning");
-                }
-            } else if (mode.equals("default")) {
-                try {
-                    this.loadUserStoreSSLCerts();
-                    HttpRequest.setSSLCertMode(HttpRequest.CERT_MODE_PINNED);
-                    callbackContext.success();
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    callbackContext.error("There was an error loading system's CA certificates");
-                }
-            }
-        } else if (action.equals("uploadFile")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            JSONObject headers = args.getJSONObject(2);
-            String filePath = args.getString(3);
-            String name = args.getString(4);
-            int timeoutInMilliseconds = args.getInt(5) * 1000;
-            CordovaHttpUpload upload = new CordovaHttpUpload(urlString, params, headers, filePath, name, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(upload);
-        } else if (action.equals("downloadFile")) {
-            String urlString = args.getString(0);
-            Object params = args.get(1);
-            JSONObject headers = args.getJSONObject(2);
-            String filePath = args.getString(3);
-            int timeoutInMilliseconds = args.getInt(4) * 1000;
-            CordovaHttpDownload download = new CordovaHttpDownload(urlString, params, headers, filePath, timeoutInMilliseconds, callbackContext);
-
-            cordova.getThreadPool().execute(download);
-        } else if (action.equals("disableRedirect")) {
-            boolean disable = args.getBoolean(0);
-            CordovaHttp.disableRedirect(disable);
-            callbackContext.success();
-        } else {
-            return false;
-        }
-        return true;
-    }
-
-    private void loadUserStoreSSLCerts() throws Exception {
-      KeyStore ks = KeyStore.getInstance("AndroidCAStore");
-      ks.load(null);
-      Enumeration<String> aliases = ks.aliases();
-
-      while (aliases.hasMoreElements()) {
-        String alias = aliases.nextElement();
-      }
-    }
-
-    private void loadSSLCerts() throws GeneralSecurityException, IOException {
-        AssetManager assetManager = cordova.getActivity().getAssets();
-        String[] files = assetManager.list("www/certificates");
-        ArrayList<String> cerFiles = new ArrayList<String>();
-
-        for (int i = 0; i < files.length; i++) {
-          int index = files[i].lastIndexOf('.');
-          if (index != -1) {
-            if (files[i].substring(index).equals(".cer")) {
-              cerFiles.add("www/certificates/" + files[i]);
-            }
-          }
-        }
-
-        for (int i = 0; i < cerFiles.size(); i++) {
-            InputStream in = cordova.getActivity().getAssets().open(cerFiles.get(i));
-            InputStream caInput = new BufferedInputStream(in);
-            HttpRequest.addCert(caInput);
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpPost.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpPost.java
@@ -1,38 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import org.apache.cordova.CallbackContext;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpPost extends CordovaHttp implements Runnable {
-    public CordovaHttpPost(String urlString, Object params, String serializerName, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        super(urlString, params, serializerName, headers, timeout, callbackContext);
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.post(this.getUrlString());
-
-            this.setupDataSerializer(request);
-            this.prepareRequest(request);
-            this.prepareRequestBody(request);
-            this.returnResponseObject(request);
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-            this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpPut.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpPut.java
@@ -1,38 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-
-import org.apache.cordova.CallbackContext;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpPut extends CordovaHttp implements Runnable {
-    public CordovaHttpPut(String urlString, Object data, String serializerName, JSONObject headers, int timeout, CallbackContext callbackContext) {
-        super(urlString, data, serializerName, headers, timeout, callbackContext);
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.put(this.getUrlString());
-
-            this.setupDataSerializer(request);
-            this.prepareRequest(request);
-            this.prepareRequestBody(request);
-            this.returnResponseObject(request);
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-            this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/android/com/synconset/cordovahttp/CordovaHttpUpload.java
+++ b/src/android/com/synconset/cordovahttp/CordovaHttpUpload.java
@@ -1,87 +0,0 @@
-/**
- * A HTTP plugin for Cordova / Phonegap
- */
-package com.synconset.cordovahttp;
-
-import java.io.File;
-
-import java.net.SocketTimeoutException;
-import java.net.UnknownHostException;
-import java.net.URI;
-import java.net.URISyntaxException;
-
-import java.util.Iterator;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.apache.cordova.CallbackContext;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import javax.net.ssl.SSLHandshakeException;
-
-import android.webkit.MimeTypeMap;
-
-import com.github.kevinsawicki.http.HttpRequest;
-import com.github.kevinsawicki.http.HttpRequest.HttpRequestException;
-
-class CordovaHttpUpload extends CordovaHttp implements Runnable {
-    private String filePath;
-    private String name;
-
-    public CordovaHttpUpload(String urlString, Object params, JSONObject headers, String filePath, String name, int timeout, CallbackContext callbackContext) {
-        super(urlString, params, headers, timeout, callbackContext);
-        this.filePath = filePath;
-        this.name = name;
-    }
-
-    @Override
-    public void run() {
-        try {
-            HttpRequest request = HttpRequest.post(this.getUrlString());
-
-            this.prepareRequest(request);
-
-            URI uri = new URI(filePath);
-
-            int filenameIndex = filePath.lastIndexOf('/');
-            String filename = filePath.substring(filenameIndex + 1);
-
-            int extIndex = filePath.lastIndexOf('.');
-            String ext = filePath.substring(extIndex + 1);
-
-            MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
-            String mimeType = mimeTypeMap.getMimeTypeFromExtension(ext);
-
-            Set<?> set = (Set<?>)this.getParamsMap().entrySet();
-            Iterator<?> i = set.iterator();
-
-            while (i.hasNext()) {
-                Entry<?, ?> e = (Entry<?, ?>)i.next();
-                String key = (String)e.getKey();
-                Object value = e.getValue();
-                if (value instanceof Number) {
-                    request.part(key, (Number)value);
-                } else if (value instanceof String) {
-                    request.part(key, (String)value);
-                } else {
-                    this.respondWithError("All parameters must be Numbers or Strings");
-                    return;
-                }
-            }
-          
-            request.part(this.name, filename, mimeType, new File(uri));
-
-            this.returnResponseObject(request);
-        } catch (URISyntaxException e) {
-            this.respondWithError("There was an error loading the file");
-        } catch (JSONException e) {
-            this.respondWithError("There was an error generating the response");
-        } catch (HttpRequestException e) {
-            this.handleHttpRequestException(e);
-        } catch (Exception e) {
-          this.respondWithError(e.getMessage());
-        }
-    }
-}
--- a/src/browser/cordova-http-plugin.js
+++ b/src/browser/cordova-http-plugin.js
@@ -1,7 +1,7 @@
 var pluginId = module.id.slice(0, module.id.lastIndexOf('.'));

 var cordovaProxy = require('cordova/exec/proxy');
-var helpers = require(pluginId + '.helpers');
+var jsUtil = require(pluginId + '.js-util');

 function serializeJsonData(data) {
  try {
@@ -29,7 +29,7 @@ function serializeParams(params) {
  if (params === null) return '';

  return Object.keys(params).map(function(key) {
-    if (helpers.getTypeOf(params[key]) === 'Array') {
+    if (jsUtil.getTypeOf(params[key]) === 'Array') {
      return serializeArray(key, params[key]);
    }

@@ -56,7 +56,7 @@ function createXhrSuccessObject(xhr) {
  return {
    url: xhr.responseURL,
    status: xhr.status,
-    data: helpers.getTypeOf(xhr.responseText) === 'String' ? xhr.responseText : xhr.response,
+    data: jsUtil.getTypeOf(xhr.responseText) === 'String' ? xhr.responseText : xhr.response,
    headers: deserializeResponseHeaders(xhr.getAllResponseHeaders())
  };
 }
@@ -65,7 +65,7 @@ function createXhrFailureObject(xhr) {
  var obj = {};

  obj.headers = xhr.getAllResponseHeaders();
-  obj.error = helpers.getTypeOf(xhr.responseText) === 'String' ? xhr.responseText : xhr.response;
+  obj.error = jsUtil.getTypeOf(xhr.responseText) === 'String' ? xhr.responseText : xhr.response;
  obj.error = obj.error || 'advanced-http: please check browser console for error messages';

  if (xhr.responseURL) obj.url = xhr.responseURL;
@@ -184,8 +184,11 @@ var browserInterface = {
  downloadFile: function (success, failure, opts) {
    return failure('advanced-http: function "downloadFile" not supported on browser platform');
  },
-  setSSLCertMode: function (success, failure, opts) {
-    return failure('advanced-http: function "setSSLCertMode" not supported on browser platform');
+  setServerTrustMode: function (success, failure, opts) {
+    return failure('advanced-http: function "setServerTrustMode" not supported on browser platform');
+  },
+  setClientAuthMode: function (success, failure, opts) {
+    return failure('advanced-http: function "setClientAuthMode" not supported on browser platform');
  },
  disableRedirect: function (success, failure, opts) {
    return failure('advanced-http: function "disableRedirect" not supported on browser platform');
--- a/src/ios/CordovaHttpPlugin.h
+++ b/src/ios/CordovaHttpPlugin.h
@@ -4,7 +4,7 @@

@interface CordovaHttpPlugin : CDVPlugin

- (void)setSSLCertMode:(CDVInvokedUrlCommand*)command;
+- (void)setServerTrustMode:(CDVInvokedUrlCommand*)command;
 - (void)disableRedirect:(CDVInvokedUrlCommand*)command;
 - (void)post:(CDVInvokedUrlCommand*)command;
 - (void)get:(CDVInvokedUrlCommand*)command;
--- a/src/ios/CordovaHttpPlugin.m
+++ b/src/ios/CordovaHttpPlugin.m
@@ -94,18 +94,22 @@
    switch ([error code]) {
        case -1001:
            // timeout
-            return [NSNumber numberWithInt:1];
+            return [NSNumber numberWithInt:-4];
        case -1002:
            // unsupported URL
-            return [NSNumber numberWithInt:2];
+            return [NSNumber numberWithInt:-5];
        case -1003:
            // server not found
-            return [NSNumber numberWithInt:0];
+            return [NSNumber numberWithInt:-3];
        case -1009:
            // no connection
-            return [NSNumber numberWithInt:3];
-        case -1202:
-            // untrusted SSL certificate
+            return [NSNumber numberWithInt:-6];
+        case -1200: // secure connection failed
+        case -1201: // certificate has bad date
+        case -1202: // certificate untrusted
+        case -1203: // certificate has unknown root
+        case -1204: // certificate is not yet valid
+            // configuring SSL failed
            return [NSNumber numberWithInt:-2];
        default:
            return [NSNumber numberWithInt:-1];
@@ -124,7 +128,7 @@
    return headerFieldsCopy;
 }

- (void)setSSLCertMode:(CDVInvokedUrlCommand*)command {
+- (void)setServerTrustMode:(CDVInvokedUrlCommand*)command {
    NSString *certMode = [command.arguments objectAtIndex:0];

    if ([certMode isEqualToString: @"default"] || [certMode isEqualToString: @"legacy"]) {
@@ -159,17 +163,15 @@
    [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
 }

- (void)post:(CDVInvokedUrlCommand*)command {
+- (void)get:(CDVInvokedUrlCommand*)command {
    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
    manager.securityPolicy = securityPolicy;

    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
-    NSString *serializerName = [command.arguments objectAtIndex:2];
-    NSDictionary *headers = [command.arguments objectAtIndex:3];
-    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:4] doubleValue];
+    NSDictionary *headers = [command.arguments objectAtIndex:1];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:2] doubleValue];

-    [self setRequestSerializer: serializerName forManager: manager];
+    [self setRequestSerializer: @"default" forManager: manager];
    [self setRequestHeaders: headers forManager: manager];
    [self setTimeout:timeoutInSeconds forManager:manager];
    [self setRedirect: manager];
@@ -179,7 +181,7 @@
    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];

    @try {
-        [manager POST:url parameters:parameters progress:nil success:^(NSURLSessionTask *task, id responseObject) {
+        [manager GET:url parameters:nil success:^(NSURLSessionTask *task, id responseObject) {
            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];

@@ -201,15 +203,53 @@
    }
 }

- (void)get:(CDVInvokedUrlCommand*)command {
+- (void)head:(CDVInvokedUrlCommand*)command {
    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
    manager.securityPolicy = securityPolicy;

    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
-    NSDictionary *headers = [command.arguments objectAtIndex:2];
-    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:3] doubleValue];
+    NSDictionary *headers = [command.arguments objectAtIndex:1];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:2] doubleValue];

+    [self setRequestHeaders: headers forManager: manager];
+    [self setTimeout:timeoutInSeconds forManager:manager];
+    [self setRedirect: manager];
+
+    CordovaHttpPlugin* __weak weakSelf = self;
+    manager.responseSerializer = [AFHTTPResponseSerializer serializer];
+    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];
+
+    @try {
+        [manager HEAD:url parameters:nil success:^(NSURLSessionTask *task) {
+            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
+            // no 'body' for HEAD request, omitting 'data'
+            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:nil];
+
+            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:dictionary];
+            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
+        } failure:^(NSURLSessionTask *task, NSError *error) {
+            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
+            [self handleError:dictionary withResponse:(NSHTTPURLResponse*)task.response error:error];
+
+            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:dictionary];
+            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
+        }];
+    }
+    @catch (NSException *exception) {
+        [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
+        [self handleException:exception withCommand:command];
+    }
+}
+
+- (void)delete:(CDVInvokedUrlCommand*)command {
+    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
+    manager.securityPolicy = securityPolicy;
+
+    NSString *url = [command.arguments objectAtIndex:0];
+    NSDictionary *headers = [command.arguments objectAtIndex:1];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:2] doubleValue];

    [self setRequestSerializer: @"default" forManager: manager];
    [self setRequestHeaders: headers forManager: manager];
@@ -221,7 +261,49 @@
    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];

    @try {
-        [manager GET:url parameters:parameters progress:nil success:^(NSURLSessionTask *task, id responseObject) {
+        [manager DELETE:url parameters:nil success:^(NSURLSessionTask *task, id responseObject) {
+            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
+            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];
+
+            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:dictionary];
+            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
+        } failure:^(NSURLSessionTask *task, NSError *error) {
+            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
+            [self handleError:dictionary withResponse:(NSHTTPURLResponse*)task.response error:error];
+
+            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:dictionary];
+            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
+        }];
+    }
+    @catch (NSException *exception) {
+        [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
+        [self handleException:exception withCommand:command];
+    }
+}
+
+- (void)post:(CDVInvokedUrlCommand*)command {
+    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
+    manager.securityPolicy = securityPolicy;
+
+    NSString *url = [command.arguments objectAtIndex:0];
+    NSDictionary *data = [command.arguments objectAtIndex:1];
+    NSString *serializerName = [command.arguments objectAtIndex:2];
+    NSDictionary *headers = [command.arguments objectAtIndex:3];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:4] doubleValue];
+
+    [self setRequestSerializer: serializerName forManager: manager];
+    [self setRequestHeaders: headers forManager: manager];
+    [self setTimeout:timeoutInSeconds forManager:manager];
+    [self setRedirect: manager];
+
+    CordovaHttpPlugin* __weak weakSelf = self;
+    manager.responseSerializer = [TextResponseSerializer serializer];
+    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];
+
+    @try {
+        [manager POST:url parameters:data success:^(NSURLSessionTask *task, id responseObject) {
            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];

@@ -248,7 +330,7 @@
    manager.securityPolicy = securityPolicy;

    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
+    NSDictionary *data = [command.arguments objectAtIndex:1];
    NSString *serializerName = [command.arguments objectAtIndex:2];
    NSDictionary *headers = [command.arguments objectAtIndex:3];
    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:4] doubleValue];
@@ -263,7 +345,7 @@
    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];

    @try {
-        [manager PUT:url parameters:parameters success:^(NSURLSessionTask *task, id responseObject) {
+        [manager PUT:url parameters:data success:^(NSURLSessionTask *task, id responseObject) {
            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];

@@ -290,7 +372,7 @@
    manager.securityPolicy = securityPolicy;

    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
+    NSDictionary *data = [command.arguments objectAtIndex:1];
    NSString *serializerName = [command.arguments objectAtIndex:2];
    NSDictionary *headers = [command.arguments objectAtIndex:3];
    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:4] doubleValue];
@@ -305,7 +387,7 @@
    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];

    @try {
-        [manager PATCH:url parameters:parameters success:^(NSURLSessionTask *task, id responseObject) {
+        [manager PATCH:url parameters:data success:^(NSURLSessionTask *task, id responseObject) {
            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];

@@ -327,97 +409,15 @@
    }
 }

- (void)delete:(CDVInvokedUrlCommand*)command {
-    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
-    manager.securityPolicy = securityPolicy;
-
-    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
-    NSDictionary *headers = [command.arguments objectAtIndex:2];
-    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:3] doubleValue];
-
-    [self setRequestSerializer: @"default" forManager: manager];
-    [self setRequestHeaders: headers forManager: manager];
-    [self setTimeout:timeoutInSeconds forManager:manager];
-    [self setRedirect: manager];
-
-    CordovaHttpPlugin* __weak weakSelf = self;
-    manager.responseSerializer = [TextResponseSerializer serializer];
-    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];
-
-    @try {
-        [manager DELETE:url parameters:parameters success:^(NSURLSessionTask *task, id responseObject) {
-            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
-            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];
-
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:dictionary];
-            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
-        } failure:^(NSURLSessionTask *task, NSError *error) {
-            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
-            [self handleError:dictionary withResponse:(NSHTTPURLResponse*)task.response error:error];
-
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:dictionary];
-            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
-        }];
-    }
-    @catch (NSException *exception) {
-        [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
-        [self handleException:exception withCommand:command];
-    }
-}
-
- (void)head:(CDVInvokedUrlCommand*)command {
-    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
-    manager.securityPolicy = securityPolicy;
-    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
-    NSDictionary *headers = [command.arguments objectAtIndex:2];
-    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:3] doubleValue];
-
-    [self setRequestHeaders: headers forManager: manager];
-    [self setTimeout:timeoutInSeconds forManager:manager];
-    [self setRedirect: manager];
-
-    CordovaHttpPlugin* __weak weakSelf = self;
-    manager.responseSerializer = [AFHTTPResponseSerializer serializer];
-    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];
-
-    @try {
-        [manager HEAD:url parameters:parameters success:^(NSURLSessionTask *task) {
-            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
-            // no 'body' for HEAD request, omitting 'data'
-            [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:nil];
-
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:dictionary];
-            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
-        } failure:^(NSURLSessionTask *task, NSError *error) {
-            NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
-            [self handleError:dictionary withResponse:(NSHTTPURLResponse*)task.response error:error];
-
-            CDVPluginResult *pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsDictionary:dictionary];
-            [weakSelf.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
-            [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
-        }];
-    }
-    @catch (NSException *exception) {
-        [[SDNetworkActivityIndicator sharedActivityIndicator] stopActivity];
-        [self handleException:exception withCommand:command];
-    }
-}
-
 - (void)uploadFile:(CDVInvokedUrlCommand*)command {
    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
    manager.securityPolicy = securityPolicy;

    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
-    NSDictionary *headers = [command.arguments objectAtIndex:2];
-    NSString *filePath = [command.arguments objectAtIndex: 3];
-    NSString *name = [command.arguments objectAtIndex: 4];
-    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:5] doubleValue];
+    NSDictionary *headers = [command.arguments objectAtIndex:1];
+    NSString *filePath = [command.arguments objectAtIndex: 2];
+    NSString *name = [command.arguments objectAtIndex: 3];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:4] doubleValue];

    NSURL *fileURL = [NSURL URLWithString: filePath];

@@ -430,7 +430,7 @@
    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];

    @try {
-        [manager POST:url parameters:parameters constructingBodyWithBlock:^(id<AFMultipartFormData> formData) {
+        [manager POST:url parameters:nil constructingBodyWithBlock:^(id<AFMultipartFormData> formData) {
            NSError *error;
            [formData appendPartWithFileURL:fileURL name:name error:&error];
            if (error) {
@@ -464,16 +464,14 @@
    }
 }

-
 - (void)downloadFile:(CDVInvokedUrlCommand*)command {
    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
    manager.securityPolicy = securityPolicy;

    NSString *url = [command.arguments objectAtIndex:0];
-    NSDictionary *parameters = [command.arguments objectAtIndex:1];
-    NSDictionary *headers = [command.arguments objectAtIndex:2];
-    NSString *filePath = [command.arguments objectAtIndex: 3];
-    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:4] doubleValue];
+    NSDictionary *headers = [command.arguments objectAtIndex:1];
+    NSString *filePath = [command.arguments objectAtIndex: 2];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:3] doubleValue];

    [self setRequestHeaders: headers forManager: manager];
    [self setTimeout:timeoutInSeconds forManager:manager];
@@ -488,7 +486,7 @@
    [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];

    @try {
-        [manager GET:url parameters:parameters progress:nil success:^(NSURLSessionTask *task, id responseObject) {
+        [manager GET:url parameters:nil success:^(NSURLSessionTask *task, id responseObject) {
            /*
             *
             * Licensed to the Apache Software Foundation (ASF) under one
--- a/test/e2e-app-template/build.json
+++ b/test/e2e-app-template/build.json
--- a/test/e2e-app-template/config.xml
+++ b/test/e2e-app-template/config.xml
--- a/test/e2e-app-template/package.json
+++ b/test/e2e-app-template/package.json
--- a/test/e2e-app-template/www/certificates/.gitkeep
+++ b/test/e2e-app-template/www/certificates/.gitkeep
--- a/test/e2e-app-template/www/index.css
+++ b/test/e2e-app-template/www/index.css
--- a/test/e2e-app-template/www/index.html
+++ b/test/e2e-app-template/www/index.html
@@ -15,7 +15,7 @@
        <button id="nextBtn">Run next test</button>

        <script type="text/javascript" src="cordova.js"></script>
-        <script type="text/javascript" src="app-test-definitions.js"></script>
+        <script type="text/javascript" src="e2e-specs.js"></script>
        <script type="text/javascript" src="index.js"></script>
    </body>
 </html>
--- a/test/e2e-app-template/www/index.js
+++ b/test/e2e-app-template/www/index.js
--- a/test/app-test-definitions.js
+++ b/test/app-test-definitions.js
@@ -1,14 +1,14 @@
 const hooks = {
  onBeforeEachTest: function(done) {
    cordova.plugin.http.clearCookies();
-    helpers.setDefaultCertMode(done);
+    helpers.setDefaultServerTrustMode(done);
  }
 };

 const helpers = {
-  setDefaultCertMode: function(done) { cordova.plugin.http.setSSLCertMode('default', done, done); },
-  setNoCheckCertMode: function(done) { cordova.plugin.http.setSSLCertMode('nocheck', done, done); },
-  setPinnedCertMode: function(done) { cordova.plugin.http.setSSLCertMode('pinned', done, done); },
+  setDefaultServerTrustMode: function(done) { cordova.plugin.http.setServerTrustMode('default', done, done); },
+  setNoCheckServerTrustMode: function(done) { cordova.plugin.http.setServerTrustMode('nocheck', done, done); },
+  setPinnedServerTrustMode: function(done) { cordova.plugin.http.setServerTrustMode('pinned', done, done); },
  setJsonSerializer: function(done) { done(cordova.plugin.http.setDataSerializer('json')); },
  setUtf8StringSerializer: function(done) { done(cordova.plugin.http.setDataSerializer('utf8')); },
  setUrlEncodedSerializer: function(done) { done(cordova.plugin.http.setDataSerializer('urlencoded')); },
@@ -38,7 +38,7 @@ const helpers = {
 };

 const messageFactory = {
-  sslTrustAnchor: function() { return 'SSL handshake failed: javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.' },
+  sslTrustAnchor: function() { return 'TLS connection could not be established: javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.' },
  invalidCertificate: function(domain) { return 'The certificate for this server is invalid. You might be connecting to a server that is pretending to be “' + domain + '” which could put your confidential information at risk.' }
 }

@@ -51,7 +51,8 @@ const tests = [
      result.type.should.be.equal('rejected');
      result.data.should.be.eql({ status: -2, error: targetInfo.isAndroid ? messageFactory.sslTrustAnchor() : messageFactory.invalidCertificate('self-signed.badssl.com') });
    }
-  },{
+  },
+  {
    description: 'should reject self signed cert (PUT)',
    expected: 'rejected: {"status":-2, ...',
    func: function(resolve, reject) { cordova.plugin.http.put('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
@@ -59,7 +60,8 @@ const tests = [
      result.type.should.be.equal('rejected');
      result.data.should.be.eql({ status: -2, error: targetInfo.isAndroid ? messageFactory.sslTrustAnchor() : messageFactory.invalidCertificate('self-signed.badssl.com') });
    }
-  },{
+  },
+  {
    description: 'should reject self signed cert (POST)',
    expected: 'rejected: {"status":-2, ...',
    func: function(resolve, reject) { cordova.plugin.http.post('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
@@ -67,7 +69,8 @@ const tests = [
      result.type.should.be.equal('rejected');
      result.data.should.be.eql({ status: -2, error: targetInfo.isAndroid ? messageFactory.sslTrustAnchor() : messageFactory.invalidCertificate('self-signed.badssl.com') });
    }
-  },{
+  },
+  {
    description: 'should reject self signed cert (PATCH)',
    expected: 'rejected: {"status":-2, ...',
    func: function(resolve, reject) { cordova.plugin.http.patch('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
@@ -75,7 +78,8 @@ const tests = [
      result.type.should.be.equal('rejected');
      result.data.should.be.eql({ status: -2, error: targetInfo.isAndroid ? messageFactory.sslTrustAnchor() : messageFactory.invalidCertificate('self-signed.badssl.com') });
    }
-  },{
+  },
+  {
    description: 'should reject self signed cert (DELETE)',
    expected: 'rejected: {"status":-2, ...',
    func: function(resolve, reject) { cordova.plugin.http.delete('https://self-signed.badssl.com/', {}, {}, resolve, reject); },
@@ -83,61 +87,68 @@ const tests = [
      result.type.should.be.equal('rejected');
      result.data.should.be.eql({ status: -2, error: targetInfo.isAndroid ? messageFactory.sslTrustAnchor() : messageFactory.invalidCertificate('self-signed.badssl.com') });
    }
-  },{
+  },
+  {
    description: 'should accept bad cert (GET)',
    expected: 'resolved: {"status":200, ...',
-    before: helpers.setNoCheckCertMode,
+    before: helpers.setNoCheckServerTrustMode,
    func: function(resolve, reject) { cordova.plugin.http.get('https://self-signed.badssl.com/', {}, {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('resolved');
      result.data.should.include({ status: 200 });
    }
-  },{
+  },
+  {
    description: 'should accept bad cert (PUT)',
    expected: 'rejected: {"status":405, ... // will be rejected because PUT is not allowed',
-    before: helpers.setNoCheckCertMode,
+    before: helpers.setNoCheckServerTrustMode,
    func: function(resolve, reject) { cordova.plugin.http.put('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('rejected');
      result.data.should.include({ status: 405 });
    }
-  },{
+  },
+  {
    description: 'should accept bad cert (POST)',
    expected: 'rejected: {"status":405, ... // will be rejected because POST is not allowed',
-    before: helpers.setNoCheckCertMode,
+    before: helpers.setNoCheckServerTrustMode,
    func: function(resolve, reject) { cordova.plugin.http.post('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('rejected');
      result.data.should.include({ status: 405 });
    }
-  },{
+  },
+  {
    description: 'should accept bad cert (PATCH)',
    expected: 'rejected: {"status":405, ... // will be rejected because PATCH is not allowed',
-    before: helpers.setNoCheckCertMode,
+    before: helpers.setNoCheckServerTrustMode,
    func: function(resolve, reject) { cordova.plugin.http.patch('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('rejected');
      result.data.should.include({ status: 405 });
    }
-  },{
+  },
+  {
    description: 'should accept bad cert (DELETE)',
    expected: 'rejected: {"status":405, ... // will be rejected because DELETE is not allowed',
-    before: helpers.setNoCheckCertMode,
+    before: helpers.setNoCheckServerTrustMode,
    func: function(resolve, reject) { cordova.plugin.http.delete('https://self-signed.badssl.com/', {}, {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('rejected');
      result.data.should.include({ status: 405 });
    }
-  },{
+  },
+  {
    description: 'should fetch data from http://httpbin.org/ (GET)',
    expected: 'resolved: {"status":200, ...',
-    before: helpers.setNoCheckCertMode,
+    before: helpers.setNoCheckServerTrustMode,
    func: function(resolve, reject) { cordova.plugin.http.get('http://httpbin.org/', {}, {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('resolved');
      result.data.should.include({ status: 200 });
    }
-  },{
+  },
+  {
    description: 'should send JSON object correctly (POST)',
    expected: 'resolved: {"status": 200, "data": "{\\"json\\":\\"test\\": \\"testString\\"}\" ...',
    before: helpers.setJsonSerializer,
@@ -146,7 +157,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).json.should.eql({ test: 'testString' });
    }
-  },{
+  },
+  {
    description: 'should send JSON object correctly (PUT)',
    expected: 'resolved: {"status": 200, "data": "{\\"json\\":\\"test\\": \\"testString\\"}\" ...',
    before: helpers.setJsonSerializer,
@@ -155,7 +167,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).json.should.eql({ test: 'testString' });
    }
-  },{
+  },
+  {
    description: 'should send JSON object correctly (PATCH)',
    expected: 'resolved: {"status": 200, "data": "{\\"json\\":\\"test\\": \\"testString\\"}\" ...',
    before: helpers.setJsonSerializer,
@@ -164,7 +177,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).json.should.eql({ test: 'testString' });
    }
-  },{
+  },
+  {
    description: 'should send JSON array correctly (POST) #26',
    expected: 'resolved: {"status": 200, "data": "[ 1, 2, 3 ]\" ...',
    before: helpers.setJsonSerializer,
@@ -173,7 +187,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).json.should.eql([ 1, 2, 3 ]);
    }
-  },{
+  },
+  {
    description: 'should send JSON array correctly (PUT) #26',
    expected: 'resolved: {"status": 200, "data": "[ 1, 2, 3 ]\" ...',
    before: helpers.setJsonSerializer,
@@ -182,7 +197,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).json.should.eql([ 1, 2, 3 ]);
    }
-  },{
+  },
+  {
    description: 'should send JSON array correctly (PATCH) #26',
    expected: 'resolved: {"status": 200, "data": "[ 1, 2, 3 ]\" ...',
    before: helpers.setJsonSerializer,
@@ -192,7 +208,8 @@ const tests = [
      result.data.data.should.be.a('string');
      JSON.parse(result.data.data).json.should.eql([ 1, 2, 3 ]);
    }
-  },{
+  },
+  {
    description: 'should send url encoded data correctly (POST) #41',
    expected: 'resolved: {"status": 200, "data": "{\\"form\\":\\"test\\": \\"testString\\"}\" ...',
    before: helpers.setUrlEncodedSerializer,
@@ -201,7 +218,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).form.should.eql({ test: 'testString' });
    }
-  },{
+  },
+  {
    description: 'should send url encoded data correctly (PUT)',
    expected: 'resolved: {"status": 200, "data": "{\\"form\\":\\"test\\": \\"testString\\"}\" ...',
    before: helpers.setUrlEncodedSerializer,
@@ -210,7 +228,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).form.should.eql({ test: 'testString' });
    }
-  },{
+  },
+  {
    description: 'should send url encoded data correctly (PATCH)',
    expected: 'resolved: {"status": 200, "data": "{\\"form\\":\\"test\\": \\"testString\\"}\" ...',
    before: helpers.setUrlEncodedSerializer,
@@ -219,7 +238,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).form.should.eql({ test: 'testString' });
    }
-  },{
+  },
+  {
    description: 'should resolve correct URL after redirect (GET) #33',
    expected: 'resolved: {"status": 200, url: "http://httpbin.org/anything", ...',
    func: function(resolve, reject) { cordova.plugin.http.get('http://httpbin.org/redirect-to?url=http://httpbin.org/anything', {}, {}, resolve, reject); },
@@ -227,7 +247,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      result.data.url.should.be.equal('http://httpbin.org/anything');
    }
-  },{
+  },
+  {
    description: 'should download a file from given URL to given path in local filesystem',
    expected: 'resolved: {"content": "<?xml version=\'1.0\' encoding=\'us-ascii\'?>\\n\\n<!--  A SAMPLE set of slides  -->" ...',
    func: function(resolve, reject) {
@@ -251,7 +272,8 @@ const tests = [
      result.data.name.should.be.equal('test.xml');
      result.data.content.should.be.equal("<?xml version='1.0' encoding='us-ascii'?>\n\n<!--  A SAMPLE set of slides  -->\n\n<slideshow \n    title=\"Sample Slide Show\"\n    date=\"Date of publication\"\n    author=\"Yours Truly\"\n    >\n\n    <!-- TITLE SLIDE -->\n    <slide type=\"all\">\n      <title>Wake up to WonderWidgets!</title>\n    </slide>\n\n    <!-- OVERVIEW -->\n    <slide type=\"all\">\n        <title>Overview</title>\n        <item>Why <em>WonderWidgets</em> are great</item>\n        <item/>\n        <item>Who <em>buys</em> WonderWidgets</item>\n    </slide>\n\n</slideshow>");
    }
-  },{
+  },
+  {
    description: 'should upload a file from given path in local filesystem to given URL #27',
    expected: 'resolved: {"status": 200, "data": "files": {"test-file.txt": "I am a dummy file. I am used ...',
    func: function(resolve, reject) {
@@ -276,7 +298,8 @@ const tests = [
        .files[fileName]
        .should.be.equal(fileContent);
    }
-  },{
+  },
+  {
    description: 'should encode HTTP array params correctly (GET) #45',
    expected: 'resolved: {"status": 200, "data": "{\\"url\\":\\"http://httpbin.org/get?myArray[]=val1&myArray[]=val2&myArray[]=val3\\"}\" ...',
    func: function(resolve, reject) {
@@ -291,7 +314,8 @@ const tests = [
        .url
        .should.include('httpbin.org/get?myArray[]=val1&myArray[]=val2&myArray[]=val3&myString=testString');
    }
-  },{
+  },
+  {
    description: 'should throw on non-string values in local header object #54',
    expected: 'throwed: {"message": "advanced-http: header values must be strings"}',
    func: function(resolve, reject) {
@@ -301,7 +325,8 @@ const tests = [
      result.type.should.be.equal('throwed');
      result.message.should.be.equal('advanced-http: header values must be strings');
    }
-  },{
+  },
+  {
    description: 'should throw an error while setting non-string value as global header #54',
    expected: 'throwed: "advanced-http: header values must be strings"',
    func: function(resolve, reject) {
@@ -311,7 +336,8 @@ const tests = [
      result.type.should.be.equal('throwed');
      result.message.should.be.equal('advanced-http: header values must be strings');
    }
-  },{
+  },
+  {
    description: 'should accept content-type "application/xml" #58',
    expected: 'resolved: {"status": 200, ...',
    func: function(resolve, reject) {
@@ -321,7 +347,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      result.data.status.should.be.equal(200);
    }
-  },{
+  },
+  {
    description: 'should send programmatically set cookies correctly (GET)',
    expected: 'resolved: {"status": 200, ...',
    func: function(resolve, reject) {
@@ -339,7 +366,8 @@ const tests = [
        .Cookie
        .should.be.equal('myCookie=myValue; mySecondCookie=mySecondValue');
    }
-  },{
+  },
+  {
    description: 'should not send any cookies after running "clearCookies" (GET) #59',
    expected: 'resolved: {"status": 200, "data": "{\"headers\": {\"Cookie\": \"\"...',
    func: function(resolve, reject) {
@@ -355,10 +383,10 @@ const tests = [
      JSON
        .parse(result.data.data)
        .headers
-        .Cookie
-        .should.be.equal('');
+        .should.not.have.property('Cookie');
    }
-  },{
+  },
+  {
    description: 'should send programmatically set cookies correctly (DOWNLOAD) #57',
    expected: 'resolved: {"content":{"cookies":{"myCookie":"myValue ...',
    func: function(resolve, reject) {
@@ -390,7 +418,8 @@ const tests = [
      cookies.myCookie.should.be.equal('myValue');
      cookies.mySecondCookie.should.be.equal('mySecondValue');
    }
-  },{
+  },
+  {
    description: 'should send UTF-8 encoded raw string correctly (POST) #34',
    expected: 'resolved: {"status": 200, "data": "{\\"data\\": \\"this is a test string\\"...',
    before: helpers.setUtf8StringSerializer,
@@ -401,7 +430,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).data.should.be.equal('this is a test string');
    }
-  },{
+  },
+  {
    description: 'should encode spaces in query string (params object) correctly (GET) #71',
    expected: 'resolved: {"status": 200, "data": "{\\"args\\": \\"query param\\": \\"and value with spaces\\"...',
    func: function(resolve, reject) {
@@ -411,7 +441,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).args['query param'].should.be.equal('and value with spaces');
    }
-  },{
+  },
+  {
    description: 'should decode latin1 (iso-8859-1) encoded body correctly (GET) #72',
    expected: 'resolved: {"status": 200, "data": "<!DOCTYPE HTML PUBLIC \\"-//W3C//DTD HTML 4.01 Transitional//EN\\"> ...',
    func: function(resolve, reject) {
@@ -421,7 +452,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      result.data.data.should.include('[¡]  161  10/01  241  A1  INVERTED EXCLAMATION MARK\n[¢]  162  10/02  242  A2  CENT SIGN');
    }
-  },{
+  },
+  {
    description: 'should return empty body string correctly (GET)',
    expected: 'resolved: {"status": 200, "data": "" ...',
    func: function(resolve, reject) {
@@ -431,10 +463,11 @@ const tests = [
      result.type.should.be.equal('resolved');
      result.data.data.should.be.equal('');
    }
-  },{
+  },
+  {
    description: 'should pin SSL cert correctly (GET)',
    expected: 'resolved: {"status": 200 ...',
-    before: helpers.setPinnedCertMode,
+    before: helpers.setPinnedServerTrustMode,
    func: function(resolve, reject) {
      cordova.plugin.http.get('https://httpbin.org', {}, {}, resolve, reject);
    },
@@ -442,10 +475,11 @@ const tests = [
      result.type.should.be.equal('resolved');
      result.data.status.should.be.equal(200);
    }
-  },{
+  },
+  {
    description: 'should reject when pinned cert does not match received server cert (GET)',
    expected: 'rejected: {"status": -2 ...',
-    before: helpers.setPinnedCertMode,
+    before: helpers.setPinnedServerTrustMode,
    func: function(resolve, reject) {
      cordova.plugin.http.get('https://sha512.badssl.com/', {}, {}, resolve, reject);
    },
@@ -453,7 +487,8 @@ const tests = [
      result.type.should.be.equal('rejected');
      result.data.should.be.eql({ status: -2, error: targetInfo.isAndroid ? messageFactory.sslTrustAnchor() : messageFactory.invalidCertificate('sha512.badssl.com') });
    }
-  },{
+  },
+  {
    description: 'should send deeply structured JSON object correctly (POST) #65',
    expected: 'resolved: {"status": 200, "data": "{\\"data\\": \\"{\\\\"outerObj\\\\":{\\\\"innerStr\\\\":\\\\"testString\\\\",\\\\"innerArr\\\\":[1,2,3]}}\\" ...',
    before: helpers.setJsonSerializer,
@@ -462,7 +497,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).json.should.eql({ outerObj: { innerStr: 'testString', innerArr: [1, 2, 3] }});
    }
-  },{
+  },
+  {
    description: 'should override header "content-type" correctly (POST) #78',
    expected: 'resolved: {"status": 200, "headers": "{\\"Content-Type\\": \\"text/plain\\" ...',
    before: helpers.setJsonSerializer,
@@ -471,7 +507,8 @@ const tests = [
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).headers['Content-Type'].should.be.equal('text/plain');
    }
-  },{
+  },
+  {
    description: 'should handle error during file download correctly (DOWNLOAD) #83',
    expected: 'rejected: {"status": 403, "error": "There was an error downloading the file" ...',
    func: function(resolve, reject) { cordova.plugin.http.downloadFile('http://httpbin.org/status/403', {}, {}, cordova.file.tempDirectory + 'testfile.txt', resolve, reject); },
@@ -480,7 +517,8 @@ const tests = [
      result.data.status.should.be.equal(403);
      result.data.error.should.be.equal('There was an error downloading the file');
    }
-  },{
+  },
+  {
    description: 'should handle gzip encoded response correctly',
    expected: 'resolved: {"status": 200, "headers": "{\\"Content-Encoding\\": \\"gzip\\" ...',
    func: function(resolve, reject) { cordova.plugin.http.get('http://httpbin.org/gzip', {}, {}, resolve, reject); },
@@ -489,15 +527,69 @@ const tests = [
      result.data.status.should.be.equal(200);
      JSON.parse(result.data.data).gzipped.should.be.equal(true);
    }
-  },{
+  },
+  {
    description: 'should send empty string correctly',
-    expected: 'resolved: {"status": 200, "data": "{\\"json\\":\\"test\\": \\"testString\\"}\" ...',
+    expected: 'resolved: {"status": 200, "data": "{\\"json\\":\\"\\" ...',
    before: helpers.setUtf8StringSerializer,
    func: function(resolve, reject) { cordova.plugin.http.post('http://httpbin.org/anything', '', {}, resolve, reject); },
    validationFunc: function(driver, result) {
      result.type.should.be.equal('resolved');
      JSON.parse(result.data.data).data.should.be.equal('');
    }
+  },
+  {
+    description: 'shouldn\'t escape forward slashes #184',
+    expected: 'resolved: {"status": 200, "data": "{\\"json\\":\\"/\\" ...',
+    before: helpers.setJsonSerializer,
+    func: function(resolve, reject) { cordova.plugin.http.post('http://httpbin.org/anything', { testString: '/' }, {}, resolve, reject); },
+    validationFunc: function(driver, result) {
+      result.type.should.be.equal('resolved');
+      JSON.parse(result.data.data).json.testString.should.be.equal('/');
+    }
+  },
+  {
+    description: 'should not double encode spaces in url path #195',
+    expected: 'resolved: {"status": 200, "data": "{\\"url\\":\\"https://httpbin.org/anything/containing spaces in url\\" ...',
+    func: function(resolve, reject) { cordova.plugin.http.get('https://httpbin.org/anything/containing%20spaces%20in%20url', {}, {}, resolve, reject); },
+    validationFunc: function(driver, result) {
+      result.type.should.be.equal('resolved');
+      JSON.parse(result.data.data).url.should.be.equal('https://httpbin.org/anything/containing spaces in url');
+    }
+  },
+  {
+    description: 'should encode spaces in url query correctly',
+    expected: 'resolved: {"status": 200, "data": "{\\"url\\":\\"https://httpbin.org/anything?query key=very long query value with spaces\\" ...',
+    func: function(resolve, reject) { cordova.plugin.http.get('https://httpbin.org/anything', { 'query key': 'very long query value with spaces' }, {}, resolve, reject); },
+    validationFunc: function(driver, result) {
+      result.type.should.be.equal('resolved');
+      JSON.parse(result.data.data).url.should.be.equal('https://httpbin.org/anything?query key=very long query value with spaces');
+    }
+  },
+  {
+    description: 'should download a file from given HTTPS URL to given path in local filesystem #197',
+    expected: 'resolved: {"content": "<?xml version=\'1.0\' encoding=\'us-ascii\'?>\\n\\n<!--  A SAMPLE set of slides  -->" ...',
+    func: function(resolve, reject) {
+      var sourceUrl = 'https://httpbin.org/xml';
+      var targetPath = cordova.file.cacheDirectory + 'test.xml';
+
+      cordova.plugin.http.downloadFile(sourceUrl, {}, {}, targetPath, function(entry) {
+        helpers.getWithXhr(function(content) {
+          resolve({
+            sourceUrl: sourceUrl,
+            targetPath: targetPath,
+            fullPath: entry.fullPath,
+            name: entry.name,
+            content: content
+          });
+        }, targetPath);
+      }, reject);
+    },
+    validationFunc: function(driver, result) {
+      result.type.should.be.equal('resolved');
+      result.data.name.should.be.equal('test.xml');
+      result.data.content.should.be.equal("<?xml version='1.0' encoding='us-ascii'?>\n\n<!--  A SAMPLE set of slides  -->\n\n<slideshow \n    title=\"Sample Slide Show\"\n    date=\"Date of publication\"\n    author=\"Yours Truly\"\n    >\n\n    <!-- TITLE SLIDE -->\n    <slide type=\"all\">\n      <title>Wake up to WonderWidgets!</title>\n    </slide>\n\n    <!-- OVERVIEW -->\n    <slide type=\"all\">\n        <title>Overview</title>\n        <item>Why <em>WonderWidgets</em> are great</item>\n        <item/>\n        <item>Who <em>buys</em> WonderWidgets</item>\n    </slide>\n\n</slideshow>");
+    }
  }
 ];

--- a/test/app-mocha-specs/helpers/apps.js
+++ b/test/app-mocha-specs/helpers/apps.js
--- a/test/app-mocha-specs/helpers/caps.js
+++ b/test/app-mocha-specs/helpers/caps.js
@@ -18,6 +18,7 @@ const local = {
    platformVersion: '5.1',
    deviceName: 'Android Emulator',
    autoWebview: true,
+    fullReset: true,
    app: undefined // will be set later
  }
 };
--- a/test/app-mocha-specs/helpers/logging.js
+++ b/test/app-mocha-specs/helpers/logging.js
--- a/test/app-mocha-specs/helpers/server.js
+++ b/test/app-mocha-specs/helpers/server.js
--- a/test/app-mocha-specs/helpers/setup.js
+++ b/test/app-mocha-specs/helpers/setup.js
--- a/test/app-mocha-specs/test.js
+++ b/test/app-mocha-specs/test.js
@@ -4,7 +4,7 @@ const wd = require('wd');
 const apps = require('./helpers/apps');
 const caps = Object.assign({}, require('./helpers/caps'));
 const serverConfig = require('./helpers/server');
-const testDefinitions = require('../app-test-definitions');
+const testDefinitions = require('../e2e-specs');
 const pkgjson = require('../../package.json');

 describe('Advanced HTTP', function() {
--- a/test/js-mocha-specs.js
+++ b/test/js-mocha-specs.js
@@ -1,133 +0,0 @@
-const chai = require('chai');
-const mock = require('mock-require');
-const path = require('path');
-
-const should = chai.should();
-
-const HELPERS_ID = path.resolve(__dirname, '..', 'www', 'helpers');
-const PLUGIN_ID = path.resolve(__dirname, '..', 'www', 'advanced-http');
-
-describe('Advanced HTTP www interface', function() {
-  let http = {};
-  let helpers = {};
-
-  const noop = () => { /* intentionally doing nothing */ };
-
-  const loadHttp = () => {
-    mock(`${PLUGIN_ID}.helpers`, mock.reRequire('../www/helpers'));
-    http = mock.reRequire('../www/advanced-http');
-  };
-
-  this.timeout(900000);
-
-  beforeEach(() => {
-    // mocked btoa function (base 64 encoding strings)
-    global.btoa = decoded => new Buffer(decoded).toString('base64');
-
-    mock('cordova/exec', noop);
-    mock(`${PLUGIN_ID}.cookie-handler`, {});
-    mock(`${HELPERS_ID}.cookie-handler`, {});
-    mock(`${HELPERS_ID}.messages`, require('../www/messages'));
-
-    loadHttp();
-  });
-
-  it('sets global headers correctly with two args (old interface)', () => {
-    http.setHeader('myKey', 'myValue');
-    http.getHeaders('*').myKey.should.equal('myValue');
-  });
-
-  it('sets global headers correctly with three args (new interface) #24', () => {
-    http.setHeader('*', 'myKey', 'myValue');
-    http.getHeaders('*').myKey.should.equal('myValue');
-  });
-
-  it('sets host headers correctly #24', () => {
-    http.setHeader('www.google.de', 'myKey', 'myValue');
-    http.getHeaders('www.google.de').myKey.should.equal('myValue');
-  });
-
-  it('resolves global headers correctly #24', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
-
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
-      headers.should.eql({
-        Cookie: 'fakeCookieString',
-        myKey: 'myValue'
-      });
-    });
-
-    loadHttp();
-
-    http.setHeader('*', 'myKey', 'myValue');
-    http.get('url', {}, {}, noop, noop);
-  });
-
-  it('resolves host headers correctly (set without port number) #37', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
-
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
-      headers.should.eql({
-        Cookie: 'fakeCookieString',
-        myKey: 'myValue'
-      });
-    });
-
-    loadHttp();
-
-    http.setHeader('www.google.de', 'myKey', 'myValue');
-    http.get('https://www.google.de/?gws_rd=ssl', {}, {}, noop, noop);
-  });
-
-  it('resolves host headers correctly (set with port number) #37', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
-
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
-      headers.should.eql({
-        Cookie: 'fakeCookieString',
-        myKey: 'myValue'
-      });
-    });
-
-    loadHttp();
-
-    http.setHeader('www.google.de:8080', 'myKey', 'myValue');
-    http.get('https://www.google.de:8080/?gws_rd=ssl', {}, {}, noop, noop);
-  });
-
-  it('resolves request headers correctly', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
-
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
-      headers.should.eql({
-        Cookie: 'fakeCookieString',
-        myKey: 'myValue'
-      });
-    });
-
-    loadHttp();
-
-    http.get('https://www.google.de/?gws_rd=ssl', {}, { myKey: 'myValue' }, noop, noop);
-  });
-
-  it('sets basic authentication header correctly #36', () => {
-    http.useBasicAuth('name', 'pass');
-    http.getHeaders('*').Authorization.should.equal('Basic bmFtZTpwYXNz');
-  });
-
-  it('throws an Error when you try to add a cookie by using "setHeader" #46', () => {
-    (function() { http.setHeader('*', 'cookie', 'value') }).should.throw();
-  });
-});
--- a/test/js-specs.js
+++ b/test/js-specs.js
@@ -0,0 +1,264 @@
+const chai = require('chai');
+const mock = require('mock-require');
+const should = chai.should();
+
+describe('Advanced HTTP public interface', function () {
+  let http = {};
+
+  const noop = () => { /* intentionally doing nothing */ };
+
+  const getDependenciesBlueprint = () => {
+    const messages = require('../www/messages');
+    const globalConfigs = require('../www/global-configs');
+    const jsUtil = require('../www/js-util');
+    const ToughCookie = require('../www/umd-tough-cookie');
+    const lodash = require('../www/lodash');
+    const WebStorageCookieStore = require('../www/local-storage-store')(ToughCookie, lodash);
+    const cookieHandler = require('../www/cookie-handler')(null, ToughCookie, WebStorageCookieStore);
+    const helpers = require('../www/helpers')(jsUtil, cookieHandler, messages);
+    const urlUtil = require('../www/url-util')(jsUtil);
+
+    return { exec: noop, cookieHandler, urlUtil: urlUtil, helpers, globalConfigs };
+  };
+
+  const loadHttp = (deps) => {
+    http = require('../www/public-interface')(deps.exec, deps.cookieHandler, deps.urlUtil, deps.helpers, deps.globalConfigs);
+  };
+
+  beforeEach(() => {
+    // mocked btoa function (base 64 encoding strings)
+    global.btoa = decoded => new Buffer(decoded).toString('base64');
+    loadHttp(getDependenciesBlueprint());
+  });
+
+  it('sets global headers correctly with two args (old interface)', () => {
+    http.setHeader('myKey', 'myValue');
+    http.getHeaders('*').myKey.should.equal('myValue');
+  });
+
+  it('sets global headers correctly with three args (new interface) #24', () => {
+    http.setHeader('*', 'myKey', 'myValue');
+    http.getHeaders('*').myKey.should.equal('myValue');
+  });
+
+  it('sets host headers correctly #24', () => {
+    http.setHeader('www.google.de', 'myKey', 'myValue');
+    http.getHeaders('www.google.de').myKey.should.equal('myValue');
+  });
+
+  it('resolves global headers correctly #24', () => {
+    const deps = getDependenciesBlueprint();
+
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
+      headers.should.eql({
+        Cookie: 'fakeCookieString',
+        myKey: 'myValue'
+      });
+    };
+
+    loadHttp(deps);
+
+    http.setHeader('*', 'myKey', 'myValue');
+    http.get('url', {}, {}, noop, noop);
+  });
+
+  it('resolves host headers correctly (set without port number) #37', () => {
+    const deps = getDependenciesBlueprint();
+
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
+      headers.should.eql({
+        Cookie: 'fakeCookieString',
+        myKey: 'myValue'
+      });
+    };
+
+    loadHttp(deps);
+
+    http.setHeader('www.google.de', 'myKey', 'myValue');
+    http.get('https://www.google.de/?gws_rd=ssl', {}, {}, noop, noop);
+  });
+
+  it('resolves host headers correctly (set with port number) #37', () => {
+    const deps = getDependenciesBlueprint();
+
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
+      headers.should.eql({
+        Cookie: 'fakeCookieString',
+        myKey: 'myValue'
+      });
+    };
+
+    loadHttp(deps);
+
+    http.setHeader('www.google.de:8080', 'myKey', 'myValue');
+    http.get('https://www.google.de:8080/?gws_rd=ssl', {}, {}, noop, noop);
+  });
+
+  it('resolves request headers correctly', () => {
+    const deps = getDependenciesBlueprint();
+
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
+      headers.should.eql({
+        Cookie: 'fakeCookieString',
+        myKey: 'myValue'
+      });
+    };
+
+    loadHttp(deps);
+
+    http.get('https://www.google.de/?gws_rd=ssl', {}, { myKey: 'myValue' }, noop, noop);
+  });
+
+  it('sets basic authentication header correctly #36', () => {
+    http.useBasicAuth('name', 'pass');
+    http.getHeaders('*').Authorization.should.equal('Basic bmFtZTpwYXNz');
+  });
+
+  it('throws an Error when you try to add a cookie by using "setHeader" #46', () => {
+    (function () { http.setHeader('*', 'cookie', 'value') }).should.throw();
+  });
+});
+
+describe('URL util', function () {
+  const jsUtil = require('../www/js-util');
+  const util = require('../www/url-util')(jsUtil);
+
+  it('parses URL with protocol, hostname and path correctly', () => {
+    util.parseUrl('http://ilkimen.net/test').should.include({
+      protocol: 'http:',
+      host: 'ilkimen.net',
+      hostname: 'ilkimen.net',
+      pathname: '/test',
+      port: '',
+      search: '',
+      hash: ''
+    });
+  });
+
+  it('parses URL with protocol, hostname, port and path correctly', () => {
+    util.parseUrl('http://ilkimen.net:8080/test').should.include({
+      protocol: 'http:',
+      host: 'ilkimen.net:8080',
+      hostname: 'ilkimen.net',
+      pathname: '/test',
+      port: '8080',
+      search: '',
+      hash: ''
+    });
+  });
+
+  it('parses URL with protocol, hostname, port, path and query string correctly', () => {
+    util.parseUrl('http://ilkimen.net:8080/test?param=value').should.include({
+      protocol: 'http:',
+      host: 'ilkimen.net:8080',
+      hostname: 'ilkimen.net',
+      pathname: '/test',
+      port: '8080',
+      search: '?param=value',
+      hash: ''
+    });
+  });
+
+  it('parses URL with protocol, hostname, port, path, query string and hash param correctly', () => {
+    util.parseUrl('http://ilkimen.net:8080/test?param=value#myHash').should.include({
+      protocol: 'http:',
+      host: 'ilkimen.net:8080',
+      hostname: 'ilkimen.net',
+      pathname: '/test',
+      port: '8080',
+      search: '?param=value',
+      hash: '#myHash'
+    });
+  });
+
+  it('serializes query params correctly', () => {
+    util.serializeQueryParams({
+      strParam1: 'value with spaces',
+      strParam2: 'value with special character äöü%',
+      boolParam: true,
+      numberParam: 1,
+      nullParam: null,
+    }, false).should.equal('strParam1=value with spaces&strParam2=value with special character äöü%&boolParam=true&numberParam=1&nullParam=null');
+  });
+
+  it('serializes query params correctly with URL encoding enabled', () => {
+    util.serializeQueryParams({
+      'param 1': 'value with spaces',
+      'param 2': 'value with special character äöü%&'
+    }, true).should.equal('param%201=value%20with%20spaces&param%202=value%20with%20special%20character%20%C3%A4%C3%B6%C3%BC%25%26');
+  });
+
+  it('serializes array of query params correctly', () => {
+    util.serializeQueryParams({
+      myArray: ['val1', 'val2', 'val3'],
+      myString: 'testString'
+    }, false).should.equal('myArray[]=val1&myArray[]=val2&myArray[]=val3&myString=testString');
+  });
+
+  it('serializes deeply structured array of query params correctly', () => {
+    util.serializeQueryParams({
+      myArray: [['val1.1', 'val1.2', 'val1.3'], 'val2', 'val3'],
+      myString: 'testString'
+    }, false).should.equal('myArray[][]=val1.1&myArray[][]=val1.2&myArray[][]=val1.3&myArray[]=val2&myArray[]=val3&myString=testString');
+  });
+
+  it('serializes deeply structured object of query params correctly', () => {
+    util.serializeQueryParams({
+      myObject: { obj1: { 'param1.1': 'val1.1', 'param1.2': 'val1.2' }, param2: 'val2' }
+    }, false).should.equal('myObject[obj1][param1.1]=val1.1&myObject[obj1][param1.2]=val1.2&myObject[param2]=val2');
+  });
+
+  it('appends query params string correctly to given URL without query parameters', () => {
+    util.appendQueryParamsString('http://ilkimen.net/', 'param1=value1')
+      .should.equal('http://ilkimen.net/?param1=value1');
+  });
+
+  it('appends query params string correctly to given URL with existing query parameters', () => {
+    util.appendQueryParamsString('http://ilkimen.net/?myParam=myValue', 'param1=value1')
+      .should.equal('http://ilkimen.net/?myParam=myValue&param1=value1');
+  });
+
+  it('appends query params string correctly to given URL with existing query parameters and hash value', () => {
+    util.appendQueryParamsString('http://ilkimen.net/?myParam=myValue#myHash', 'param1=value1')
+      .should.equal('http://ilkimen.net/?myParam=myValue&param1=value1#myHash');
+  });
+});
+
+describe('Common helpers', function () {
+  describe('mergeHeaders(globalHeaders, localHeaders)', function () {
+    const init = require('../www/helpers');
+    init.debug = true;
+
+    const helpers = init(null, null, null);
+
+    it('merges empty header sets correctly', () => {
+      helpers.mergeHeaders({}, {}).should.eql({});
+    });
+  });
+
+  describe('getCookieHeader(url)', function () {
+    it('resolves cookie header correctly when no cookie is set #198', () => {
+      const helpers = require('../www/helpers')(null, { getCookieString: () => '' }, null);
+
+      helpers.getCookieHeader('http://ilkimen.net').should.eql({});
+    });
+
+    it('resolves cookie header correctly when a cookie is set', () => {
+      const helpers = require('../www/helpers')(null, { getCookieString: () => 'cookie=value' }, null);
+
+      helpers.getCookieHeader('http://ilkimen.net').should.eql({ Cookie: 'cookie=value' });
+    });
+  });
+})
--- a/www/advanced-http.js
+++ b/www/advanced-http.js
@@ -5,121 +5,15 @@
 var pluginId = module.id.slice(0, module.id.lastIndexOf('.'));

 var exec = require('cordova/exec');
-var cookieHandler = require(pluginId + '.cookie-handler');
-var helpers = require(pluginId + '.helpers');
-
-var globalConfigs = {
-  headers: {},
-  serializer: 'urlencoded',
-  timeout: 60.0,
-};
-
-var publicInterface = {
-  getBasicAuthHeader: function (username, password) {
-    return {'Authorization': 'Basic ' + helpers.b64EncodeUnicode(username + ':' + password)};
-  },
-  useBasicAuth: function (username, password) {
-    this.setHeader('*', 'Authorization', 'Basic ' + helpers.b64EncodeUnicode(username + ':' + password));
-  },
-  getHeaders: function (host) {
-    return globalConfigs.headers[host || '*'] || null;
-  },
-  setHeader: function () {
-    // this one is for being backward compatible
-    var host = '*';
-    var header = arguments[0];
-    var value = arguments[1];
-
-    if (arguments.length === 3) {
-        host = arguments[0];
-        header = arguments[1];
-        value = arguments[2];
-    }
-
-    helpers.checkForBlacklistedHeaderKey(header);
-    helpers.checkForInvalidHeaderValue(value);
-
-    globalConfigs.headers[host] = globalConfigs.headers[host] || {};
-    globalConfigs.headers[host][header] = value;
-  },
-  getDataSerializer: function () {
-    return globalConfigs.serializer;
-  },
-  setDataSerializer: function (serializer) {
-    globalConfigs.serializer = helpers.checkSerializer(serializer);
-  },
-  setCookie: function (url, cookie, options) {
-    cookieHandler.setCookie(url, cookie, options);
-  },
-  clearCookies: function () {
-    cookieHandler.clearCookies();
-  },
-  removeCookies: function (url, callback) {
-    cookieHandler.removeCookies(url, callback);
-  },
-  getCookieString: function (url) {
-    return cookieHandler.getCookieString(url);
-  },
-  getRequestTimeout: function () {
-    return globalConfigs.timeout;
-  },
-  setRequestTimeout: function (timeout) {
-    globalConfigs.timeout = timeout;
-  },
-  setSSLCertMode: function (mode, success, failure) {
-    return exec(success, failure, 'CordovaHttpPlugin', 'setSSLCertMode', [ helpers.checkSSLCertMode(mode) ]);
-  },
-  disableRedirect: function (disable, success, failure) {
-    return exec(success, failure, 'CordovaHttpPlugin', 'disableRedirect', [ !!disable ]);
-  },
-  sendRequest: function (url, options, success, failure) {
-    helpers.handleMissingCallbacks(success, failure);
-
-    options = helpers.handleMissingOptions(options, globalConfigs);
-
-    var headers = helpers.getMergedHeaders(url, options.headers, globalConfigs.headers);
-    var onSuccess = helpers.injectCookieHandler(url, success);
-    var onFail = helpers.injectCookieHandler(url, failure);
-
-    switch(options.method) {
-      case 'post':
-      case 'put':
-      case 'patch':
-        var data = helpers.getProcessedData(options.data, options.serializer);
-        return exec(onSuccess, onFail, 'CordovaHttpPlugin', options.method, [ url, data, options.serializer, headers, options.timeout ]);
-      case 'upload':
-        return exec(onSuccess, onFail, 'CordovaHttpPlugin', 'uploadFile', [ url, options.params, headers, options.filePath, options.name, options.timeout ]);
-      case 'download':
-        var onDownloadSuccess = helpers.injectCookieHandler(url, helpers.injectFileEntryHandler(success));
-        return exec(onDownloadSuccess, onFail, 'CordovaHttpPlugin', 'downloadFile', [ url, options.params, headers, options.filePath, options.timeout ]);
-      default:
-        return exec(onSuccess, onFail, 'CordovaHttpPlugin', options.method, [ url, options.params, headers, options.timeout ]);
-    }
-  },
-  post: function (url, data, headers, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'post', data: data, headers: headers }, success, failure);
-  },
-  get: function (url, params, headers, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'get', params: params, headers: headers }, success, failure);
-  },
-  put: function (url, data, headers, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'put', data: data, headers: headers }, success, failure);
-  },
-  patch: function (url, data, headers, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'patch', data: data, headers: headers }, success, failure);
-  },
-  delete: function (url, params, headers, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'delete', params: params, headers: headers }, success, failure);
-  },
-  head: function (url, params, headers, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'head', params: params, headers: headers }, success, failure);
-  },
-  uploadFile: function (url, params, headers, filePath, name, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'upload', params: params, headers: headers, filePath: filePath, name: name }, success, failure);
-  },
-  downloadFile: function (url, params, headers, filePath, success, failure) {
-    return publicInterface.sendRequest(url, { method: 'download', params: params, headers: headers, filePath: filePath }, success, failure);
-  }
-};
+var messages = require(pluginId + '.messages');
+var globalConfigs = require(pluginId + '.global-configs');
+var jsUtil = require(pluginId + '.js-util');
+var ToughCookie = require(pluginId + '.tough-cookie');
+var lodash = require(pluginId + '.lodash');
+var WebStorageCookieStore = require(pluginId + '.local-storage-store')(ToughCookie, lodash);
+var cookieHandler = require(pluginId + '.cookie-handler')(window.localStorage, ToughCookie, WebStorageCookieStore);
+var helpers = require(pluginId + '.helpers')(jsUtil, cookieHandler, messages);
+var urlUtil = require(pluginId + '.url-util')(jsUtil);
+var publicInterface = require(pluginId + '.public-interface')(exec, cookieHandler, urlUtil, helpers, globalConfigs);

 module.exports = publicInterface;
--- a/www/cookie-handler.js
+++ b/www/cookie-handler.js
@@ -1,73 +1,70 @@
-var pluginId = module.id.slice(0, module.id.lastIndexOf('.'));
-var ToughCookie = require(pluginId + '.tough-cookie');
-var WebStorageCookieStore = require(pluginId + '.local-storage-store');
+module.exports = function init(storage, ToughCookie, WebStorageCookieStore) {
+  var storeKey = '__advancedHttpCookieStore__';

-var storage = window.localStorage;
-var storeKey = '__advancedHttpCookieStore__';
+  var store = new WebStorageCookieStore(storage, storeKey);
+  var cookieJar = new ToughCookie.CookieJar(store);

-var store = new WebStorageCookieStore(storage, storeKey);
-var cookieJar = new ToughCookie.CookieJar(store);
-
-module.exports = {
+  return {
    setCookieFromString: setCookieFromString,
    setCookie: setCookie,
    getCookieString: getCookieString,
    clearCookies: clearCookies,
    removeCookies: removeCookies
-}
+  };

-function splitCookieString(cookieStr) {
+  function splitCookieString(cookieStr) {
    var cookieParts = cookieStr.split(',');
    var splitCookies = [];
    var processedCookie = null;

    for (var i = 0; i < cookieParts.length; ++i) {
-        if (cookieParts[i].substr(-11, 8).toLowerCase() === 'expires=') {
-            processedCookie = cookieParts[i] + ',' + cookieParts[i + 1];
-            i++;
-        } else {
-            processedCookie = cookieParts[i];
-        }
+      if (cookieParts[i].substr(-11, 8).toLowerCase() === 'expires=') {
+        processedCookie = cookieParts[i] + ',' + cookieParts[i + 1];
+        i++;
+      } else {
+        processedCookie = cookieParts[i];
+      }

-        processedCookie = processedCookie.trim();
-        splitCookies.push(processedCookie);
+      processedCookie = processedCookie.trim();
+      splitCookies.push(processedCookie);
    }

    return splitCookies;
-}
+  }

-function setCookieFromString(url, cookieStr) {
+  function setCookieFromString(url, cookieStr) {
    if (!cookieStr) return;

    var cookies = splitCookieString(cookieStr);

    for (var i = 0; i < cookies.length; ++i) {
-        cookieJar.setCookieSync(cookies[i], url, { ignoreError: true });
+      cookieJar.setCookieSync(cookies[i], url, { ignoreError: true });
    }
-}
+  }

-function setCookie(url, cookie, options) {
-  options = options || {};
-  options.ignoreError = false;
-  cookieJar.setCookieSync(cookie, url, options);
-}
+  function setCookie(url, cookie, options) {
+    options = options || {};
+    options.ignoreError = false;
+    cookieJar.setCookieSync(cookie, url, options);
+  }

-function getCookieString(url) {
+  function getCookieString(url) {
    return cookieJar.getCookieStringSync(url);
-}
+  }

-function clearCookies() {
+  function clearCookies() {
    window.localStorage.removeItem(storeKey);
-}
+  }

-function removeCookies(url, cb) {
-    cookieJar.getCookies(url, function(error, cookies) {
-        if (!cookies || cookies.length === 0) {
+  function removeCookies(url, cb) {
+    cookieJar.getCookies(url, function (error, cookies) {
+      if (!cookies || cookies.length === 0) {
        return cb(null, []);
-        }
+      }

-        var domain = cookies[0].domain;
+      var domain = cookies[0].domain;

-        cookieJar.store.removeCookies(domain, null, cb);
+      cookieJar.store.removeCookies(domain, null, cb);
    });
-}
+  }
+};
--- a/www/global-configs.js
+++ b/www/global-configs.js
@@ -0,0 +1,7 @@
+var globalConfigs = {
+  headers: {},
+  serializer: 'urlencoded',
+  timeout: 60.0,
+};
+
+module.exports = globalConfigs;
--- a/www/helpers.js
+++ b/www/helpers.js
@@ -1,253 +1,256 @@
-var pluginId = module.id.slice(0, module.id.lastIndexOf('.'));
-var cookieHandler = require(pluginId + '.cookie-handler');
-var messages = require(pluginId + '.messages');
+module.exports = function init(jsUtil, cookieHandler, messages) {
+  var validSerializers = ['urlencoded', 'json', 'utf8'];
+  var validCertModes = ['default', 'nocheck', 'pinned', 'legacy'];
+  var validClientAuthModes = ['none', 'systemstore', 'file'];
+  var validHttpMethods = ['get', 'put', 'post', 'patch', 'head', 'delete', 'upload', 'download'];

-var validSerializers = [ 'urlencoded', 'json', 'utf8' ];
-var validCertModes = [ 'default', 'nocheck', 'pinned', 'legacy' ];
-var validHttpMethods = [ 'get', 'put', 'post', 'patch', 'head', 'delete', 'upload', 'download' ];
+  var interface = {
+    b64EncodeUnicode: b64EncodeUnicode,
+    checkSerializer: checkSerializer,
+    checkSSLCertMode: checkSSLCertMode,
+    checkClientAuthMode: checkClientAuthMode,
+    checkForBlacklistedHeaderKey: checkForBlacklistedHeaderKey,
+    checkForInvalidHeaderValue: checkForInvalidHeaderValue,
+    injectCookieHandler: injectCookieHandler,
+    injectFileEntryHandler: injectFileEntryHandler,
+    getMergedHeaders: getMergedHeaders,
+    getProcessedData: getProcessedData,
+    handleMissingCallbacks: handleMissingCallbacks,
+    handleMissingOptions: handleMissingOptions
+  };

-module.exports = {
-  b64EncodeUnicode: b64EncodeUnicode,
-  getTypeOf: getTypeOf,
-  checkSerializer: checkSerializer,
-  checkSSLCertMode: checkSSLCertMode,
-  checkForBlacklistedHeaderKey: checkForBlacklistedHeaderKey,
-  checkForInvalidHeaderValue: checkForInvalidHeaderValue,
-  injectCookieHandler: injectCookieHandler,
-  injectFileEntryHandler: injectFileEntryHandler,
-  getMergedHeaders: getMergedHeaders,
-  getProcessedData: getProcessedData,
-  handleMissingCallbacks: handleMissingCallbacks,
-  handleMissingOptions: handleMissingOptions
-};
+  // expose all functions for testing purposes
+  if (init.debug) {
+    interface.mergeHeaders = mergeHeaders;
+    interface.checkForValidStringValue = checkForValidStringValue;
+    interface.checkKeyValuePairObject = checkKeyValuePairObject;
+    interface.checkHttpMethod = checkHttpMethod;
+    interface.checkTimeoutValue = checkTimeoutValue;
+    interface.checkHeadersObject = checkHeadersObject;
+    interface.checkParamsObject = checkParamsObject;
+    interface.resolveCookieString = resolveCookieString;
+    interface.createFileEntry = createFileEntry;
+    interface.getCookieHeader = getCookieHeader;
+    interface.getMatchingHostHeaders = getMatchingHostHeaders;
+    interface.getAllowedDataTypes = getAllowedDataTypes;
+  }

-// Thanks Mozilla: https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_.22Unicode_Problem.22
-function b64EncodeUnicode(str) {
-  return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
-    return String.fromCharCode('0x' + p1);
-  }));
-}
+  return interface;

-function mergeHeaders(globalHeaders, localHeaders) {
-  var globalKeys = Object.keys(globalHeaders);
-  var key;
+  // Thanks Mozilla: https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_.22Unicode_Problem.22
+  function b64EncodeUnicode(str) {
+    return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
+      return String.fromCharCode('0x' + p1);
+    }));
+  }

-  for (var i = 0; i < globalKeys.length; i++) {
-    key = globalKeys[i];
+  function mergeHeaders(globalHeaders, localHeaders) {
+    var globalKeys = Object.keys(globalHeaders);
+    var key;

-    if (!localHeaders.hasOwnProperty(key)) {
-      localHeaders[key] = globalHeaders[key];
+    for (var i = 0; i < globalKeys.length; i++) {
+      key = globalKeys[i];
+
+      if (!localHeaders.hasOwnProperty(key)) {
+        localHeaders[key] = globalHeaders[key];
+      }
    }
+
+    return localHeaders;
  }

-  return localHeaders;
-}
+  function checkForValidStringValue(list, value, onInvalidValueMessage) {
+    if (jsUtil.getTypeOf(value) !== 'String') {
+      throw new Error(onInvalidValueMessage + ' ' + list.join(', '));
+    }

-function checkForValidStringValue(list, value, onInvalidValueMessage) {
-  if (getTypeOf(value) !== 'String') {
-    throw new Error(onInvalidValueMessage + ' ' + list.join(', '));
+    value = value.trim().toLowerCase();
+
+    if (list.indexOf(value) === -1) {
+      throw new Error(onInvalidValueMessage + ' ' + list.join(', '));
+    }
+
+    return value;
  }

-  value = value.trim().toLowerCase();
-
-  if (list.indexOf(value) === -1) {
-    throw new Error(onInvalidValueMessage + ' ' + list.join(', '));
-  }
-
-  return value;
-}
-
-function checkKeyValuePairObject(obj, allowedChildren, onInvalidValueMessage) {
-  if (getTypeOf(obj) !== 'Object') {
-    throw new Error(onInvalidValueMessage);
-  }
-
-  var keys = Object.keys(obj);
-
-  for (var i = 0; i < keys.length; i++) {
-    if (allowedChildren.indexOf(getTypeOf(obj[keys[i]])) === -1) {
+  function checkKeyValuePairObject(obj, allowedChildren, onInvalidValueMessage) {
+    if (jsUtil.getTypeOf(obj) !== 'Object') {
      throw new Error(onInvalidValueMessage);
    }
+
+    var keys = Object.keys(obj);
+
+    for (var i = 0; i < keys.length; i++) {
+      if (allowedChildren.indexOf(jsUtil.getTypeOf(obj[keys[i]])) === -1) {
+        throw new Error(onInvalidValueMessage);
+      }
+    }
+
+    return obj;
  }

-  return obj;
-}
-
-function checkHttpMethod(method) {
-  return checkForValidStringValue(validHttpMethods, method, messages.INVALID_HTTP_METHOD);
-}
-
-function checkSerializer(serializer) {
-  return checkForValidStringValue(validSerializers, serializer, messages.INVALID_DATA_SERIALIZER);
-}
-
-function checkSSLCertMode(mode) {
-  return checkForValidStringValue(validCertModes, mode, messages.INVALID_SSL_CERT_MODE);
-}
-
-function checkForBlacklistedHeaderKey(key) {
-  if (key.toLowerCase() === 'cookie') {
-    throw new Error(messages.ADDING_COOKIES_NOT_SUPPORTED);
+  function checkHttpMethod(method) {
+    return checkForValidStringValue(validHttpMethods, method, messages.INVALID_HTTP_METHOD);
  }

-  return key;
-}
-
-function checkForInvalidHeaderValue(value) {
-  if (getTypeOf(value) !== 'String') {
-    throw new Error(messages.INVALID_HEADERS_VALUE);
+  function checkSerializer(serializer) {
+    return checkForValidStringValue(validSerializers, serializer, messages.INVALID_DATA_SERIALIZER);
  }

-  return value;
-}
-
-function checkTimeoutValue(timeout) {
-  if (getTypeOf(timeout) !== 'Number' || timeout < 0) {
-    throw new Error(messages.INVALID_TIMEOUT_VALUE);
+  function checkSSLCertMode(mode) {
+    return checkForValidStringValue(validCertModes, mode, messages.INVALID_SSL_CERT_MODE);
  }

-  return timeout;
-}
+  function checkClientAuthMode(mode) {
+    return checkForValidStringValue(validClientAuthModes, mode, messages.INVALID_CLIENT_AUTH_MODE);
+  }

-function checkHeadersObject(headers) {
-  return checkKeyValuePairObject(headers, [ 'String' ], messages.INVALID_HEADERS_VALUE);
-}
+  function checkForBlacklistedHeaderKey(key) {
+    if (key.toLowerCase() === 'cookie') {
+      throw new Error(messages.ADDING_COOKIES_NOT_SUPPORTED);
+    }

-function checkParamsObject(params) {
-  return checkKeyValuePairObject(params, [ 'String', 'Array' ], messages.INVALID_PARAMS_VALUE);
-}
+    return key;
+  }

-function resolveCookieString(headers) {
-  var keys = Object.keys(headers || {});
+  function checkForInvalidHeaderValue(value) {
+    if (jsUtil.getTypeOf(value) !== 'String') {
+      throw new Error(messages.INVALID_HEADERS_VALUE);
+    }

-  for (var i = 0; i < keys.length; ++i) {
-    if (keys[i].match(/^set-cookie$/i)) {
-      return headers[keys[i]];
+    return value;
+  }
+
+  function checkTimeoutValue(timeout) {
+    if (jsUtil.getTypeOf(timeout) !== 'Number' || timeout < 0) {
+      throw new Error(messages.INVALID_TIMEOUT_VALUE);
+    }
+
+    return timeout;
+  }
+
+  function checkHeadersObject(headers) {
+    return checkKeyValuePairObject(headers, ['String'], messages.INVALID_HEADERS_VALUE);
+  }
+
+  function checkParamsObject(params) {
+    return checkKeyValuePairObject(params, ['String', 'Array'], messages.INVALID_PARAMS_VALUE);
+  }
+
+  function resolveCookieString(headers) {
+    var keys = Object.keys(headers || {});
+
+    for (var i = 0; i < keys.length; ++i) {
+      if (keys[i].match(/^set-cookie$/i)) {
+        return headers[keys[i]];
+      }
+    }
+
+    return null;
+  }
+
+  function createFileEntry(rawEntry) {
+    var entry = new (require('cordova-plugin-file.FileEntry'))();
+
+    entry.isDirectory = rawEntry.isDirectory;
+    entry.isFile = rawEntry.isFile;
+    entry.name = rawEntry.name;
+    entry.fullPath = rawEntry.fullPath;
+    entry.filesystem = new FileSystem(rawEntry.filesystemName || (rawEntry.filesystem == window.PERSISTENT ? 'persistent' : 'temporary'));
+    entry.nativeURL = rawEntry.nativeURL;
+
+    return entry;
+  }
+
+  function injectCookieHandler(url, cb) {
+    return function (response) {
+      cookieHandler.setCookieFromString(url, resolveCookieString(response.headers));
+      cb(response);
    }
  }

-  return null;
-}
-
-function createFileEntry(rawEntry) {
-  var entry = new (require('cordova-plugin-file.FileEntry'))();
-
-  entry.isDirectory = rawEntry.isDirectory;
-  entry.isFile = rawEntry.isFile;
-  entry.name = rawEntry.name;
-  entry.fullPath = rawEntry.fullPath;
-  entry.filesystem = new FileSystem(rawEntry.filesystemName || (rawEntry.filesystem == window.PERSISTENT ? 'persistent' : 'temporary'));
-  entry.nativeURL = rawEntry.nativeURL;
-
-  return entry;
-}
-
-function injectCookieHandler(url, cb) {
-  return function(response) {
-    cookieHandler.setCookieFromString(url, resolveCookieString(response.headers));
-    cb(response);
-  }
-}
-
-function injectFileEntryHandler(cb) {
-  return function(response) {
-    cb(createFileEntry(response.file));
-  }
-}
-
-function getCookieHeader(url) {
-  return { Cookie: cookieHandler.getCookieString(url) };
-}
-
-function getMatchingHostHeaders(url, headersList) {
-  var matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
-  var domain = matches && matches[1];
-
-  return headersList[domain] || null;
-}
-
-function getMergedHeaders(url, requestHeaders, predefinedHeaders) {
-  var globalHeaders = predefinedHeaders['*'] || {};
-  var hostHeaders = getMatchingHostHeaders(url, predefinedHeaders) || {};
-  var mergedHeaders = mergeHeaders(globalHeaders, hostHeaders);
-
-  mergedHeaders = mergeHeaders(mergedHeaders, requestHeaders);
-  mergedHeaders = mergeHeaders(mergedHeaders, getCookieHeader(url));
-
-  return mergedHeaders;
-}
-
-// typeof is not working reliably in JS
-function getTypeOf(object) {
-  switch (Object.prototype.toString.call(object)) {
-    case '[object Array]':
-      return 'Array';
-    case '[object Boolean]':
-      return 'Boolean';
-    case '[object Function]':
-      return 'Function';
-    case '[object Null]':
-      return 'Null';
-    case '[object Number]':
-      return 'Number';
-    case '[object Object]':
-      return 'Object';
-    case '[object String]':
-      return 'String';
-    case '[object Undefined]':
-      return 'Undefined';
-    default:
-      return 'Unknown';
-  }
-}
-
-function getAllowedDataTypes(dataSerializer) {
-  switch (dataSerializer) {
-    case 'utf8':
-      return ['String'];
-    case 'urlencoded':
-      return ['Object'];
-    default:
-      return ['Array', 'Object'];
-  }
-}
-
-function getProcessedData(data, dataSerializer) {
-  var currentDataType = getTypeOf(data);
-  var allowedDataTypes = getAllowedDataTypes(dataSerializer);
-
-  if (allowedDataTypes.indexOf(currentDataType) === -1) {
-    throw new Error(messages.DATA_TYPE_MISMATCH + ' ' + allowedDataTypes.join(', '));
+  function injectFileEntryHandler(cb) {
+    return function (response) {
+      cb(createFileEntry(response.file));
+    }
  }

-  if (dataSerializer === 'utf8') {
-    data = { text: data };
+  function getCookieHeader(url) {
+    var cookieString = cookieHandler.getCookieString(url);
+
+    if (cookieString.length) {
+      return { Cookie: cookieHandler.getCookieString(url) };
+    }
+
+    return {};
  }

-  return data;
-}
+  function getMatchingHostHeaders(url, headersList) {
+    var matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
+    var domain = matches && matches[1];

-function handleMissingCallbacks(successFn, failFn) {
-  if (getTypeOf(successFn) !== 'Function') {
-    throw new Error(messages.MANDATORY_SUCCESS);
+    return headersList[domain] || null;
  }

-  if (getTypeOf(failFn) !== 'Function') {
-    throw new Error(messages.MANDATORY_FAIL);
+  function getMergedHeaders(url, requestHeaders, predefinedHeaders) {
+    var globalHeaders = predefinedHeaders['*'] || {};
+    var hostHeaders = getMatchingHostHeaders(url, predefinedHeaders) || {};
+    var mergedHeaders = mergeHeaders(globalHeaders, hostHeaders);
+
+    mergedHeaders = mergeHeaders(mergedHeaders, requestHeaders);
+    mergedHeaders = mergeHeaders(mergedHeaders, getCookieHeader(url));
+
+    return mergedHeaders;
  }
-}

-function handleMissingOptions(options, globals) {
-  options = options || {};
+  function getAllowedDataTypes(dataSerializer) {
+    switch (dataSerializer) {
+      case 'utf8':
+        return ['String'];
+      case 'urlencoded':
+        return ['Object'];
+      default:
+        return ['Array', 'Object'];
+    }
+  }

-  return {
-    method: checkHttpMethod(options.method || validHttpMethods[0]),
-    serializer: checkSerializer(options.serializer || globals.serializer),
-    timeout: checkTimeoutValue(options.timeout || globals.timeout),
-    headers: checkHeadersObject(options.headers || {}),
-    params: checkParamsObject(options.params || {}),
-    data: getTypeOf(options.data) === 'Undefined' ? null : options.data,
-    filePath: options.filePath || '',
-    name: options.name || ''
-  };
-}
+  function getProcessedData(data, dataSerializer) {
+    var currentDataType = jsUtil.getTypeOf(data);
+    var allowedDataTypes = getAllowedDataTypes(dataSerializer);
+
+    if (allowedDataTypes.indexOf(currentDataType) === -1) {
+      throw new Error(messages.DATA_TYPE_MISMATCH + ' ' + allowedDataTypes.join(', '));
+    }
+
+    if (dataSerializer === 'utf8') {
+      data = { text: data };
+    }
+
+    return data;
+  }
+
+  function handleMissingCallbacks(successFn, failFn) {
+    if (jsUtil.getTypeOf(successFn) !== 'Function') {
+      throw new Error(messages.MANDATORY_SUCCESS);
+    }
+
+    if (jsUtil.getTypeOf(failFn) !== 'Function') {
+      throw new Error(messages.MANDATORY_FAIL);
+    }
+  }
+
+  function handleMissingOptions(options, globals) {
+    options = options || {};
+
+    return {
+      method: checkHttpMethod(options.method || validHttpMethods[0]),
+      serializer: checkSerializer(options.serializer || globals.serializer),
+      timeout: checkTimeoutValue(options.timeout || globals.timeout),
+      headers: checkHeadersObject(options.headers || {}),
+      params: checkParamsObject(options.params || {}),
+      data: jsUtil.getTypeOf(options.data) === 'Undefined' ? null : options.data,
+      filePath: options.filePath || '',
+      name: options.name || ''
+    };
+  }
+};
--- a/www/js-util.js
+++ b/www/js-util.js
@@ -0,0 +1,26 @@
+module.exports = {
+  // typeof is not working reliably in JS
+  getTypeOf: function (object) {
+    switch (Object.prototype.toString.call(object)) {
+      case '[object Array]':
+        return 'Array';
+      case '[object Boolean]':
+        return 'Boolean';
+      case '[object Function]':
+        return 'Function';
+      case '[object Null]':
+        return 'Null';
+      case '[object Number]':
+        return 'Number';
+      case '[object Object]':
+        return 'Object';
+      case '[object String]':
+        return 'String';
+      case '[object Undefined]':
+        return 'Undefined';
+      default:
+        return 'Unknown';
+    }
+  }
+}
+
--- a/www/local-storage-store.js
+++ b/www/local-storage-store.js
@@ -30,30 +30,27 @@

 'use strict';

-var pluginId = module.id.slice(0, module.id.lastIndexOf('.'));
-var ToughCookie = require(pluginId + '.tough-cookie');
-var _ = require(pluginId + '.lodash');
-
-function WebStorageCookieStore(storage, storeKey) {
+module.exports = function init(ToughCookie, _) {
+  function WebStorageCookieStore(storage, storeKey) {
    ToughCookie.Store.call(this);
-    this._storage = storage || window.localStorage;
+    this._storage = storage;
    this._storeKey = storeKey || '__cookieStore__';
    this.synchronous = true;
-}
+  }

-WebStorageCookieStore.prototype = Object.create(ToughCookie.Store);
+  WebStorageCookieStore.prototype = Object.create(ToughCookie.Store);

-WebStorageCookieStore.prototype.findCookie = function(domain, path, key, callback) {
+  WebStorageCookieStore.prototype.findCookie = function (domain, path, key, callback) {
    var store = this._readStore();
    var cookie = _.get(store, [domain, path, key], null);

    callback(null, ToughCookie.Cookie.fromJSON(cookie));
-};
+  };

-WebStorageCookieStore.prototype.findCookies = function(domain, path, callback) {
+  WebStorageCookieStore.prototype.findCookies = function (domain, path, callback) {
    if (!domain) {
-        callback(null, []);
-        return;
+      callback(null, []);
+      return;
    }

    var that = this;
@@ -61,123 +58,124 @@ WebStorageCookieStore.prototype.findCookies = function(domain, path, callback) {
    var store = this._readStore();
    var domains = ToughCookie.permuteDomain(domain) || [domain];

-    domains.forEach(function(domain) {
-        if (!store[domain]) {
-            return;
-        }
+    domains.forEach(function (domain) {
+      if (!store[domain]) {
+        return;
+      }

-        var matchingPaths = Object.keys(store[domain]);
+      var matchingPaths = Object.keys(store[domain]);

-        if (path != null) {
-            matchingPaths = matchingPaths.filter(function(cookiePath) {
-                return that._isOnPath(cookiePath, path);
-            });
-        }
-
-        matchingPaths.forEach(function(path) {
-            Array.prototype.push.apply(cookies, _.values(store[domain][path]));
+      if (path != null) {
+        matchingPaths = matchingPaths.filter(function (cookiePath) {
+          return that._isOnPath(cookiePath, path);
        });
+      }
+
+      matchingPaths.forEach(function (path) {
+        Array.prototype.push.apply(cookies, _.values(store[domain][path]));
+      });
    });

-    cookies = cookies.map(function(cookie) {
-        return ToughCookie.Cookie.fromJSON(cookie);
+    cookies = cookies.map(function (cookie) {
+      return ToughCookie.Cookie.fromJSON(cookie);
    });

    callback(null, cookies);
-};
+  };

-/**
- * Returns whether `cookiePath` is on the given `urlPath`
- */
-WebStorageCookieStore.prototype._isOnPath = function(cookiePath, urlPath) {
+  /**
+   * Returns whether `cookiePath` is on the given `urlPath`
+   */
+  WebStorageCookieStore.prototype._isOnPath = function (cookiePath, urlPath) {
    if (!cookiePath) {
-        return false;
+      return false;
    }

    if (cookiePath === urlPath) {
-        return true;
+      return true;
    }

    if (urlPath.indexOf(cookiePath) !== 0) {
-        return false;
+      return false;
    }

    if (cookiePath[cookiePath.length - 1] !== '/' && urlPath[cookiePath.length] !== '/') {
-        return false;
+      return false;
    }

    return true;
-};
+  };

-WebStorageCookieStore.prototype.putCookie = function(cookie, callback) {
-     var store = this._readStore();
+  WebStorageCookieStore.prototype.putCookie = function (cookie, callback) {
+    var store = this._readStore();

-     _.set(store, [cookie.domain, cookie.path, cookie.key], cookie);
-     this._writeStore(store);
-     callback(null);
-};
+    _.set(store, [cookie.domain, cookie.path, cookie.key], cookie);
+    this._writeStore(store);
+    callback(null);
+  };

-WebStorageCookieStore.prototype.updateCookie = function(oldCookie, newCookie, callback) {
+  WebStorageCookieStore.prototype.updateCookie = function (oldCookie, newCookie, callback) {
    this.putCookie(newCookie, callback);
-};
+  };


-WebStorageCookieStore.prototype.removeCookie = function(domain, path, key, callback) {
+  WebStorageCookieStore.prototype.removeCookie = function (domain, path, key, callback) {
    var store = this._readStore();

    _.unset(store, [domain, path, key]);
    this._writeStore(store);
    callback(null);
-};
+  };

-WebStorageCookieStore.prototype.removeCookies = function(domain, path, callback) {
+  WebStorageCookieStore.prototype.removeCookies = function (domain, path, callback) {
    var store = this._readStore();

    if (path == null) {
-        _.unset(store, [domain]);
+      _.unset(store, [domain]);
    } else {
-        _.unset(store, [domain, path]);
+      _.unset(store, [domain, path]);
    }

    this._writeStore(store);
    callback(null);
-};
+  };

-WebStorageCookieStore.prototype.getAllCookies = function(callback) {
+  WebStorageCookieStore.prototype.getAllCookies = function (callback) {
    var cookies = [];
    var store = this._readStore();

-    Object.keys(store).forEach(function(domain) {
-        Object.keys(store[domain]).forEach(function(path) {
-            Array.protype.push.apply(cookies, _.values(store[domain][path]));
-        });
+    Object.keys(store).forEach(function (domain) {
+      Object.keys(store[domain]).forEach(function (path) {
+        Array.protype.push.apply(cookies, _.values(store[domain][path]));
+      });
    });

-    cookies = cookies.map(function(cookie) {
-        return ToughCookie.Cookie.fromJSON(cookie);
+    cookies = cookies.map(function (cookie) {
+      return ToughCookie.Cookie.fromJSON(cookie);
    });

-    cookies.sort(function(c1, c2) {
-        return (c1.creationIndex || 0) - (c2.creationIndex || 0);
+    cookies.sort(function (c1, c2) {
+      return (c1.creationIndex || 0) - (c2.creationIndex || 0);
    });

    callback(null, cookies);
-};
+  };

-WebStorageCookieStore.prototype._readStore = function() {
+  WebStorageCookieStore.prototype._readStore = function () {
    var json = this._storage.getItem(this._storeKey);

    if (json !== null) {
-        try {
-            return JSON.parse(json);
-        } catch (e) { }
+      try {
+        return JSON.parse(json);
+      } catch (e) { }
    }

    return {};
-};
+  };

-WebStorageCookieStore.prototype._writeStore = function(store) {
+  WebStorageCookieStore.prototype._writeStore = function (store) {
    this._storage.setItem(this._storeKey, JSON.stringify(store));
-};
+  };

-module.exports = WebStorageCookieStore;
+  return WebStorageCookieStore;
+};
--- a/www/messages.js
+++ b/www/messages.js
@@ -6,6 +6,7 @@ module.exports = {
  INVALID_HTTP_METHOD: 'advanced-http: invalid HTTP method, supported methods are:',
  INVALID_DATA_SERIALIZER: 'advanced-http: invalid serializer, supported serializers are:',
  INVALID_SSL_CERT_MODE: 'advanced-http: invalid SSL cert mode, supported modes are:',
+  INVALID_CLIENT_AUTH_MODE: 'advanced-http: invalid client certificate authentication mode, supported modes are:',
  INVALID_HEADERS_VALUE: 'advanced-http: header values must be strings',
  INVALID_TIMEOUT_VALUE: 'advanced-http: invalid timeout value, needs to be a positive numeric value',
  INVALID_PARAMS_VALUE: 'advanced-http: invalid params object, needs to be an object with strings'
--- a/www/public-interface.js
+++ b/www/public-interface.js
@@ -0,0 +1,184 @@
+module.exports = function init(exec, cookieHandler, urlUtil, helpers, globalConfigs) {
+  const publicInterface = {
+    getBasicAuthHeader: getBasicAuthHeader,
+    useBasicAuth: useBasicAuth,
+    getHeaders: getHeaders,
+    setHeader: setHeader,
+    getDataSerializer: getDataSerializer,
+    setDataSerializer: setDataSerializer,
+    setCookie: setCookie,
+    clearCookies: clearCookies,
+    removeCookies: removeCookies,
+    getCookieString: getCookieString,
+    getRequestTimeout: getRequestTimeout,
+    setRequestTimeout: setRequestTimeout,
+    // for being backward compatible
+    setSSLCertMode: setServerTrustMode,
+    setServerTrustMode: setServerTrustMode,
+    setClientAuthMode: setClientAuthMode,
+    disableRedirect: disableRedirect,
+    sendRequest: sendRequest,
+    post: post,
+    get: get,
+    put: put,
+    patch: patch,
+    delete: del,
+    head: head,
+    uploadFile: uploadFile,
+    downloadFile: downloadFile
+  };
+
+  function getBasicAuthHeader(username, password) {
+    return { 'Authorization': 'Basic ' + helpers.b64EncodeUnicode(username + ':' + password) };
+  }
+
+  function useBasicAuth(username, password) {
+    this.setHeader('*', 'Authorization', 'Basic ' + helpers.b64EncodeUnicode(username + ':' + password));
+  }
+
+  function getHeaders(host) {
+    return globalConfigs.headers[host || '*'] || null;
+  }
+
+  function setHeader() {
+    // this one is for being backward compatible
+    var host = '*';
+    var header = arguments[0];
+    var value = arguments[1];
+
+    if (arguments.length === 3) {
+      host = arguments[0];
+      header = arguments[1];
+      value = arguments[2];
+    }
+
+    helpers.checkForBlacklistedHeaderKey(header);
+    helpers.checkForInvalidHeaderValue(value);
+
+    globalConfigs.headers[host] = globalConfigs.headers[host] || {};
+    globalConfigs.headers[host][header] = value;
+  }
+
+  function getDataSerializer() {
+    return globalConfigs.serializer;
+  }
+
+  function setDataSerializer(serializer) {
+    globalConfigs.serializer = helpers.checkSerializer(serializer);
+  }
+
+  function setCookie(url, cookie, options) {
+    cookieHandler.setCookie(url, cookie, options);
+  }
+
+  function clearCookies() {
+    cookieHandler.clearCookies();
+  }
+
+  function removeCookies(url, callback) {
+    cookieHandler.removeCookies(url, callback);
+  }
+
+  function getCookieString(url) {
+    return cookieHandler.getCookieString(url);
+  }
+
+  function getRequestTimeout() {
+    return globalConfigs.timeout;
+  }
+
+  function setRequestTimeout(timeout) {
+    globalConfigs.timeout = timeout;
+  }
+
+  function setServerTrustMode(mode, success, failure) {
+    helpers.handleMissingCallbacks(success, failure);
+
+    return exec(success, failure, 'CordovaHttpPlugin', 'setServerTrustMode', [helpers.checkSSLCertMode(mode)]);
+  }
+
+  function setClientAuthMode() {
+    // filePath is an optional param
+    var mode = arguments[0];
+    var success = arguments[1];
+    var failure = arguments[2];
+    var filePath = null;
+
+    if (arguments.length === 4) {
+      mode = arguments[0];
+      filePath = arguments[1];
+      success = arguments[2];
+      failure = arguments[3];
+    }
+
+    helpers.handleMissingCallbacks(success, failure);
+
+    return exec(success, failure, 'CordovaHttpPlugin', 'setClientAuthMode', [helpers.checkClientAuthMode(mode), filePath]);
+  }
+
+  function disableRedirect(disable, success, failure) {
+    helpers.handleMissingCallbacks(success, failure);
+
+    return exec(success, failure, 'CordovaHttpPlugin', 'disableRedirect', [!!disable]);
+  }
+
+  function sendRequest(url, options, success, failure) {
+    helpers.handleMissingCallbacks(success, failure);
+
+    options = helpers.handleMissingOptions(options, globalConfigs);
+    url = urlUtil.appendQueryParamsString(url, urlUtil.serializeQueryParams(options.params, true));
+
+    var headers = helpers.getMergedHeaders(url, options.headers, globalConfigs.headers);
+    var onSuccess = helpers.injectCookieHandler(url, success);
+    var onFail = helpers.injectCookieHandler(url, failure);
+
+    switch (options.method) {
+      case 'post':
+      case 'put':
+      case 'patch':
+        var data = helpers.getProcessedData(options.data, options.serializer);
+        return exec(onSuccess, onFail, 'CordovaHttpPlugin', options.method, [url, data, options.serializer, headers, options.timeout]);
+      case 'upload':
+        return exec(onSuccess, onFail, 'CordovaHttpPlugin', 'uploadFile', [url, headers, options.filePath, options.name, options.timeout]);
+      case 'download':
+        var onDownloadSuccess = helpers.injectCookieHandler(url, helpers.injectFileEntryHandler(success));
+        return exec(onDownloadSuccess, onFail, 'CordovaHttpPlugin', 'downloadFile', [url, headers, options.filePath, options.timeout]);
+      default:
+        return exec(onSuccess, onFail, 'CordovaHttpPlugin', options.method, [url, headers, options.timeout]);
+    }
+  }
+
+  function post(url, data, headers, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'post', data: data, headers: headers }, success, failure);
+  };
+
+  function get(url, params, headers, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'get', params: params, headers: headers }, success, failure);
+  };
+
+  function put(url, data, headers, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'put', data: data, headers: headers }, success, failure);
+  }
+
+  function patch(url, data, headers, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'patch', data: data, headers: headers }, success, failure);
+  }
+
+  function del(url, params, headers, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'delete', params: params, headers: headers }, success, failure);
+  }
+
+  function head(url, params, headers, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'head', params: params, headers: headers }, success, failure);
+  }
+
+  function uploadFile(url, params, headers, filePath, name, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'upload', params: params, headers: headers, filePath: filePath, name: name }, success, failure);
+  }
+
+  function downloadFile(url, params, headers, filePath, success, failure) {
+    return publicInterface.sendRequest(url, { method: 'download', params: params, headers: headers, filePath: filePath }, success, failure);
+  }
+
+  return publicInterface;
+}
--- a/www/url-util.js
+++ b/www/url-util.js
@@ -0,0 +1,103 @@
+module.exports = function init(jsUtil) {
+  return {
+    parseUrl: parseUrl,
+    appendQueryParamsString: appendQueryParamsString,
+    serializeQueryParams: serializeQueryParams
+  }
+
+  function parseUrl(url) {
+    var match = url.match(/^(https?\:)\/\/(([^:\/?#]*)(?:\:([0-9]+))?)([\/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
+
+    return match && {
+        protocol: match[1],
+        host: match[2],
+        hostname: match[3],
+        port: match[4] || '',
+        pathname: match[5],
+        search: match[6],
+        hash: match[7]
+    }
+  }
+
+  function appendQueryParamsString(url, params) {
+    if (!url.length || !params.length) {
+      return url;
+    }
+
+    var parsed = parseUrl(url);
+
+    return parsed.protocol
+      + '//'
+      + parsed.host
+      + parsed.pathname
+      + (parsed.search.length ? parsed.search + '&' + params : '?' + params)
+      + parsed.hash;
+  }
+
+  function serializeQueryParams(params, encode) {
+    return serializeObject('', params, encode);
+  }
+
+  function serializeObject(parentKey, object, encode) {
+    var parts = [];
+
+    for (var key in object) {
+      if (!object.hasOwnProperty(key)) {
+        continue;
+      }
+
+      var identifier = parentKey.length ? parentKey + '[' + key + ']' : key;
+
+      if (jsUtil.getTypeOf(object[key]) === 'Array') {
+        parts.push(serializeArray(identifier, object[key], encode));
+        continue;
+      } else if (jsUtil.getTypeOf(object[key]) === 'Object') {
+        parts.push(serializeObject(identifier, object[key], encode));
+        continue;
+      }
+
+      parts.push(serializeIdentifier(parentKey, key, encode) + '=' + serializeValue(object[key], encode));
+    }
+
+    return parts.join('&');
+  }
+
+  function serializeArray(parentKey, array, encode) {
+    var parts = [];
+
+    for (var i = 0; i < array.length; ++i) {
+      if (jsUtil.getTypeOf(array[i]) === 'Array') {
+        parts.push(serializeArray(parentKey + '[]', array[i], encode));
+        continue;
+      } else if (jsUtil.getTypeOf(array[i]) === 'Object') {
+        parts.push(serializeObject(parentKey + '[]' + array[i], encode));
+        continue;
+      }
+
+      parts.push(serializeIdentifier(parentKey, '', encode) + '=' + serializeValue(array[i], encode));
+    }
+
+    return parts.join('&');
+  }
+
+  function serializeIdentifier(parentKey, key, encode) {
+    if (!parentKey.length) {
+      return encode ? encodeURIComponent(key) : key;
+    }
+
+    if (encode) {
+      return encodeURIComponent(parentKey) + '[' + encodeURIComponent(key) + ']';
+    } else {
+      return parentKey + '[' + key + ']';
+    }
+  }
+
+  function serializeValue(value, encode) {
+    if (encode) {
+      return encodeURIComponent(value);
+    } else {
+      return value;
+    }
+  }
+};
+
Author	SHA1	Message	Date
Sefa Ilkimen	0bf39650e1	release v2.0.8	2019-04-10 12:06:17 +02:00
Sefa Ilkimen	d444363a8e	- fix #198 : Cookie header is always passed even if there is no cookie - some cleanup	2019-04-09 17:25:55 +02:00
Sefa Ilkimen	13976bbe43	Update change log and version number	2019-04-08 20:16:24 +02:00
Sefa Ilkimen	70c8b9bb32	Fix #201 : browser implementation broken due to broken dependency	2019-04-08 20:12:36 +02:00
Sefa Ilkimen	4b964e8b7c	Fix #197 : iOS crashes on multiple HTTPS downloadFile() calls (reverting `a8e3637`)	2019-04-08 19:14:39 +02:00
Sefa Ilkimen	56f8b41f4f	Fix #189 : error code mappings for TLS handshake problems are not precise	2019-04-08 17:58:39 +02:00
Sefa Ilkimen	e1e720fe2d	Add missing handler on browser platform	2019-04-08 17:31:38 +02:00
Sefa Ilkimen	a1b6ea94f0	Fix #200 : remove string switch and use ugly if ... else 😢 to be compatible with Java target 6	2019-04-05 16:48:18 +02:00
Sefa Ilkimen	d977392a49	- some cleanup - deprecate "setSSLCertMode" in favor of "setServerTrustMode"	2019-04-05 16:26:04 +02:00
Sefa Ilkimen	8d28f4ab80	WIP: implementing X509 client cert authentication	2019-04-05 05:22:34 +02:00
Sefa Ilkimen	38b3e6ffb1	release v2.0.7	2019-04-03 19:20:58 +02:00
Sefa Ilkimen	7d984bcf89	add spec for #197	2019-04-03 19:14:39 +02:00
Sefa Ilkimen	2cfac2026b	- increment version - update changelog - improve query params spec	2019-04-03 18:58:19 +02:00
Sefa Ilkimen	8bdbf7ca78	fix query params handling for iOS	2019-04-03 14:28:12 +02:00
Sefa Ilkimen	d5ce3ed76b	fix query param url encoding	2019-04-03 13:03:49 +02:00
Sefa Ilkimen	8a83a940cb	WIP: support deeply structured query params (fix #48 )	2019-04-02 12:51:20 +02:00
Sefa Ilkimen	230de36618	WIP: - some refactoring for future features - move params serializer into JS code	2019-04-02 12:04:49 +02:00
Sefa Ilkimen	0af726d8ce	align iOS error codes with Android error codes	2019-03-28 15:37:56 +01:00
Sefa Ilkimen	ba57d3cba1	re-integrate OkHttp3 connection factory	2019-03-22 18:09:25 +01:00
Sefa Ilkimen	508b1b4f83	re-implement disabling verification of hostname	2019-03-22 05:03:24 +01:00
Sefa Ilkimen	7992bd0991	WIP: started re-implementing SSL cert modes	2019-03-22 04:06:50 +01:00
Sefa Ilkimen	a331b57ab2	WIP: fix disableRedirect()	2019-03-22 02:18:43 +01:00
Sefa Ilkimen	ee30160921	WIP: reduce duplicate code & cleanup	2019-03-22 02:06:39 +01:00
Sefa Ilkimen	e8e1c4273f	WIP: re-implement Upload and Download Runnables	2019-03-21 17:45:24 +01:00
Sefa Ilkimen	752b2cdcb7	WIP: started refactoring - one HTTP request class implementing Runnable for all request methods - broken SSL cert handling	2019-03-21 15:12:53 +01:00
Sefa Ilkimen	314314d7f9	release v2.0.6	2019-03-11 14:20:57 +01:00
Sefa Ilkimen	a8e3637f27	Merge branch 'chrisjdev-master'	2019-03-11 14:01:37 +01:00
Sefa Ilkimen	56272b9a5d	Update changelog	2019-03-11 13:59:17 +01:00
Sefa Ilkimen	8f859db57f	Merge branch 'master' of https://github.com/chrisjdev/cordova-plugin-advanced-http into chrisjdev-master	2019-03-11 11:34:10 +01:00
Sefa Ilkimen	e673754b13	Test for #184	2019-03-01 18:12:46 +01:00
Sefa Ilkimen	a0f376233c	Fix #187 : setSSLCertMode with "default" throws an error on Android	2019-03-01 18:12:06 +01:00
Chris J	0fade8351d	Merge pull request #1 from chrisjdev/keepSessionManager Keep AFHTTPSessionManager instance with the plugin	2018-12-20 10:49:05 -05:00
Chris J	ebd6ae9793	Keep AFHTTPSessionManager instance with the plugin Persist the AFHTTPSessionManager instance for the life of the plugin to allow reusing the underlying sockets, for example, with "Connection: keep-alive" headers.	2018-12-20 10:47:13 -05:00