@capacitor-plus/android 8.0.0-beta.0

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

@@ -0,0 +1,119 @@
+package com.getcapacitor.plugin;
+
+import android.webkit.JavascriptInterface;
+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.io.UnsupportedEncodingException;
+import java.net.CookieHandler;
+import java.net.HttpCookie;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+
+@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, this.bridge);
+        this.cookieManager.removeSessionCookies();
+        CookieHandler.setDefault(this.cookieManager);
+        super.load();
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        super.handleOnDestroy();
+        this.cookieManager.removeSessionCookies();
+    }
+
+    @JavascriptInterface
+    public boolean isEnabled() {
+        PluginConfig pluginConfig = getBridge().getConfig().getPluginConfiguration("CapacitorCookies");
+        return pluginConfig.getBoolean("enabled", false);
+    }
+
+    @JavascriptInterface
+    public void setCookie(String domain, String action) {
+        cookieManager.setCookie(domain, action);
+    }
+
+    @PluginMethod
+    public void getCookies(PluginCall call) {
+        this.bridge.eval("document.cookie", (value) -> {
+            String cookies = value.substring(1, value.length() - 1);
+            String[] cookieArray = cookies.split(";");
+
+            JSObject cookieMap = new JSObject();
+
+            for (String cookie : cookieArray) {
+                if (cookie.length() > 0) {
+                    String[] keyValue = cookie.split("=", 2);
+
+                    if (keyValue.length == 2) {
+                        String key = keyValue[0].trim();
+                        String val = keyValue[1].trim();
+                        try {
+                            key = URLDecoder.decode(keyValue[0].trim(), StandardCharsets.UTF_8.name());
+                            val = URLDecoder.decode(keyValue[1].trim(), StandardCharsets.UTF_8.name());
+                        } catch (UnsupportedEncodingException ignored) {}
+
+                        cookieMap.put(key, val);
+                    }
+                }
+            }
+
+            call.resolve(cookieMap);
+        });
+    }
+
+    @PluginMethod
+    public void setCookie(PluginCall call) {
+        String key = call.getString("key");
+        if (null == key) {
+            call.reject("Must provide key");
+        }
+        String value = call.getString("value");
+        if (null == value) {
+            call.reject("Must provide value");
+        }
+        String url = call.getString("url");
+        String expires = call.getString("expires", "");
+        String path = call.getString("path", "/");
+        cookieManager.setCookie(url, key, value, expires, path);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void deleteCookie(PluginCall call) {
+        String key = call.getString("key");
+        if (null == key) {
+            call.reject("Must provide key");
+        }
+        String url = call.getString("url");
+        cookieManager.setCookie(url, key + "=; Expires=Wed, 31 Dec 2000 23:59:59 GMT");
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void clearCookies(PluginCall call) {
+        String url = call.getString("url");
+        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,119 @@
+package com.getcapacitor.plugin;
+
+import android.Manifest;
+import android.webkit.JavascriptInterface;
+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.CapacitorHttpUrlConnection;
+import com.getcapacitor.plugin.util.HttpRequestHandler;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@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 final Map<Runnable, PluginCall> activeRequests = new ConcurrentHashMap<>();
+    private final ExecutorService executor = Executors.newCachedThreadPool();
+
+    @Override
+    public void load() {
+        this.bridge.getWebView().addJavascriptInterface(this, "CapacitorHttpAndroidInterface");
+        super.load();
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        super.handleOnDestroy();
+
+        for (Map.Entry<Runnable, PluginCall> entry : activeRequests.entrySet()) {
+            Runnable job = entry.getKey();
+            PluginCall call = entry.getValue();
+
+            if (call.getData().has("activeCapacitorHttpUrlConnection")) {
+                try {
+                    CapacitorHttpUrlConnection connection = (CapacitorHttpUrlConnection) call
+                        .getData()
+                        .get("activeCapacitorHttpUrlConnection");
+                    connection.disconnect();
+                    call.getData().remove("activeCapacitorHttpUrlConnection");
+                } catch (Exception ignored) {}
+            }
+
+            getBridge().releaseCall(call);
+        }
+
+        activeRequests.clear();
+        executor.shutdownNow();
+    }
+
+    private void http(final PluginCall call, final String httpMethod) {
+        Runnable asyncHttpCall = new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    JSObject response = HttpRequestHandler.request(call, httpMethod, getBridge());
+                    call.resolve(response);
+                } catch (Exception e) {
+                    call.reject(e.getLocalizedMessage(), e.getClass().getSimpleName(), e);
+                } finally {
+                    activeRequests.remove(this);
+                }
+            }
+        };
+
+        if (!executor.isShutdown()) {
+            activeRequests.put(asyncHttpCall, call);
+            executor.submit(asyncHttpCall);
+        } else {
+            call.reject("Failed to execute request - Http Plugin was shutdown");
+        }
+    }
+
+    @JavascriptInterface
+    public boolean isEnabled() {
+        PluginConfig pluginConfig = getBridge().getConfig().getPluginConfiguration("CapacitorHttp");
+        return pluginConfig.getBoolean("enabled", 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");
+    }
+}

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

@@ -0,0 +1,220 @@
+package com.getcapacitor.plugin;
+
+import android.content.pm.PackageInfo;
+import android.content.res.Configuration;
+import android.view.View;
+import android.view.Window;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
+import androidx.webkit.WebViewCompat;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@CapacitorPlugin
+public class SystemBars extends Plugin {
+
+    static final String STYLE_LIGHT = "LIGHT";
+    static final String STYLE_DARK = "DARK";
+    static final String STYLE_DEFAULT = "DEFAULT";
+    static final String BAR_STATUS_BAR = "StatusBar";
+    static final String BAR_GESTURE_BAR = "NavigationBar";
+
+    static final String viewportMetaJSFunction = """
+        function capacitorSystemBarsCheckMetaViewport() {
+            const meta = document.querySelectorAll("meta[name=viewport]");
+            if (meta.length == 0) {
+                return false;
+            }
+            // get the last found meta viewport tag
+            const metaContent = meta[meta.length - 1].content;
+            return metaContent.includes("viewport-fit=cover");
+        }
+
+        capacitorSystemBarsCheckMetaViewport();
+        """;
+
+    @Override
+    public void load() {
+        super.load();
+        initSystemBars();
+    }
+
+    private boolean hasFixedWebView() {
+        PackageInfo packageInfo = WebViewCompat.getCurrentWebViewPackage(bridge.getContext());
+        Pattern pattern = Pattern.compile("(\\d+)");
+        Matcher matcher = pattern.matcher(packageInfo.versionName);
+
+        if (!matcher.find()) {
+            return false;
+        }
+
+        String majorVersionStr = matcher.group(0);
+        int majorVersion = Integer.parseInt(majorVersionStr);
+
+        return majorVersion >= 140;
+    }
+
+    private void initSystemBars() {
+        String style = getConfig().getString("style", STYLE_DEFAULT).toUpperCase(Locale.US);
+        boolean hidden = getConfig().getBoolean("hidden", false);
+        boolean disableCSSInsets = getConfig().getBoolean("disableInsets", false);
+
+        this.bridge.getWebView().evaluateJavascript(viewportMetaJSFunction, (res) -> {
+            boolean hasMetaViewportCover = res.equals("true");
+            if (!disableCSSInsets) {
+                setupSafeAreaInsets(this.hasFixedWebView(), hasMetaViewportCover);
+            }
+        });
+
+        getBridge().executeOnMainThread(() -> {
+            setStyle(style, "");
+            setHidden(hidden, "");
+        });
+    }
+
+    @PluginMethod
+    public void setStyle(final PluginCall call) {
+        String bar = call.getString("bar", "");
+        String style = call.getString("style", STYLE_DEFAULT);
+
+        getBridge().executeOnMainThread(() -> {
+            setStyle(style, bar);
+            call.resolve();
+        });
+    }
+
+    @PluginMethod
+    public void show(final PluginCall call) {
+        String bar = call.getString("bar", "");
+
+        getBridge().executeOnMainThread(() -> {
+            setHidden(false, bar);
+            call.resolve();
+        });
+    }
+
+    @PluginMethod
+    public void hide(final PluginCall call) {
+        String bar = call.getString("bar", "");
+
+        getBridge().executeOnMainThread(() -> {
+            setHidden(true, bar);
+            call.resolve();
+        });
+    }
+
+    @PluginMethod
+    public void setAnimation(final PluginCall call) {
+        call.resolve();
+    }
+
+    private void setupSafeAreaInsets(boolean hasFixedWebView, boolean hasMetaViewportCover) {
+        ViewCompat.setOnApplyWindowInsetsListener((View) getBridge().getWebView().getParent(), (v, insets) -> {
+            if (hasFixedWebView && hasMetaViewportCover) {
+                return insets;
+            }
+
+            Insets safeArea = insets.getInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout());
+            Insets imeInsets = insets.getInsets(WindowInsetsCompat.Type.ime());
+            boolean keyboardVisible = insets.isVisible(WindowInsetsCompat.Type.ime());
+
+            int bottomInsets = safeArea.bottom;
+
+            if (keyboardVisible) {
+                // When https://issues.chromium.org/issues/457682720 is fixed and released,
+                // add behind a WebView version check
+                bottomInsets = imeInsets.bottom - bottomInsets;
+            }
+
+            injectSafeAreaCSS(safeArea.top, safeArea.right, bottomInsets, safeArea.left);
+
+            return WindowInsetsCompat.CONSUMED;
+        });
+    }
+
+    private void injectSafeAreaCSS(int top, int right, int bottom, int left) {
+        // Convert pixels to density-independent pixels
+        float density = getActivity().getResources().getDisplayMetrics().density;
+        float topPx = top / density;
+        float rightPx = right / density;
+        float bottomPx = bottom / density;
+        float leftPx = left / density;
+
+        // Execute JavaScript to inject the CSS
+        getBridge().executeOnMainThread(() -> {
+            if (bridge != null && bridge.getWebView() != null) {
+                String script = String.format(
+                    Locale.US,
+                    """
+                    try {
+                      document.documentElement.style.setProperty("--safe-area-inset-top", "%dpx");
+                      document.documentElement.style.setProperty("--safe-area-inset-right", "%dpx");
+                      document.documentElement.style.setProperty("--safe-area-inset-bottom", "%dpx");
+                      document.documentElement.style.setProperty("--safe-area-inset-left", "%dpx");
+                    } catch(e) { console.error('Error injecting safe area CSS:', e); }
+                    """,
+                    (int) topPx,
+                    (int) rightPx,
+                    (int) bottomPx,
+                    (int) leftPx
+                );
+
+                bridge.getWebView().evaluateJavascript(script, null);
+            }
+        });
+    }
+
+    private void setStyle(String style, String bar) {
+        if (style.equals(STYLE_DEFAULT)) {
+            style = getStyleForTheme();
+        }
+
+        Window window = getActivity().getWindow();
+        WindowInsetsControllerCompat windowInsetsControllerCompat = WindowCompat.getInsetsController(window, window.getDecorView());
+        if (bar.isEmpty() || bar.equals(BAR_STATUS_BAR)) {
+            windowInsetsControllerCompat.setAppearanceLightStatusBars(!style.equals(STYLE_DARK));
+        }
+
+        if (bar.isEmpty() || bar.equals(BAR_GESTURE_BAR)) {
+            windowInsetsControllerCompat.setAppearanceLightNavigationBars(!style.equals(STYLE_DARK));
+        }
+    }
+
+    private void setHidden(boolean hide, String bar) {
+        Window window = getActivity().getWindow();
+        WindowInsetsControllerCompat windowInsetsControllerCompat = WindowCompat.getInsetsController(window, window.getDecorView());
+
+        if (hide) {
+            if (bar.isEmpty() || bar.equals(BAR_STATUS_BAR)) {
+                windowInsetsControllerCompat.hide(WindowInsetsCompat.Type.statusBars());
+            }
+            if (bar.isEmpty() || bar.equals(BAR_GESTURE_BAR)) {
+                windowInsetsControllerCompat.hide(WindowInsetsCompat.Type.navigationBars());
+            }
+            return;
+        }
+
+        if (bar.isEmpty() || bar.equals(BAR_STATUS_BAR)) {
+            windowInsetsControllerCompat.show(WindowInsetsCompat.Type.systemBars());
+        }
+        if (bar.isEmpty() || bar.equals(BAR_GESTURE_BAR)) {
+            windowInsetsControllerCompat.show(WindowInsetsCompat.Type.navigationBars());
+        }
+    }
+
+    private String getStyleForTheme() {
+        int currentNightMode = getActivity().getResources().getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK;
+        if (currentNightMode != Configuration.UI_MODE_NIGHT_YES) {
+            return STYLE_LIGHT;
+        }
+        return STYLE_DARK;
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.getcapacitor.plugin;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin
+public class WebView extends Plugin {
+
+    public static final String WEBVIEW_PREFS_NAME = "CapWebViewSettings";
+    public static final String CAP_SERVER_PATH = "serverBasePath";
+
+    @PluginMethod
+    public void setServerAssetPath(PluginCall call) {
+        String path = call.getString("path");
+        bridge.setServerAssetPath(path);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void setServerBasePath(PluginCall call) {
+        String path = call.getString("path");
+        bridge.setServerBasePath(path);
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getServerBasePath(PluginCall call) {
+        String path = bridge.getServerBasePath();
+        JSObject ret = new JSObject();
+        ret.put("path", path);
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void persistServerBasePath(PluginCall call) {
+        String path = bridge.getServerBasePath();
+        SharedPreferences prefs = getContext().getSharedPreferences(WEBVIEW_PREFS_NAME, Activity.MODE_PRIVATE);
+        SharedPreferences.Editor editor = prefs.edit();
+        editor.putString(CAP_SERVER_PATH, path);
+        editor.apply();
+        call.resolve();
+    }
+}