@capacitor/android 4.1.0 → 4.1.1-dev-7e3589f9.0

package/capacitor/src/main/assets/native-bridge.js

@@ -241,6 +241,209 @@ const nativeBridge = (function (exports) {
                 }
                 return String(msg);
             };
+            /**
+             * Safely web decode a string value (inspired by js-cookie)
+             * @param str The string value to decode
+             */
+            const decode = (str) => str.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+            const platform = getPlatformId(win);
+            if (platform == 'android' || platform == 'ios') {
+                // patch document.cookie on Android/iOS
+                win.CapacitorCookiesDescriptor =
+                    Object.getOwnPropertyDescriptor(Document.prototype, 'cookie') ||
+                        Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie');
+                Object.defineProperty(document, 'cookie', {
+                    get: function () {
+                        if (platform === 'ios') {
+                            // Use prompt to synchronously get cookies.
+                            // https://stackoverflow.com/questions/29249132/wkwebview-complex-communication-between-javascript-native-code/49474323#49474323
+                            const payload = {
+                                type: 'CapacitorCookies',
+                            };
+                            const res = prompt(JSON.stringify(payload));
+                            return res;
+                        }
+                        else if (typeof win.CapacitorCookiesAndroidInterface !== 'undefined') {
+                            return win.CapacitorCookiesAndroidInterface.getCookies();
+                        }
+                    },
+                    set: function (val) {
+                        const cookiePairs = val.split(';');
+                        for (const cookiePair of cookiePairs) {
+                            const cookieKey = cookiePair.split('=')[0];
+                            const cookieValue = cookiePair.split('=')[1];
+                            if (null == cookieValue) {
+                                continue;
+                            }
+                            cap.toNative('CapacitorCookies', 'setCookie', {
+                                key: cookieKey,
+                                value: decode(cookieValue),
+                            });
+                        }
+                    },
+                });
+                // patch fetch / XHR on Android/iOS
+                // store original fetch & XHR functions
+                win.CapacitorWebFetch = window.fetch;
+                win.CapacitorWebXMLHttpRequest = {
+                    abort: window.XMLHttpRequest.prototype.abort,
+                    open: window.XMLHttpRequest.prototype.open,
+                    send: window.XMLHttpRequest.prototype.send,
+                    setRequestHeader: window.XMLHttpRequest.prototype.setRequestHeader,
+                };
+                // fetch patch
+                window.fetch = async (resource, options) => {
+                    if (resource.toString().startsWith('data:')) {
+                        return win.CapacitorWebFetch(resource, options);
+                    }
+                    try {
+                        // intercept request & pass to the bridge
+                        const nativeResponse = await cap.nativePromise('CapacitorHttp', 'request', {
+                            url: resource,
+                            method: (options === null || options === void 0 ? void 0 : options.method) ? options.method : undefined,
+                            data: (options === null || options === void 0 ? void 0 : options.body) ? options.body : undefined,
+                            headers: (options === null || options === void 0 ? void 0 : options.headers) ? options.headers : undefined,
+                        });
+                        // intercept & parse response before returning
+                        const response = new Response(JSON.stringify(nativeResponse.data), {
+                            headers: nativeResponse.headers,
+                            status: nativeResponse.status,
+                        });
+                        return response;
+                    }
+                    catch (error) {
+                        return Promise.reject(error);
+                    }
+                };
+                // XHR event listeners
+                const addEventListeners = function () {
+                    this.addEventListener('abort', function () {
+                        if (typeof this.onabort === 'function')
+                            this.onabort();
+                    });
+                    this.addEventListener('error', function () {
+                        if (typeof this.onerror === 'function')
+                            this.onerror();
+                    });
+                    this.addEventListener('load', function () {
+                        if (typeof this.onload === 'function')
+                            this.onload();
+                    });
+                    this.addEventListener('loadend', function () {
+                        if (typeof this.onloadend === 'function')
+                            this.onloadend();
+                    });
+                    this.addEventListener('loadstart', function () {
+                        if (typeof this.onloadstart === 'function')
+                            this.onloadstart();
+                    });
+                    this.addEventListener('readystatechange', function () {
+                        if (typeof this.onreadystatechange === 'function')
+                            this.onreadystatechange();
+                    });
+                    this.addEventListener('timeout', function () {
+                        if (typeof this.ontimeout === 'function')
+                            this.ontimeout();
+                    });
+                };
+                // XHR patch abort
+                window.XMLHttpRequest.prototype.abort = function () {
+                    Object.defineProperties(this, {
+                        _headers: {
+                            value: {},
+                            writable: true,
+                        },
+                        readyState: {
+                            get: function () {
+                                var _a;
+                                return (_a = this._readyState) !== null && _a !== void 0 ? _a : 0;
+                            },
+                            set: function (val) {
+                                this._readyState = val;
+                                this.dispatchEvent(new Event('readystatechange'));
+                            },
+                        },
+                        response: {
+                            value: '',
+                            writable: true,
+                        },
+                        responseText: {
+                            value: '',
+                            writable: true,
+                        },
+                        responseURL: {
+                            value: '',
+                            writable: true,
+                        },
+                        status: {
+                            value: 0,
+                            writable: true,
+                        },
+                    });
+                    this.readyState = 0;
+                    this.dispatchEvent(new Event('abort'));
+                    this.dispatchEvent(new Event('loadend'));
+                };
+                // XHR patch open
+                window.XMLHttpRequest.prototype.open = function (method, url) {
+                    this.abort();
+                    addEventListeners.call(this);
+                    this._method = method;
+                    this._url = url;
+                    this.readyState = 1;
+                };
+                // XHR patch set request header
+                window.XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+                    this._headers[header] = value;
+                };
+                // XHR patch send
+                window.XMLHttpRequest.prototype.send = function (body) {
+                    try {
+                        this.readyState = 2;
+                        // intercept request & pass to the bridge
+                        cap
+                            .nativePromise('CapacitorHttp', 'request', {
+                            url: this._url,
+                            method: this._method,
+                            data: body !== null ? body : undefined,
+                            headers: this._headers,
+                        })
+                            .then((nativeResponse) => {
+                            // intercept & parse response before returning
+                            if (this.readyState == 2) {
+                                this.dispatchEvent(new Event('loadstart'));
+                                this.status = nativeResponse.status;
+                                this.response = nativeResponse.data;
+                                this.responseText = JSON.stringify(nativeResponse.data);
+                                this.responseURL = nativeResponse.url;
+                                this.readyState = 4;
+                                this.dispatchEvent(new Event('load'));
+                                this.dispatchEvent(new Event('loadend'));
+                            }
+                        })
+                            .catch((error) => {
+                            this.dispatchEvent(new Event('loadstart'));
+                            this.status = error.status;
+                            this.response = error.data;
+                            this.responseText = JSON.stringify(error.data);
+                            this.responseURL = error.url;
+                            this.readyState = 4;
+                            this.dispatchEvent(new Event('error'));
+                            this.dispatchEvent(new Event('loadend'));
+                        });
+                    }
+                    catch (error) {
+                        this.dispatchEvent(new Event('loadstart'));
+                        this.status = 500;
+                        this.response = error;
+                        this.responseText = error.toString();
+                        this.responseURL = this._url;
+                        this.readyState = 4;
+                        this.dispatchEvent(new Event('error'));
+                        this.dispatchEvent(new Event('loadend'));
+                    }
+                };
+            }
             // patch window.console on iOS and store original console fns
             const isIos = getPlatformId(win) === 'ios';
             if (win.console && isIos) {

package/capacitor/src/main/java/com/getcapacitor/Bridge.java

@@ -556,7 +556,9 @@ public class Bridge {
      * Register our core Plugin APIs
      */
     private void registerAllPlugins() {
+        this.registerPlugin(com.getcapacitor.plugin.CapacitorCookies.class);
         this.registerPlugin(com.getcapacitor.plugin.WebView.class);
+        this.registerPlugin(com.getcapacitor.plugin.CapacitorHttp.class);
 
         for (Class<? extends Plugin> pluginClass : this.initialPlugins) {
             this.registerPlugin(pluginClass);

package/capacitor/src/main/java/com/getcapacitor/JSValue.java

@@ -0,0 +1,65 @@
+package com.getcapacitor;
+
+import org.json.JSONException;
+
+/**
+ * Represents a single user-data value of any type on the capacitor PluginCall object.
+ */
+public class JSValue {
+
+    private final Object value;
+
+    /**
+     * @param call The capacitor plugin call, used for accessing the value safely.
+     * @param name The name of the property to access.
+     */
+    public JSValue(PluginCall call, String name) {
+        this.value = this.toValue(call, name);
+    }
+
+    /**
+     * Returns the coerced but uncasted underlying value.
+     */
+    public Object getValue() {
+        return this.value;
+    }
+
+    @Override
+    public String toString() {
+        return this.getValue().toString();
+    }
+
+    /**
+     * Returns the underlying value as a JSObject, or throwing if it cannot.
+     *
+     * @throws JSONException If the underlying value is not a JSObject.
+     */
+    public JSObject toJSObject() throws JSONException {
+        if (this.value instanceof JSObject) return (JSObject) this.value;
+        throw new JSONException("JSValue could not be coerced to JSObject.");
+    }
+
+    /**
+     * Returns the underlying value as a JSArray, or throwing if it cannot.
+     *
+     * @throws JSONException If the underlying value is not a JSArray.
+     */
+    public JSArray toJSArray() throws JSONException {
+        if (this.value instanceof JSArray) return (JSArray) this.value;
+        throw new JSONException("JSValue could not be coerced to JSArray.");
+    }
+
+    /**
+     * Returns the underlying value this object represents, coercing it into a capacitor-friendly object if supported.
+     */
+    private Object toValue(PluginCall call, String name) {
+        Object value = null;
+        value = call.getArray(name, null);
+        if (value != null) return value;
+        value = call.getObject(name, null);
+        if (value != null) return value;
+        value = call.getString(name, null);
+        if (value != null) return value;
+        return call.getData().opt(name);
+    }
+}

package/capacitor/src/main/java/com/getcapacitor/plugin/CapacitorCookieManager.java

@@ -0,0 +1,172 @@
+package com.getcapacitor.plugin;
+
+import java.net.CookieManager;
+import java.net.CookiePolicy;
+import java.net.CookieStore;
+import java.net.HttpCookie;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class CapacitorCookieManager extends CookieManager {
+
+    private final android.webkit.CookieManager webkitCookieManager;
+
+    /**
+     * Create a new cookie manager with the default cookie store and policy
+     */
+    public CapacitorCookieManager() {
+        this(null, null);
+    }
+
+    /**
+     * Create a new cookie manager with specified cookie store and cookie policy.
+     * @param store a {@code CookieStore} to be used by CookieManager. if {@code null}, cookie
+     *              manager will use a default one, which is an in-memory CookieStore implementation.
+     * @param policy a {@code CookiePolicy} instance to be used by cookie manager as policy
+     *               callback. if {@code null}, ACCEPT_ORIGINAL_SERVER will be used.
+     */
+    public CapacitorCookieManager(CookieStore store, CookiePolicy policy) {
+        super(store, policy);
+        webkitCookieManager = android.webkit.CookieManager.getInstance();
+    }
+
+    /**
+     * Gets the cookies for the given URL.
+     * @param url the URL for which the cookies are requested
+     * @return value the cookies as a string, using the format of the 'Cookie' HTTP request header
+     */
+    public String getCookieString(String url) {
+        return webkitCookieManager.getCookie(url);
+    }
+
+    /**
+     * Gets a cookie value for the given URL and key.
+     * @param url the URL for which the cookies are requested
+     * @param key the key of the cookie to search for
+     * @return the {@code HttpCookie} value of the cookie at the key,
+     *         otherwise it will return a new empty {@code HttpCookie}
+     */
+    public HttpCookie getCookie(String url, String key) {
+        HttpCookie[] cookies = getCookies(url);
+        for (HttpCookie cookie : cookies) {
+            if (cookie.getName().equals(key)) {
+                return cookie;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Gets an array of {@code HttpCookie} given a URL.
+     * @param url the URL for which the cookies are requested
+     * @return an {@code HttpCookie} array of non-expired cookies
+     */
+    public HttpCookie[] getCookies(String url) {
+        try {
+            ArrayList<HttpCookie> cookieList = new ArrayList<>();
+            String cookieString = getCookieString(url);
+            if (cookieString != null) {
+                String[] singleCookie = cookieString.split(";");
+                for (String c : singleCookie) {
+                    HttpCookie parsed = HttpCookie.parse(c).get(0);
+                    parsed.setValue(parsed.getValue());
+                    cookieList.add(parsed);
+                }
+            }
+            HttpCookie[] cookies = new HttpCookie[cookieList.size()];
+            return cookieList.toArray(cookies);
+        } catch (Exception ex) {
+            return new HttpCookie[0];
+        }
+    }
+
+    /**
+     * Sets a cookie for the given URL. Any existing cookie with the same host, path and name will
+     *  be replaced with the new cookie. The cookie being set will be ignored if it is expired.
+     * @param url the URL for which the cookie is to be set
+     * @param value the cookie as a string, using the format of the 'Set-Cookie' HTTP response header
+     */
+    public void setCookie(String url, String value) {
+        webkitCookieManager.setCookie(url, value);
+        flush();
+    }
+
+    /**
+     * Sets a cookie for the given URL. Any existing cookie with the same host, path and name will
+     *  be replaced with the new cookie. The cookie being set will be ignored if it is expired.
+     * @param url the URL for which the cookie is to be set
+     * @param key the {@code HttpCookie} name to use for lookup
+     * @param value the value of the {@code HttpCookie} given a key
+     */
+    public void setCookie(String url, String key, String value) {
+        String cookieValue = key + "=" + value;
+        setCookie(url, cookieValue);
+    }
+
+    /**
+     * Removes all cookies. This method is asynchronous.
+     */
+    public void removeAllCookies() {
+        webkitCookieManager.removeAllCookies(null);
+        flush();
+    }
+
+    /**
+     * Ensures all cookies currently accessible through the getCookie API are written to persistent
+     *  storage. This call will block the caller until it is done and may perform I/O.
+     */
+    public void flush() {
+        webkitCookieManager.flush();
+    }
+
+    @Override
+    public void put(URI uri, Map<String, List<String>> responseHeaders) {
+        // make sure our args are valid
+        if ((uri == null) || (responseHeaders == null)) return;
+
+        // save our url once
+        String url = uri.toString();
+
+        // go over the headers
+        for (String headerKey : responseHeaders.keySet()) {
+            // ignore headers which aren't cookie related
+            if ((headerKey == null) || !(headerKey.equalsIgnoreCase("Set-Cookie2") || headerKey.equalsIgnoreCase("Set-Cookie"))) continue;
+
+            // process each of the headers
+            for (String headerValue : Objects.requireNonNull(responseHeaders.get(headerKey))) {
+                setCookie(url, headerValue);
+            }
+        }
+    }
+
+    @Override
+    public Map<String, List<String>> get(URI uri, Map<String, List<String>> requestHeaders) {
+        // make sure our args are valid
+        if ((uri == null) || (requestHeaders == null)) throw new IllegalArgumentException("Argument is null");
+
+        // save our url once
+        String url = uri.toString();
+
+        // prepare our response
+        Map<String, List<String>> res = new HashMap<>();
+
+        // get the cookie
+        String cookie = getCookieString(url);
+
+        // return it
+        if (cookie != null) res.put("Cookie", Collections.singletonList(cookie));
+        return res;
+    }
+
+    @Override
+    public CookieStore getCookieStore() {
+        // we don't want anyone to work with this cookie store directly
+        throw new UnsupportedOperationException();
+    }
+}

package/capacitor/src/main/java/com/getcapacitor/plugin/CapacitorCookies.java

@@ -0,0 +1,122 @@
+package com.getcapacitor.plugin;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.util.Log;
+import android.webkit.JavascriptInterface;
+import androidx.annotation.Nullable;
+import com.getcapacitor.CapConfig;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.net.CookieHandler;
+import java.net.HttpCookie;
+import java.net.URI;
+
+@CapacitorPlugin
+public class CapacitorCookies extends Plugin {
+
+    CapacitorCookieManager cookieManager;
+
+    @Override
+    public void load() {
+        this.bridge.getWebView().addJavascriptInterface(this, "CapacitorCookiesAndroidInterface");
+        this.cookieManager = new CapacitorCookieManager(null, java.net.CookiePolicy.ACCEPT_ALL);
+        CookieHandler.setDefault(cookieManager);
+        super.load();
+    }
+
+    /**
+     * Helper function for getting the serverUrl from the Capacitor Config. Returns an empty
+     * string if it is invalid and will auto-reject through {@code call}
+     * @param call the {@code PluginCall} context
+     * @return the string of the server specified in the Capacitor config
+     */
+    private String getServerUrl(@Nullable PluginCall call) {
+        String url = (call == null) ? this.bridge.getServerUrl() : call.getString("url", this.bridge.getServerUrl());
+
+        if (url == null || url.isEmpty()) {
+            url = this.bridge.getLocalUrl();
+        }
+
+        URI uri = getUri(url);
+        if (uri == null) {
+            if (call != null) {
+                call.reject("Invalid URL. Check that \"server\" is passed in correctly");
+            }
+
+            return "";
+        }
+
+        return url;
+    }
+
+    /**
+     * Try to parse a url string and if it can't be parsed, return null
+     * @param url the url string to try to parse
+     * @return a parsed URI
+     */
+    private URI getUri(String url) {
+        try {
+            return new URI(url);
+        } catch (Exception ex) {
+            return null;
+        }
+    }
+
+    @JavascriptInterface
+    public String getCookies() {
+        try {
+            String url = getServerUrl(null);
+            if (!url.isEmpty()) {
+                return cookieManager.getCookieString(url);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return "";
+    }
+
+    @PluginMethod
+    public void setCookie(PluginCall call) {
+        String key = call.getString("key");
+        String value = call.getString("value");
+        String url = getServerUrl(call);
+
+        if (!url.isEmpty()) {
+            cookieManager.setCookie(url, key, value);
+            call.resolve();
+        }
+    }
+
+    @PluginMethod
+    public void deleteCookie(PluginCall call) {
+        String key = call.getString("key");
+        String url = getServerUrl(call);
+        if (!url.isEmpty()) {
+            cookieManager.setCookie(url, key + "=; Expires=Wed, 31 Dec 2000 23:59:59 GMT");
+            call.resolve();
+        }
+    }
+
+    @PluginMethod
+    public void clearCookies(PluginCall call) {
+        String url = getServerUrl(call);
+        if (!url.isEmpty()) {
+            HttpCookie[] cookies = cookieManager.getCookies(url);
+            for (HttpCookie cookie : cookies) {
+                cookieManager.setCookie(url, cookie.getName() + "=; Expires=Wed, 31 Dec 2000 23:59:59 GMT");
+            }
+            call.resolve();
+        }
+    }
+
+    @PluginMethod
+    public void clearAllCookies(PluginCall call) {
+        cookieManager.removeAllCookies();
+        call.resolve();
+    }
+}

package/capacitor/src/main/java/com/getcapacitor/plugin/CapacitorHttp.java

@@ -0,0 +1,75 @@
+package com.getcapacitor.plugin;
+
+import android.Manifest;
+import android.webkit.JavascriptInterface;
+import com.getcapacitor.CapConfig;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginConfig;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.plugin.util.HttpRequestHandler;
+
+@CapacitorPlugin(
+    permissions = {
+        @Permission(strings = { Manifest.permission.WRITE_EXTERNAL_STORAGE }, alias = "HttpWrite"),
+        @Permission(strings = { Manifest.permission.READ_EXTERNAL_STORAGE }, alias = "HttpRead")
+    }
+)
+public class CapacitorHttp extends Plugin {
+
+    private void http(final PluginCall call, final String httpMethod) {
+        Runnable asyncHttpCall = new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    JSObject response = HttpRequestHandler.request(call, httpMethod);
+                    call.resolve(response);
+                } catch (Exception e) {
+                    System.out.println(e.toString());
+                    call.reject(e.getClass().getSimpleName(), e);
+                }
+            }
+        };
+        Thread httpThread = new Thread(asyncHttpCall);
+        httpThread.start();
+    }
+
+    @JavascriptInterface
+    public boolean isDisabled() {
+        PluginConfig pluginConfig = getBridge().getConfig().getPluginConfiguration("CapacitorHttp");
+        return pluginConfig.getBoolean("disabled", false);
+    }
+
+    @PluginMethod
+    public void request(final PluginCall call) {
+        this.http(call, null);
+    }
+
+    @PluginMethod
+    public void get(final PluginCall call) {
+        this.http(call, "GET");
+    }
+
+    @PluginMethod
+    public void post(final PluginCall call) {
+        this.http(call, "POST");
+    }
+
+    @PluginMethod
+    public void put(final PluginCall call) {
+        this.http(call, "PUT");
+    }
+
+    @PluginMethod
+    public void patch(final PluginCall call) {
+        this.http(call, "PATCH");
+    }
+
+    @PluginMethod
+    public void delete(final PluginCall call) {
+        this.http(call, "DELETE");
+    }
+}