release v2.0.7

- update changelog
- improve query params spec

.travis.yml

@@ -1,12 +1,6 @@
-sudo: false
-
-language: objective-c
-os: osx
-osx_image: xcode9.3
-
-env:
-  - TARGET_PLATFORM=ios
-  - TARGET_PLATFORM=android ANDROID_API_LEVEL=27 ANDROID_BUILD_TOOLS_VERSION=28.0.3
+notifications:
+  slack:
+    secure: lXE+2AgsxZU5G5dI91LkMAIgo8MAWfdM7DB5UOtn5LpuNln+2FmJo1gOI7tkdmLOqpXTGYnpI2VyQN3H4nOF21YhuouzD1Sh8n2wtQg1iTm353kuQpqiVhSBX8ZJ7Be1e1G8OsnxoYOxbs4Zo9qI40EruwkvqLCBHWM5MRGyd4M7EFWwb9Z29VZN0y1Nt5g/c3bT76kdKmF+JCLur2OeEKxAity7sIKgZekSqeIMwEVLSxXnda6Dbjc/cg0MJ0iDArkD7iu6fz/Fcrrxgm/pUxjcgvqze7Gy5i31mjEfspnrglWV1cshMd48BTDKCJ2AMmxH8O3GPSWE2txjIvGRWUve7iViNylvmQCVz3Eyf99+4EuuVGa+5PSodQ/CqODx/65EwtcN3PE1tNz2puKOK8nrOJcFkcbG8KTHKUlQtHCkjitbykUnj/hvhLK5/oWlQYVOLWWrHwdGUh8FI8aFPVGjRjWbHbhdayjEIqxwr1ns+6mYrP1EFNXbaeZxnLNC59XpJl1ifuezqYAk7YEiU5j4rtC7YKgyQ3ueb7anOHTJoTMyDn8mpZXgwuyhoBaeEYytQVgRyMtL6Y5cP98Jn2kv0+vdne3rkk9/JEBTo32HOjvoij6rsqEvXC0LhUDJSNadOVdHht0jjoN6zBH37HIE5/3zysLlPcAcHAS83ow=
 
 cache:
   directories:
@@ -15,30 +9,51 @@ cache:
 addons:
   sauce_connect: true
 
-before_install:
-- export LANG=en_US.UTF-8
+matrix:
+  include:
+  - name: "iOS Build & Test"
+    language: objective-c
+    sudo: false
+    os: osx
+    osx_image: xcode10.1
 
-install:
-- npm install
-- if [ $TARGET_PLATFORM = "android" ]; then
-    brew update &&
-    brew install gradle &&
-    scripts/setup-android-sdk.sh -a $ANDROID_API_LEVEL -b $ANDROID_BUILD_TOOLS_VERSION &&
-    export ANDROID_HOME=$(pwd)/android-sdk-macosx &&
-    export PATH=${PATH}:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools:$ANDROID_HOME/build-tools/$ANDROID_BUILD_TOOLS_VERSION;
-  fi
+    before_install:
+    - export LANG=en_US.UTF-8
 
-script:
-- npm run testjs
-- npm run updatecert
-- travis_wait scripts/build-test-app.sh --$TARGET_PLATFORM --emulator &&
-  scripts/upload-artifact.sh --$TARGET_PLATFORM &&
-  scripts/test-app.sh --$TARGET_PLATFORM --emulator;
+    install:
+    - npm install
 
-after_success:
+    script:
+    - npm run testjs &&
+      npm run updatecert &&
+      scripts/build-test-app.sh --ios --emulator &&
+      scripts/upload-artifact.sh --ios &&
+      scripts/test-app.sh --ios --emulator;
 
-deploy:
+  - name: "Android Build & Test"
+    language: android
+    sudo : required
 
-notifications:
-  slack:
-    secure: lXE+2AgsxZU5G5dI91LkMAIgo8MAWfdM7DB5UOtn5LpuNln+2FmJo1gOI7tkdmLOqpXTGYnpI2VyQN3H4nOF21YhuouzD1Sh8n2wtQg1iTm353kuQpqiVhSBX8ZJ7Be1e1G8OsnxoYOxbs4Zo9qI40EruwkvqLCBHWM5MRGyd4M7EFWwb9Z29VZN0y1Nt5g/c3bT76kdKmF+JCLur2OeEKxAity7sIKgZekSqeIMwEVLSxXnda6Dbjc/cg0MJ0iDArkD7iu6fz/Fcrrxgm/pUxjcgvqze7Gy5i31mjEfspnrglWV1cshMd48BTDKCJ2AMmxH8O3GPSWE2txjIvGRWUve7iViNylvmQCVz3Eyf99+4EuuVGa+5PSodQ/CqODx/65EwtcN3PE1tNz2puKOK8nrOJcFkcbG8KTHKUlQtHCkjitbykUnj/hvhLK5/oWlQYVOLWWrHwdGUh8FI8aFPVGjRjWbHbhdayjEIqxwr1ns+6mYrP1EFNXbaeZxnLNC59XpJl1ifuezqYAk7YEiU5j4rtC7YKgyQ3ueb7anOHTJoTMyDn8mpZXgwuyhoBaeEYytQVgRyMtL6Y5cP98Jn2kv0+vdne3rkk9/JEBTo32HOjvoij6rsqEvXC0LhUDJSNadOVdHht0jjoN6zBH37HIE5/3zysLlPcAcHAS83ow=
+    android:
+      components:
+        - platform-tools
+        - build-tools-28.0.3
+        - android-27
+        - extra-android-support
+        - extra-android-m2repository
+        - extra-google-m2repository
+
+    before_install:
+    - export LANG=en_US.UTF-8 &&
+      curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash - &&
+      sudo apt-get install -y nodejs
+
+    install:
+    - npm install
+
+    script:
+    - npm run testjs &&
+      npm run updatecert &&
+      scripts/build-test-app.sh --android --emulator &&
+      scripts/upload-artifact.sh --android &&
+      scripts/test-app.sh --android --emulator;

CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 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
+
+## 2.0.4
+
+- Fixed #179: sending empty string with utf8 serializer throws an exception
+
+## 2.0.3
+
+- Fixed #172: plugin does not respect user installed CA certs on Android
+
+#### Important information
+We've changed a default behavior on Android. User installed CA certs are respected now.
+If you don't want this for your needs, you can switch back to old behavior by setting SSL cert mode to `legacy`.
+
 ## 2.0.2
 
 - Fixed #142: Plugin affected by REDoS Issue of tough-cookie

README.md

@@ -132,12 +132,13 @@ These functions all take success and error callbacks as their last 2 arguments.
 Set SSL Cert handling mode, being one of the following values:
 
 * `default`: default SSL cert 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
 
 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.
 
-:warning: Your certificate must be DER encoded! If you only have a PEM enoceded certificate see this [stackoverflow answer](http://stackoverflow.com/a/16583429/3182729). You want to convert it to a DER encoded certificate with a .cer extension.
+:warning: Your certificate must be DER encoded! If you only have a PEM encoded certificate read this [stackoverflow answer](http://stackoverflow.com/a/16583429/3182729). You want to convert it to a DER encoded certificate with a .cer extension.
 
 ```js
 // enable SSL pinning

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-plugin-advanced-http",
-  "version": "2.0.2",
+  "version": "2.0.7",
   "description": "Cordova / Phonegap plugin for communicating with HTTP servers using SSL pinning",
   "scripts": {
     "updatecert": "node ./scripts/update-test-cert.js",
@@ -59,7 +59,7 @@
     "chai": "4.1.2",
     "chai-as-promised": "7.1.1",
     "colors": "1.1.2",
-    "cordova": "7.1.0",
+    "cordova": "8.1.2",
     "mocha": "4.0.0",
     "mock-require": "2.0.2",
     "mz": "2.7.0",

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.2">
+<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.7">
   <name>Advanced HTTP plugin</name>
   <description>
         Cordova / Phonegap plugin for communicating with HTTP servers using SSL pinning
@@ -8,12 +8,15 @@
     <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/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 +53,25 @@
   <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/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/http/HostnameVerifierFactory.java" target-dir="src/com/silkimen/http"/>
+    <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/OkConnectionFactory.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/TLSSocketFactory.java" target-dir="src/com/silkimen/http"/>
+    <source-file src="src/android/com/silkimen/http/TrustManagersFactory.java" target-dir="src/com/silkimen/http"/>
     <framework src="com.squareup.okhttp3:okhttp-urlconnection:3.10.0"/>
   </platform>
   <platform name="browser">

scripts/build-test-app.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -e
 
-ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"/..
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )"; cd ..; pwd )"
 WORKINGCOPY=$ROOT/temp/workingcopy
 CDV=$ROOT/node_modules/.bin/cordova
 
@@ -37,9 +37,9 @@ done
 
 rm -rf $ROOT/temp
 mkdir $ROOT/temp
-cp -r $ROOT/test/app-template/ $ROOT/temp/
+cp -r $ROOT/test/app-template/. $ROOT/temp/
 cp $ROOT/test/app-test-definitions.js $ROOT/temp/www/
-rsync -ax --exclude node_modules --exclude scripts --exclude temp --exclude test $ROOT $WORKINGCOPY
+rsync -ax --exclude node_modules --exclude scripts --exclude temp --exclude test $ROOT/. $WORKINGCOPY
 cd $ROOT/temp
 $CDV prepare
 $CDV plugins add $WORKINGCOPY

scripts/release.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -e
 
-ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"/..
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )"; cd ..; pwd )"
 
 pushd $ROOT
 VERSION=$(node -e "console.log(require('./package.json').version)")

scripts/test-app.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -e
 
-ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"/..
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )"; cd ..; pwd )"
 
 if [ $CI == "true" ] && ([ -z $SAUCE_USERNAME ] || [ -z $SAUCE_ACCESS_KEY ]); then
   echo "Skipping CI tests, because Saucelabs credentials are not set.";

scripts/update-tough-cookie.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 set -e
 
-ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"/..
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )"; cd ..; pwd )"
 
 cd $ROOT
 npm i

scripts/upload-artifact.sh

@@ -2,7 +2,7 @@
 set -e
 
 PLATFORM=$([[ "${@#--android}" = "$@" ]] && echo "ios" || echo "android")
-ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"/..
+ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}" )"; cd ..; pwd )"
 TEMP=$ROOT/temp
 
 if [ -z $SAUCE_USERNAME ] || [ -z $SAUCE_ACCESS_KEY ]; then

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);
-    }
-}

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;
-    }
-}

src/android/com/silkimen/cordovahttp/CordovaHttpBase.java

@@ -0,0 +1,189 @@
+package com.silkimen.cordovahttp;
+
+import java.io.ByteArrayOutputStream;
+
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+
+import java.nio.ByteBuffer;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLSocketFactory;
+
+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 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 SSLSocketFactory customSSLSocketFactory;
+  protected HostnameVerifier customHostnameVerifier;
+  protected CallbackContext callbackContext;
+
+  public CordovaHttpBase(String method, String url, String serializer, Object data, JSONObject headers, int timeout,
+      boolean followRedirects, SSLSocketFactory customSSLSocketFactory, HostnameVerifier customHostnameVerifier,
+      CallbackContext callbackContext) {
+
+    this.method = method;
+    this.url = url;
+    this.serializer = serializer;
+    this.data = data;
+    this.headers = headers;
+    this.timeout = timeout;
+    this.followRedirects = followRedirects;
+    this.customSSLSocketFactory = customSSLSocketFactory;
+    this.customHostnameVerifier = customHostnameVerifier;
+    this.callbackContext = callbackContext;
+  }
+
+  public CordovaHttpBase(String method, String url, JSONObject headers, int timeout,
+      boolean followRedirects, SSLSocketFactory customSSLSocketFactory, HostnameVerifier customHostnameVerifier,
+      CallbackContext callbackContext) {
+
+    this.method = method;
+    this.url = url;
+    this.headers = headers;
+    this.timeout = timeout;
+    this.followRedirects = followRedirects;
+    this.customSSLSocketFactory = customSSLSocketFactory;
+    this.customHostnameVerifier = customHostnameVerifier;
+    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 SSLHandshakeException) {
+        response.setStatus(-2);
+        response.setErrorMessage("SSL handshake failed: " + e.getMessage());
+        Log.w(TAG, "SSL handshake failed", 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 {
+    request.followRedirects(this.followRedirects);
+    request.readTimeout(this.timeout);
+    request.acceptCharset("UTF-8");
+    request.uncompress(true);
+    request.setConnectionFactory(new OkConnectionFactory());
+
+    if (this.customHostnameVerifier != null) {
+      request.setHostnameVerifier(this.customHostnameVerifier);
+    }
+
+    if (this.customSSLSocketFactory != null) {
+      request.setSSLSocketFactory(this.customSSLSocketFactory);
+    }
+
+    // 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) {
+    switch (this.serializer) {
+    case "json":
+      request.contentType("application/json", "UTF-8");
+      break;
+    case "utf8":
+      request.contentType("text/plain", "UTF-8");
+      break;
+    case "urlencoded":
+      // intentionally left blank, because content type is set in HttpRequest.form()
+      break;
+    }
+  }
+
+  protected void sendBody(HttpRequest request) throws Exception {
+    if (this.data == null) {
+      return;
+    }
+
+    switch (this.serializer) {
+    case "json":
+      request.send(this.data.toString());
+      break;
+    case "utf8":
+      request.send(((JSONObject) this.data).getString("text"));
+      break;
+    case "urlencoded":
+      request.form(JsonUtils.getObjectMap((JSONObject) this.data));
+      break;
+    }
+  }
+
+  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);
+    }
+  }
+}

src/android/com/silkimen/cordovahttp/CordovaHttpDownload.java

@@ -0,0 +1,43 @@
+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 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, SSLSocketFactory customSSLSocketFactory, HostnameVerifier customHostnameVerifier,
+      CallbackContext callbackContext) {
+
+    super("GET", url, headers, timeout, followRedirects, customSSLSocketFactory, customHostnameVerifier,
+        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");
+    }
+  }
+}

src/android/com/silkimen/cordovahttp/CordovaHttpOperation.java

@@ -0,0 +1,25 @@
+package com.silkimen.cordovahttp;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+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, SSLSocketFactory customSSLSocketFactory,
+      HostnameVerifier customHostnameVerifier, CallbackContext callbackContext) {
+
+    super(method, url, serializer, data, headers, timeout, followRedirects, customSSLSocketFactory,
+        customHostnameVerifier, callbackContext);
+  }
+
+  public CordovaHttpOperation(String method, String url, JSONObject headers, int timeout, boolean followRedirects,
+      SSLSocketFactory customSSLSocketFactory, HostnameVerifier customHostnameVerifier,
+      CallbackContext callbackContext) {
+
+    super(method, url, headers, timeout, followRedirects, customSSLSocketFactory, customHostnameVerifier,
+        callbackContext);
+  }
+}

src/android/com/silkimen/cordovahttp/CordovaHttpPlugin.java

@@ -0,0 +1,248 @@
+package com.silkimen.cordovahttp;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import java.security.cert.CertificateFactory;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.KeyStore.TrustedCertificateEntry;
+import java.security.SecureRandom;
+import java.security.cert.Certificate;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+
+import com.silkimen.http.HostnameVerifierFactory;
+import com.silkimen.http.TLSSocketFactory;
+import com.silkimen.http.TrustManagersFactory;
+
+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 android.util.Log;
+
+public class CordovaHttpPlugin extends CordovaPlugin {
+  private static final String TAG = "Cordova-Plugin-HTTP";
+
+  private final TrustManagersFactory trustManagersFactory = new TrustManagersFactory();
+  private final HostnameVerifierFactory hostnameVerifierFactory = new HostnameVerifierFactory();
+
+  private boolean followRedirects = true;
+  private SSLSocketFactory customSSLSocketFactory;
+  private HostnameVerifier customHostnameVerifier;
+
+  @Override
+  public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+    super.initialize(cordova, webView);
+
+    try {
+      this.customSSLSocketFactory = this.createSocketFactory(
+          this.trustManagersFactory.getPinnedTrustManagers(this.getCertsFromKeyStore("AndroidCAStore")));
+    } 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;
+    }
+
+    switch (action) {
+    case "get":
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    case "post":
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    case "put":
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    case "patch":
+      return this.executeHttpRequestWithData(action, args, callbackContext);
+    case "head":
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    case "delete":
+      return this.executeHttpRequestWithoutData(action, args, callbackContext);
+    case "uploadFile":
+      return this.uploadFile(args, callbackContext);
+    case "downloadFile":
+      return this.downloadFile(args, callbackContext);
+    case "setSSLCertMode":
+      return this.setSSLCertMode(args, callbackContext);
+    case "disableRedirect":
+      return this.disableRedirect(args, callbackContext);
+    default:
+      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.customSSLSocketFactory, this.customHostnameVerifier, 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.customSSLSocketFactory, this.customHostnameVerifier, 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.customSSLSocketFactory, this.customHostnameVerifier, 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.customSSLSocketFactory, this.customHostnameVerifier, callbackContext);
+
+    cordova.getThreadPool().execute(download);
+
+    return true;
+  }
+
+  private boolean setSSLCertMode(final JSONArray args, final CallbackContext callbackContext) {
+    try {
+      switch (args.getString(0)) {
+      case "legacy":
+        this.customHostnameVerifier = null;
+        this.customSSLSocketFactory = null;
+        break;
+      case "nocheck":
+        this.customHostnameVerifier = this.hostnameVerifierFactory.getNoOpVerifier();
+        this.customSSLSocketFactory = this.createSocketFactory(this.trustManagersFactory.getNoopTrustManagers());
+        break;
+      case "pinned":
+        this.customHostnameVerifier = null;
+        this.customSSLSocketFactory = this.createSocketFactory(
+            this.trustManagersFactory.getPinnedTrustManagers(this.getCertsFromBundle("www/certificates")));
+        break;
+      default:
+        this.customHostnameVerifier = null;
+        this.customSSLSocketFactory = this.createSocketFactory(
+            this.trustManagersFactory.getPinnedTrustManagers(this.getCertsFromKeyStore("AndroidCAStore")));
+        break;
+      }
+
+      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");
+    }
+
+    return true;
+  }
+
+  private boolean disableRedirect(final JSONArray args, final CallbackContext callbackContext) throws JSONException {
+    this.followRedirects = !args.getBoolean(0);
+
+    callbackContext.success();
+
+    return true;
+  }
+
+  private ArrayList<Certificate> getCertsFromKeyStore(String storeType) throws GeneralSecurityException, IOException {
+    ArrayList<Certificate> certList = new ArrayList<Certificate>();
+    KeyStore keyStore = KeyStore.getInstance(storeType);
+    keyStore.load(null);
+
+    Enumeration<String> aliases = keyStore.aliases();
+
+    while (aliases.hasMoreElements()) {
+      String alias = aliases.nextElement();
+      TrustedCertificateEntry certEntry = (TrustedCertificateEntry) keyStore.getEntry(alias, null);
+      Certificate cert = certEntry.getTrustedCertificate();
+      certList.add(cert);
+    }
+
+    return certList;
+  }
+
+  private ArrayList<Certificate> getCertsFromBundle(String path) throws GeneralSecurityException, IOException {
+    AssetManager assetManager = cordova.getActivity().getAssets();
+    String[] files = assetManager.list(path);
+    CertificateFactory cf = CertificateFactory.getInstance("X.509");
+    ArrayList<Certificate> certList = new ArrayList<Certificate>();
+
+    for (int i = 0; i < files.length; i++) {
+      int index = files[i].lastIndexOf('.');
+
+      if (index == -1 || !files[i].substring(index).equals(".cer")) {
+        continue;
+      }
+
+      certList.add(cf.generateCertificate(assetManager.open(path + "/" + files[i])));
+    }
+
+    return certList;
+  }
+
+  private SSLSocketFactory createSocketFactory(TrustManager[] trustManagers) throws IOException {
+    try {
+      SSLContext context = SSLContext.getInstance("TLS");
+
+      /* @TODO implement custom KeyManager */
+      context.init(null, trustManagers, new SecureRandom());
+
+      if (android.os.Build.VERSION.SDK_INT < 20) {
+        return new TLSSocketFactory(context);
+      } else {
+        return context.getSocketFactory();
+      }
+    } catch (GeneralSecurityException e) {
+      IOException ioException = new IOException("Security exception occured while configuring SSL context");
+      ioException.initCause(e);
+      throw ioException;
+    }
+  }
+}

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;
+  }
+}

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 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, SSLSocketFactory customSSLSocketFactory,
+      HostnameVerifier customHostnameVerifier, CallbackContext callbackContext) {
+
+    super("POST", url, headers, timeout, followRedirects, customSSLSocketFactory, customHostnameVerifier,
+        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)));
+  }
+}

src/android/com/silkimen/http/HostnameVerifierFactory.java

@@ -0,0 +1,20 @@
+package com.silkimen.http;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSession;
+
+public class HostnameVerifierFactory {
+  private final HostnameVerifier noOpVerifier;
+
+  public HostnameVerifierFactory() {
+    this.noOpVerifier = new HostnameVerifier() {
+      public boolean verify(String hostname, SSLSession session) {
+        return true;
+      }
+    };
+  }
+
+  public HostnameVerifier getNoOpVerifier() {
+    return this.noOpVerifier;
+  }
+}

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);
+  }
+}

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;
+  }
+}

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);
+  }
+}

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 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;
+  }
+}

src/android/com/silkimen/http/TrustManagersFactory.java

@@ -0,0 +1,64 @@
+package com.silkimen.http;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+public class TrustManagersFactory {
+  private final TrustManager[] noOpTrustManager;
+
+  public TrustManagersFactory() {
+    this.noOpTrustManager = 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
+      }
+    } };
+  }
+
+  public TrustManager[] getNoopTrustManagers() {
+    return this.noOpTrustManager;
+  }
+
+  public TrustManager[] getPinnedTrustManagers(ArrayList<Certificate> pinnedCerts) throws IOException {
+    if (pinnedCerts == null || pinnedCerts.size() == 0) {
+      throw new IOException("You must add at least 1 certificate in order to pin to certificates");
+    }
+
+    try {
+      String keyStoreType = KeyStore.getDefaultType();
+      KeyStore keyStore = KeyStore.getInstance(keyStoreType);
+      keyStore.load(null, null);
+
+      for (int i = 0; i < pinnedCerts.size(); i++) {
+        keyStore.setCertificateEntry("CA" + i, pinnedCerts.get(i));
+      }
+
+      // Create a TrustManager that trusts the CAs in our KeyStore
+      String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
+      TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
+      tmf.init(keyStore);
+
+      return tmf.getTrustManagers();
+    } catch (GeneralSecurityException e) {
+      IOException ioException = new IOException("Security exception configuring SSL trust managers");
+      ioException.initCause(e);
+
+      throw ioException;
+    }
+  }
+}

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");
-      } else if (e.getCause() instanceof SocketTimeoutException) {
-          this.respondWithError(1, "The request timed out");
-      } else if (e.getCause() instanceof SSLHandshakeException) {
-          this.respondWithError("SSL handshake failed");
-      } else {
-          this.respondWithError("There was an error with the request: " + e.getMessage());
-      }
-    }
-}

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());
-        }
-    }
-}

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());
-        }
-    }
-}

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());
-        }
-    }
-}

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());
-        }
-    }
-}

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());
-        }
-    }
-}

src/android/com/synconset/cordovahttp/CordovaHttpPlugin.java

@@ -1,157 +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.util.ArrayList;
-
-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("default")) {
-                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 (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 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);
-        }
-    }
-}

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());
-        }
-    }
-}

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());
-        }
-    }
-}

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());
-        }
-    }
-}

src/ios/AFNetworking/AFURLSessionManager.m

@@ -392,11 +392,11 @@ static NSString * const AFNSURLSessionTaskDidSuspendNotification = @"com.alamofi
             - On iOS 7, `__NSCFLocalSessionTask` and `__NSCFURLSessionTask` are the only two classes that have their own implementations of `resume` and `suspend`, and `__NSCFLocalSessionTask` DOES NOT CALL SUPER. This means both classes need to be swizzled.
             - On iOS 8, `NSURLSessionTask` is the only class that implements `resume` and `suspend`. This means this is the only class that needs to be swizzled.
             - Because `NSURLSessionTask` is not involved in the class hierarchy for every version of iOS, its easier to add the swizzled methods to a dummy class and manage them there.
-        
+
          Some Assumptions:
             - No implementations of `resume` or `suspend` call super. If this were to change in a future version of iOS, we'd need to handle it.
             - No background task classes override `resume` or `suspend`
-         
+
          The current solution:
             1) Grab an instance of `__NSCFLocalDataTask` by asking an instance of `NSURLSession` for a data task.
             2) Grab a pointer to the original implementation of `af_resume`
@@ -415,7 +415,7 @@ static NSString * const AFNSURLSessionTaskDidSuspendNotification = @"com.alamofi
 #pragma clang diagnostic pop
         IMP originalAFResumeIMP = method_getImplementation(class_getInstanceMethod([self class], @selector(af_resume)));
         Class currentClass = [localDataTask class];
-        
+
         while (class_getInstanceMethod(currentClass, @selector(resume))) {
             Class superClass = [currentClass superclass];
             IMP classResumeIMP = method_getImplementation(class_getInstanceMethod(currentClass, @selector(resume)));
@@ -426,7 +426,7 @@ static NSString * const AFNSURLSessionTaskDidSuspendNotification = @"com.alamofi
             }
             currentClass = [currentClass superclass];
         }
-        
+
         [localDataTask cancel];
         [session finishTasksAndInvalidate];
     }
@@ -454,7 +454,7 @@ static NSString * const AFNSURLSessionTaskDidSuspendNotification = @"com.alamofi
     NSAssert([self respondsToSelector:@selector(state)], @"Does not respond to state");
     NSURLSessionTaskState state = [self state];
     [self af_resume];
-    
+
     if (state != NSURLSessionTaskStateRunning) {
         [[NSNotificationCenter defaultCenter] postNotificationName:AFNSURLSessionTaskDidResumeNotification object:self];
     }
@@ -464,7 +464,7 @@ static NSString * const AFNSURLSessionTaskDidSuspendNotification = @"com.alamofi
     NSAssert([self respondsToSelector:@selector(state)], @"Does not respond to state");
     NSURLSessionTaskState state = [self state];
     [self af_suspend];
-    
+
     if (state != NSURLSessionTaskStateSuspended) {
         [[NSNotificationCenter defaultCenter] postNotificationName:AFNSURLSessionTaskDidSuspendNotification object:self];
     }
@@ -978,7 +978,7 @@ didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge
                     disposition = NSURLSessionAuthChallengePerformDefaultHandling;
                 }
             } else {
-                disposition = NSURLSessionAuthChallengeCancelAuthenticationChallenge;
+                disposition = NSURLSessionAuthChallengeRejectProtectionSpace;
             }
         } else {
             disposition = NSURLSessionAuthChallengePerformDefaultHandling;
@@ -1025,7 +1025,7 @@ didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge
                 disposition = NSURLSessionAuthChallengeUseCredential;
                 credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
             } else {
-                disposition = NSURLSessionAuthChallengeCancelAuthenticationChallenge;
+                disposition = NSURLSessionAuthChallengeRejectProtectionSpace;
             }
         } else {
             disposition = NSURLSessionAuthChallengePerformDefaultHandling;

src/ios/CordovaHttpPlugin.m

@@ -20,10 +20,12 @@
 @implementation CordovaHttpPlugin {
     AFSecurityPolicy *securityPolicy;
     bool redirect;
+    AFHTTPSessionManager *manager;
 }
 
 - (void)pluginInitialize {
     securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeNone];
+    manager = [AFHTTPSessionManager manager];
     redirect = true;
 }
 
@@ -94,16 +96,19 @@
     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];
+            return [NSNumber numberWithInt:-6];
+        case -1202:
+            // untrusted SSL certificate
+            return [NSNumber numberWithInt:-2];
         default:
             return [NSNumber numberWithInt:-1];
     }
@@ -124,7 +129,7 @@
 - (void)setSSLCertMode:(CDVInvokedUrlCommand*)command {
     NSString *certMode = [command.arguments objectAtIndex:0];
 
-    if ([certMode isEqualToString: @"default"]) {
+    if ([certMode isEqualToString: @"default"] || [certMode isEqualToString: @"legacy"]) {
         securityPolicy = [AFSecurityPolicy policyWithPinningMode:AFSSLPinningModeNone];
         securityPolicy.allowInvalidCertificates = NO;
         securityPolicy.validatesDomainName = YES;
@@ -156,57 +161,12 @@
     [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
 }
 
-- (void)post:(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];
-
-    [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:parameters progress: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)get:(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 setRequestSerializer: @"default" forManager: manager];
     [self setRequestHeaders: headers forManager: manager];
@@ -218,132 +178,7 @@
     [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];
 
     @try {
-        [manager GET:url parameters:parameters progress: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)put:(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];
-
-    [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 PUT: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)patch:(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];
-
-    [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 PATCH: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)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) {
+        [manager GET:url parameters:nil success:^(NSURLSessionTask *task, id responseObject) {
             NSMutableDictionary *dictionary = [NSMutableDictionary dictionary];
             [self handleSuccess:dictionary withResponse:(NSHTTPURLResponse*)task.response andData:responseObject];
 
@@ -366,12 +201,11 @@
 }
 
 - (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];
@@ -382,7 +216,7 @@
     [[SDNetworkActivityIndicator sharedActivityIndicator] startActivity];
 
     @try {
-        [manager HEAD:url parameters:parameters success:^(NSURLSessionTask *task) {
+        [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];
@@ -405,16 +239,176 @@
     }
 }
 
-- (void)uploadFile:(CDVInvokedUrlCommand*)command {
-    AFHTTPSessionManager *manager = [AFHTTPSessionManager manager];
+- (void)delete:(CDVInvokedUrlCommand*)command {
     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];
+    NSTimeInterval timeoutInSeconds = [[command.arguments objectAtIndex:2] 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: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 {
+    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];
+
+            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)put:(CDVInvokedUrlCommand*)command {
+    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 PUT:url parameters:data 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)patch:(CDVInvokedUrlCommand*)command {
+    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 PATCH:url parameters:data 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)uploadFile:(CDVInvokedUrlCommand*)command {
+    manager.securityPolicy = securityPolicy;
+
+    NSString *url = [command.arguments objectAtIndex:0];
+    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];
 
@@ -427,7 +421,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) {
@@ -461,16 +455,13 @@
     }
 }
 
-
 - (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];
@@ -485,7 +476,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

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
   }
 };

test/app-test-definitions.js

@@ -37,48 +37,58 @@ 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.' },
+  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.' }
+}
+
 const tests = [
   {
     description: 'should reject self signed cert (GET)',
-    expected: 'rejected: {"status":-1,"error":"cancelled"}',
+    expected: 'rejected: {"status":-2, ...',
     func: function(resolve, reject) { cordova.plugin.http.get('https://self-signed.badssl.com/', {}, {}, resolve, reject); },
     validationFunc: function(driver, result, targetInfo) {
       result.type.should.be.equal('rejected');
-      result.data.should.be.eql({ status: -1, error: targetInfo.isAndroid ? 'SSL handshake failed' : 'cancelled' });
+      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":-1,"error":"cancelled"}',
+    expected: 'rejected: {"status":-2, ...',
     func: function(resolve, reject) { cordova.plugin.http.put('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
     validationFunc: function(driver, result, targetInfo) {
       result.type.should.be.equal('rejected');
-      result.data.should.be.eql({ status: -1, error: targetInfo.isAndroid ? 'SSL handshake failed' : 'cancelled' });
+      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":-1,"error":"cancelled"}',
+    expected: 'rejected: {"status":-2, ...',
     func: function(resolve, reject) { cordova.plugin.http.post('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
     validationFunc: function(driver, result, targetInfo) {
       result.type.should.be.equal('rejected');
-      result.data.should.be.eql({ status: -1, error: targetInfo.isAndroid ? 'SSL handshake failed' : 'cancelled' });
+      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":-1,"error":"cancelled"}',
+    expected: 'rejected: {"status":-2, ...',
     func: function(resolve, reject) { cordova.plugin.http.patch('https://self-signed.badssl.com/', { test: 'testString' }, {}, resolve, reject); },
     validationFunc: function(driver, result, targetInfo) {
       result.type.should.be.equal('rejected');
-      result.data.should.be.eql({ status: -1, error: targetInfo.isAndroid ? 'SSL handshake failed' : 'cancelled' });
+      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":-1,"error":"cancelled"}',
+    expected: 'rejected: {"status":-2, ...',
     func: function(resolve, reject) { cordova.plugin.http.delete('https://self-signed.badssl.com/', {}, {}, resolve, reject); },
     validationFunc: function(driver, result, targetInfo) {
       result.type.should.be.equal('rejected');
-      result.data.should.be.eql({ status: -1, error: targetInfo.isAndroid ? 'SSL handshake failed' : 'cancelled' });
+      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,
@@ -87,7 +97,8 @@ const tests = [
       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,
@@ -96,7 +107,8 @@ const tests = [
       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,
@@ -105,7 +117,8 @@ const tests = [
       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,
@@ -114,7 +127,8 @@ const tests = [
       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,
@@ -123,7 +137,8 @@ const tests = [
       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,
@@ -132,7 +147,8 @@ const tests = [
       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,
@@ -141,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,
@@ -150,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,
@@ -159,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,
@@ -168,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,
@@ -177,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,
@@ -187,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,
@@ -196,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,
@@ -205,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,
@@ -214,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); },
@@ -222,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) {
@@ -246,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) {
@@ -271,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) {
@@ -284,9 +312,10 @@ const tests = [
       JSON
         .parse(result.data.data)
         .url
-        .should.be.equal('http://httpbin.org/get?myArray[]=val1&myArray[]=val2&myArray[]=val3&myString=testString');
+        .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) {
@@ -296,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) {
@@ -306,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) {
@@ -316,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) {
@@ -334,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) {
@@ -353,7 +386,8 @@ const tests = [
         .Cookie
         .should.be.equal('');
     }
-  },{
+  },
+  {
     description: 'should send programmatically set cookies correctly (DOWNLOAD) #57',
     expected: 'resolved: {"content":{"cookies":{"myCookie":"myValue ...',
     func: function(resolve, reject) {
@@ -385,7 +419,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,
@@ -396,7 +431,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) {
@@ -406,7 +442,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) {
@@ -416,7 +453,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) {
@@ -426,7 +464,8 @@ 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,
@@ -437,18 +476,20 @@ 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": -1 ...',
+    expected: 'rejected: {"status": -2 ...',
     before: helpers.setPinnedCertMode,
     func: function(resolve, reject) {
       cordova.plugin.http.get('https://sha512.badssl.com/', {}, {}, resolve, reject);
     },
     validationFunc: function(driver, result, targetInfo) {
       result.type.should.be.equal('rejected');
-      result.data.should.be.eql({ status: -1, error: targetInfo.isAndroid ? 'SSL handshake failed' : 'cancelled' });
+      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,
@@ -457,7 +498,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,
@@ -466,7 +508,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); },
@@ -475,7 +518,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); },
@@ -484,6 +528,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\\":\\"\\" ...',
+    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>");
+    }
   }
 ];
 

test/js-mocha-specs.js

@@ -1,35 +1,33 @@
 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() {
+describe('Advanced HTTP public 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');
+  const getDependenciesBlueprint = () => {
+    const messages = require('../www/messages');
+    const globalConfigs = require('../www/global-configs');
+    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')(cookieHandler, messages);
+    const urlUtil = require('../www/url-util')(helpers);
+
+    return { exec: noop, cookieHandler, urlUtil: urlUtil, helpers, globalConfigs };
   };
 
-  this.timeout(900000);
+  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');
-
-    mock('cordova/exec', noop);
-    mock(`${PLUGIN_ID}.cookie-handler`, {});
-    mock(`${HELPERS_ID}.cookie-handler`, {});
-    mock(`${HELPERS_ID}.messages`, require('../www/messages'));
-
-    loadHttp();
+    loadHttp(getDependenciesBlueprint());
   });
 
   it('sets global headers correctly with two args (old interface)', () => {
@@ -48,76 +46,76 @@ describe('Advanced HTTP www interface', function() {
   });
 
   it('resolves global headers correctly #24', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
+    const deps = getDependenciesBlueprint();
 
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
       headers.should.eql({
         Cookie: 'fakeCookieString',
         myKey: 'myValue'
       });
-    });
+    };
 
-    loadHttp();
+    loadHttp(deps);
 
     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'
-    });
+    const deps = getDependenciesBlueprint();
 
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
       headers.should.eql({
         Cookie: 'fakeCookieString',
         myKey: 'myValue'
       });
-    });
+    };
 
-    loadHttp();
+    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', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
+    const deps = getDependenciesBlueprint();
 
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
       headers.should.eql({
         Cookie: 'fakeCookieString',
         myKey: 'myValue'
       });
-    });
+    };
 
-    loadHttp();
+    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', () => {
-    mock(`${HELPERS_ID}.cookie-handler`, {
-      getCookieString: () => 'fakeCookieString'
-    });
+    const deps = getDependenciesBlueprint();
 
-    mock('cordova/exec', (onSuccess, onFail, namespace, method, params) => {
-      const headers = params[2];
+    deps.cookieHandler.getCookieString = () => 'fakeCookieString';
+
+    deps.exec = (onSuccess, onFail, namespace, method, params) => {
+      const headers = params[1];
       headers.should.eql({
         Cookie: 'fakeCookieString',
         myKey: 'myValue'
       });
-    });
+    };
 
-    loadHttp();
+    loadHttp(deps);
 
     http.get('https://www.google.de/?gws_rd=ssl', {}, { myKey: 'myValue' }, noop, noop);
   });
@@ -128,6 +126,111 @@ describe('Advanced HTTP www interface', function() {
   });
 
   it('throws an Error when you try to add a cookie by using "setHeader" #46', () => {
-    (function() { http.setHeader('*', 'cookie', 'value') }).should.throw();
+    (function () { http.setHeader('*', 'cookie', 'value') }).should.throw();
+  });
+});
+
+describe('URL util', function () {
+  const helpers = require('../www/helpers')(null, null);
+  const util = require('../www/url-util')(helpers);
+
+  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');
   });
 });

www/advanced-http.js

@@ -5,121 +5,14 @@
 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 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')(cookieHandler, messages);
+var urlUtil = require(pluginId + '.url-util')(helpers);
+var publicInterface = require(pluginId + '.public-interface')(exec, cookieHandler, urlUtil, helpers, globalConfigs);
 
 module.exports = publicInterface;

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);
     });
-}
+  }
+};

www/global-configs.js

@@ -0,0 +1,7 @@
+var globalConfigs = {
+  headers: {},
+  serializer: 'urlencoded',
+  timeout: 60.0,
+};
+
+module.exports = globalConfigs;

www/helpers.js

@@ -1,255 +1,251 @@
-var pluginId = module.id.slice(0, module.id.lastIndexOf('.'));
-var cookieHandler = require(pluginId + '.cookie-handler');
-var messages = require(pluginId + '.messages');
-
-var validSerializers = [ 'urlencoded', 'json', 'utf8' ];
-var validCertModes = [ 'default', 'nocheck', 'pinned' ];
-var validHttpMethods = [ 'get', 'put', 'post', 'patch', 'head', 'delete', 'upload', 'download' ];
-
-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
-};
-
-// 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);
-  }));
-}
-
-function mergeHeaders(globalHeaders, localHeaders) {
-  var globalKeys = Object.keys(globalHeaders);
-  var key;
-
-  for (var i = 0; i < globalKeys.length; i++) {
-    key = globalKeys[i];
-
-    if (!localHeaders.hasOwnProperty(key)) {
-      localHeaders[key] = globalHeaders[key];
-    }
-  }
-
-  return localHeaders;
-}
-
-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;
-}
-
-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) {
-      throw new Error(onInvalidValueMessage);
-    }
-  }
-
-  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);
-  }
-
-  return key;
-}
-
-function checkForInvalidHeaderValue(value) {
-  if (getTypeOf(value) !== 'String') {
-    throw new Error(messages.INVALID_HEADERS_VALUE);
-  }
-
-  return value;
-}
-
-function checkTimeoutValue(timeout) {
-  if (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);
-  }
-}
-
-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) {
-  data = data || {};
-
-  var currentDataType = 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 (getTypeOf(successFn) !== 'Function') {
-    throw new Error(messages.MANDATORY_SUCCESS);
-  }
-
-  if (getTypeOf(failFn) !== 'Function') {
-    throw new Error(messages.MANDATORY_FAIL);
-  }
-}
-
-function handleMissingOptions(options, globals) {
-  options = options || {};
+module.exports = function init(cookieHandler, messages) {
+  var validSerializers = ['urlencoded', 'json', 'utf8'];
+  var validCertModes = ['default', 'nocheck', 'pinned', 'legacy'];
+  var validHttpMethods = ['get', 'put', 'post', 'patch', 'head', 'delete', 'upload', 'download'];
 
   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: options.data || null,
-    filePath: options.filePath || '',
-    name: options.name || ''
+    b64EncodeUnicode: b64EncodeUnicode,
+    getTypeOf: getTypeOf,
+    checkSerializer: checkSerializer,
+    checkSSLCertMode: checkSSLCertMode,
+    checkForBlacklistedHeaderKey: checkForBlacklistedHeaderKey,
+    checkForInvalidHeaderValue: checkForInvalidHeaderValue,
+    injectCookieHandler: injectCookieHandler,
+    injectFileEntryHandler: injectFileEntryHandler,
+    getMergedHeaders: getMergedHeaders,
+    getProcessedData: getProcessedData,
+    handleMissingCallbacks: handleMissingCallbacks,
+    handleMissingOptions: handleMissingOptions
   };
-}
+
+  // 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);
+    }));
+  }
+
+  function mergeHeaders(globalHeaders, localHeaders) {
+    var globalKeys = Object.keys(globalHeaders);
+    var key;
+
+    for (var i = 0; i < globalKeys.length; i++) {
+      key = globalKeys[i];
+
+      if (!localHeaders.hasOwnProperty(key)) {
+        localHeaders[key] = globalHeaders[key];
+      }
+    }
+
+    return localHeaders;
+  }
+
+  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;
+  }
+
+  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) {
+        throw new Error(onInvalidValueMessage);
+      }
+    }
+
+    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);
+    }
+
+    return key;
+  }
+
+  function checkForInvalidHeaderValue(value) {
+    if (getTypeOf(value) !== 'String') {
+      throw new Error(messages.INVALID_HEADERS_VALUE);
+    }
+
+    return value;
+  }
+
+  function checkTimeoutValue(timeout) {
+    if (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);
+    }
+  }
+
+  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(', '));
+    }
+
+    if (dataSerializer === 'utf8') {
+      data = { text: data };
+    }
+
+    return data;
+  }
+
+  function handleMissingCallbacks(successFn, failFn) {
+    if (getTypeOf(successFn) !== 'Function') {
+      throw new Error(messages.MANDATORY_SUCCESS);
+    }
+
+    if (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: getTypeOf(options.data) === 'Undefined' ? null : options.data,
+      filePath: options.filePath || '',
+      name: options.name || ''
+    };
+  }
+};

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;
+};

www/public-interface.js

@@ -0,0 +1,158 @@
+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,
+    setSSLCertMode: setSSLCertMode,
+    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 setSSLCertMode(mode, success, failure) {
+    return exec(success, failure, 'CordovaHttpPlugin', 'setSSLCertMode', [helpers.checkSSLCertMode(mode)]);
+  }
+
+  function disableRedirect(disable, 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;
+}

www/url-util.js

@@ -0,0 +1,103 @@
+module.exports = function init(helpers) {
+  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 (helpers.getTypeOf(object[key]) === 'Array') {
+        parts.push(serializeArray(identifier, object[key], encode));
+        continue;
+      } else if (helpers.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 (helpers.getTypeOf(array[i]) === 'Array') {
+        parts.push(serializeArray(parentKey + '[]', array[i], encode));
+        continue;
+      } else if (helpers.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;
+    }
+  }
+};
+