@capacitor/android 4.2.1-nightly-20220920T151019.0 → 4.3.0

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [4.3.0](https://github.com/ionic-team/capacitor/compare/4.2.0...4.3.0) (2022-09-21)
+
+
+### Bug Fixes
+
+* **android:** open external links in browser ([#5913](https://github.com/ionic-team/capacitor/issues/5913)) ([7553ede](https://github.com/ionic-team/capacitor/commit/7553ede93170971e21ab3dec1798443d084ead2a))
+* **android:** set all cookies on proxied requests ([#5781](https://github.com/ionic-team/capacitor/issues/5781)) ([5ef6a38](https://github.com/ionic-team/capacitor/commit/5ef6a3889121dd39a9159ff80250df18854bc557))
+* **android:** set WebViewClient on the WebView ([#5919](https://github.com/ionic-team/capacitor/issues/5919)) ([020ed8e](https://github.com/ionic-team/capacitor/commit/020ed8eaeb7864399d4b93f54ab7601c607d8e0d))
+* **core:** Exception object was not set on Cap ([#5917](https://github.com/ionic-team/capacitor/issues/5917)) ([9ca27a4](https://github.com/ionic-team/capacitor/commit/9ca27a4f8441b368f8bf9d97dda57b1a55ac0e4e))
+
+
+### Features
+
+* Capacitor Cookies & Capacitor Http core plugins ([d4047cf](https://github.com/ionic-team/capacitor/commit/d4047cfa947676777f400389a8d65defae140b45))
+
+
+
+
+
 # [4.2.0](https://github.com/ionic-team/capacitor/compare/4.1.0...4.2.0) (2022-09-08)
 
 **Note:** Version bump only for package @capacitor/android

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

@@ -2,7 +2,7 @@
 /*! Capacitor: https://capacitorjs.com/ - MIT License */
 /* Generated File. Do not edit. */
 
-var nativeBridge = (function (exports) {
+const nativeBridge = (function (exports) {
     'use strict';
 
     var ExceptionCode;
@@ -268,6 +268,274 @@ var 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');
+                let doPatchCookies = false;
+                // check if capacitor cookies is disabled before patching
+                if (platform === 'ios') {
+                    // Use prompt to synchronously get capacitor cookies config.
+                    // https://stackoverflow.com/questions/29249132/wkwebview-complex-communication-between-javascript-native-code/49474323#49474323
+                    const payload = {
+                        type: 'CapacitorCookies.isEnabled',
+                    };
+                    const isCookiesEnabled = prompt(JSON.stringify(payload));
+                    if (isCookiesEnabled === 'true') {
+                        doPatchCookies = true;
+                    }
+                }
+                else if (typeof win.CapacitorCookiesAndroidInterface !== 'undefined') {
+                    const isCookiesEnabled = win.CapacitorCookiesAndroidInterface.isEnabled();
+                    if (isCookiesEnabled === true) {
+                        doPatchCookies = true;
+                    }
+                }
+                if (doPatchCookies) {
+                    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,
+                };
+                let doPatchHttp = false;
+                // check if capacitor http is disabled before patching
+                if (platform === 'ios') {
+                    // Use prompt to synchronously get capacitor http config.
+                    // https://stackoverflow.com/questions/29249132/wkwebview-complex-communication-between-javascript-native-code/49474323#49474323
+                    const payload = {
+                        type: 'CapacitorHttp',
+                    };
+                    const isHttpEnabled = prompt(JSON.stringify(payload));
+                    if (isHttpEnabled === 'true') {
+                        doPatchHttp = true;
+                    }
+                }
+                else if (typeof win.CapacitorHttpAndroidInterface !== 'undefined') {
+                    const isHttpEnabled = win.CapacitorHttpAndroidInterface.isEnabled();
+                    if (isHttpEnabled === true) {
+                        doPatchHttp = true;
+                    }
+                }
+                if (doPatchHttp) {
+                    // fetch patch
+                    window.fetch = async (resource, options) => {
+                        if (resource.toString().startsWith('data:') ||
+                            resource.toString().startsWith('blob:')) {
+                            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,
+                            });
+                            const data = typeof nativeResponse.data === 'string'
+                                ? nativeResponse.data
+                                : JSON.stringify(nativeResponse.data);
+                            // intercept & parse response before returning
+                            const response = new Response(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 () {
+                        this.readyState = 0;
+                        this.dispatchEvent(new Event('abort'));
+                        this.dispatchEvent(new Event('loadend'));
+                    };
+                    // XHR patch open
+                    window.XMLHttpRequest.prototype.open = function (method, url) {
+                        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,
+                            },
+                        });
+                        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._headers = nativeResponse.headers;
+                                    this.status = nativeResponse.status;
+                                    this.response = nativeResponse.data;
+                                    this.responseText =
+                                        typeof nativeResponse.data === 'string'
+                                            ? nativeResponse.data
+                                            : 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._headers = error.headers;
+                                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._headers = {};
+                            this.response = error;
+                            this.responseText = error.toString();
+                            this.responseURL = this._url;
+                            this.readyState = 4;
+                            this.dispatchEvent(new Event('error'));
+                            this.dispatchEvent(new Event('loadend'));
+                        }
+                    };
+                    // XHR patch getAllResponseHeaders
+                    window.XMLHttpRequest.prototype.getAllResponseHeaders = function () {
+                        let returnString = '';
+                        for (const key in this._headers) {
+                            if (key != 'Set-Cookie') {
+                                returnString += key + ': ' + this._headers[key] + '\r\n';
+                            }
+                        }
+                        return returnString;
+                    };
+                    // XHR patch getResponseHeader
+                    window.XMLHttpRequest.prototype.getResponseHeader = function (name) {
+                        return this._headers[name];
+                    };
+                }
+            }
             // 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,129 @@
+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.PluginConfig;
+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();
+    }
+
+    @JavascriptInterface
+    public boolean isEnabled() {
+        PluginConfig pluginConfig = getBridge().getConfig().getPluginConfiguration("CapacitorCookies");
+        return pluginConfig.getBoolean("enabled", false);
+    }
+
+    /**
+     * 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();
+    }
+}