fix(http): route get requests through custom handler

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

@@ -423,10 +423,25 @@ var nativeBridge = (function (exports) {
                 if (doPatchHttp) {
                     // fetch patch
                     window.fetch = async (resource, options) => {
+                        var _a;
                         if (!(resource.toString().startsWith('http:') ||
                             resource.toString().startsWith('https:'))) {
                             return win.CapacitorWebFetch(resource, options);
                         }
+                        if (!(options === null || options === void 0 ? void 0 : options.method) ||
+                            options.method.toLocaleUpperCase() === 'GET' ||
+                            options.method.toLocaleUpperCase() === 'HEAD' ||
+                            options.method.toLocaleUpperCase() === 'OPTIONS' ||
+                            options.method.toLocaleUpperCase() === 'TRACE') {
+                            const url = new URL(resource.toString());
+                            if (platform === 'ios') {
+                                url.protocol = (_a = win.WEBVIEW_SERVER_URL) !== null && _a !== void 0 ? _a : '';
+                            }
+                            url.pathname = '/_capacitor_http_interceptor_' + url.pathname;
+                            const modifiedResource = url.toString();
+                            const response = await win.CapacitorWebFetch(modifiedResource, options);
+                            return response;
+                        }
                         const tag = `CapacitorHttp fetch ${Date.now()} ${resource}`;
                         console.time(tag);
                         try {
@@ -499,7 +514,9 @@ var nativeBridge = (function (exports) {
                         });
                         xhr.readyState = 0;
                         const prototype = win.CapacitorWebXMLHttpRequest.prototype;
-                        const isRelativeURL = (url) => !url || !(url.startsWith('http:') || url.startsWith('https:'));
+                        const isRelativeURL = (url) => !url ||
+                            !(url.startsWith('http:') || url.startsWith('https:')) ||
+                            url.indexOf('/_capacitor_http_interceptor_') > -1;
                         const isProgressEventAvailable = () => typeof ProgressEvent !== 'undefined' &&
                             ProgressEvent.prototype instanceof Event;
                         // XHR patch abort
@@ -515,10 +532,25 @@ var nativeBridge = (function (exports) {
                         };
                         // XHR patch open
                         prototype.open = function (method, url) {
+                            var _a;
+                            this._method = method.toLocaleUpperCase();
                             this._url = url;
-                            this._method = method;
-                            if (isRelativeURL(url)) {
-                                return win.CapacitorWebXMLHttpRequest.open.call(this, method, url);
+                            if (!this._method ||
+                                this._method === 'GET' ||
+                                this._method === 'HEAD' ||
+                                this._method === 'OPTIONS' ||
+                                this._method === 'TRACE') {
+                                if (isRelativeURL(url)) {
+                                    return win.CapacitorWebXMLHttpRequest.open.call(this, method, url);
+                                }
+                                const modifiedUrl = new URL(this._url);
+                                if (platform === 'ios') {
+                                    modifiedUrl.protocol = (_a = win.WEBVIEW_SERVER_URL) !== null && _a !== void 0 ? _a : '';
+                                }
+                                modifiedUrl.pathname =
+                                    '/_capacitor_http_interceptor_' + modifiedUrl.pathname;
+                                this._url = modifiedUrl.toString();
+                                return win.CapacitorWebXMLHttpRequest.open.call(this, method, this._url);
                             }
                             setTimeout(() => {
                                 this.dispatchEvent(new Event('loadstart'));

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

@@ -86,6 +86,7 @@ public class Bridge {
     public static final String CAPACITOR_HTTPS_SCHEME = "https";
     public static final String CAPACITOR_FILE_START = "/_capacitor_file_";
     public static final String CAPACITOR_CONTENT_START = "/_capacitor_content_";
+    public static final String CAPACITOR_HTTP_INTERCEPTOR_START = "/_capacitor_http_interceptor_";
     public static final int DEFAULT_ANDROID_WEBVIEW_VERSION = 60;
     public static final int MINIMUM_ANDROID_WEBVIEW_VERSION = 55;
     public static final int DEFAULT_HUAWEI_WEBVIEW_VERSION = 10;

android/capacitor/src/main/java/com/getcapacitor/WebViewLocalServer.java

@@ -21,14 +21,18 @@
 import android.webkit.CookieManager;
 import android.webkit.WebResourceRequest;
 import android.webkit.WebResourceResponse;
+import com.getcapacitor.plugin.util.CapacitorHttpUrlConnection;
+import com.getcapacitor.plugin.util.HttpRequestHandler;
 import java.io.IOException;
 import java.io.InputStream;
+import java.lang.reflect.Method;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.net.URLConnection;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -165,6 +169,16 @@ private static Uri parseAndVerifyUrl(String url) {
      */
     public WebResourceResponse shouldInterceptRequest(WebResourceRequest request) {
         Uri loadingUrl = request.getUrl();
+
+        if (null != loadingUrl.getPath() && loadingUrl.getPath().startsWith(Bridge.CAPACITOR_HTTP_INTERCEPTOR_START)) {
+            Logger.debug("Handling CapacitorHttp request: " + request.getUrl().toString());
+            try {
+                return handleCapacitorHttpRequest(request);
+            } catch (Exception e) {
+                Logger.error(e.getLocalizedMessage());
+            }
+        }
+
         PathHandler handler;
         synchronized (uriMatcher) {
             handler = (PathHandler) uriMatcher.match(request.getUrl());
@@ -199,6 +213,110 @@ private boolean isAllowedUrl(Uri loadingUrl) {
         return !(bridge.getServerUrl() == null && !bridge.getAppAllowNavigationMask().matches(loadingUrl.getHost()));
     }
 
+    private Boolean isDomainExcludedFromSSL(Bridge bridge, URL url) {
+        try {
+            Class<?> sslPinningImpl = Class.forName("io.ionic.sslpinning.SSLPinning");
+            Method method = sslPinningImpl.getDeclaredMethod("isDomainExcluded", Bridge.class, URL.class);
+            return (Boolean) method.invoke(sslPinningImpl.newInstance(), bridge, url);
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    private String getReasonPhraseFromResponseCode(int code) {
+        return switch (code) {
+            case 100 -> "Continue";
+            case 101 -> "Switching Protocols";
+            case 200 -> "OK";
+            case 201 -> "Created";
+            case 202 -> "Accepted";
+            case 203 -> "Non-Authoritative Information";
+            case 204 -> "No Content";
+            case 205 -> "Reset Content";
+            case 206 -> "Partial Content";
+            case 300 -> "Multiple Choices";
+            case 301 -> "Moved Permanently";
+            case 302 -> "Found";
+            case 303 -> "See Other";
+            case 304 -> "Not Modified";
+            case 400 -> "Bad Request";
+            case 401 -> "Unauthorized";
+            case 403 -> "Forbidden";
+            case 404 -> "Not Found";
+            case 405 -> "Method Not Allowed";
+            case 406 -> "Not Acceptable";
+            case 407 -> "Proxy Authentication Required";
+            case 408 -> "Request Timeout";
+            case 409 -> "Conflict";
+            case 410 -> "Gone";
+            case 500 -> "Internal Server Error";
+            case 501 -> "Not Implemented";
+            case 502 -> "Bad Gateway";
+            case 503 -> "Service Unavailable";
+            case 504 -> "Gateway Timeout";
+            case 505 -> "HTTP Version Not Supported";
+            default -> "Unknown";
+        };
+    }
+
+    private WebResourceResponse handleCapacitorHttpRequest(WebResourceRequest request) throws IOException {
+        String urlString = request.getUrl().toString().replace(Bridge.CAPACITOR_HTTP_INTERCEPTOR_START, "");
+        URL url = new URL(urlString);
+        JSObject headers = new JSObject();
+
+        for (Map.Entry<String, String> header : request.getRequestHeaders().entrySet()) {
+            headers.put(header.getKey(), header.getValue());
+        }
+
+        HttpRequestHandler.HttpURLConnectionBuilder connectionBuilder = new HttpRequestHandler.HttpURLConnectionBuilder()
+            .setUrl(url)
+            .setMethod(request.getMethod())
+            .setHeaders(headers)
+            .openConnection();
+
+        CapacitorHttpUrlConnection connection = connectionBuilder.build();
+
+        if (null != bridge && !isDomainExcludedFromSSL(bridge, url)) {
+            connection.setSSLSocketFactory(bridge);
+        }
+
+        connection.connect();
+
+        String mimeType = null;
+        String encoding = null;
+        Map<String, String> responseHeaders = new LinkedHashMap<>();
+        for (Map.Entry<String, List<String>> entry : connection.getHeaderFields().entrySet()) {
+            StringBuilder builder = new StringBuilder();
+            for (String value : entry.getValue()) {
+                builder.append(value);
+                builder.append(", ");
+            }
+            builder.setLength(builder.length() - 2);
+
+            if ("Content-Type".equalsIgnoreCase(entry.getKey())) {
+                String[] contentTypeParts = builder.toString().split(";");
+                mimeType = contentTypeParts[0].trim();
+                if (contentTypeParts.length > 1) {
+                    String[] encodingParts = contentTypeParts[1].split("=");
+                    if (encodingParts.length > 1) {
+                        encoding = encodingParts[1].trim();
+                    }
+                }
+            } else {
+                responseHeaders.put(entry.getKey(), builder.toString());
+            }
+        }
+
+        if (null == mimeType) {
+            mimeType = getMimeType(request.getUrl().getPath(), connection.getInputStream());
+        }
+
+        int responseCode = connection.getResponseCode();
+        String reasonPhrase = getReasonPhraseFromResponseCode(responseCode);
+
+        return new WebResourceResponse(mimeType, encoding, responseCode, reasonPhrase, responseHeaders, connection.getInputStream());
+    }
+
     private WebResourceResponse handleLocalRequest(WebResourceRequest request, PathHandler handler) {
         String path = request.getUrl().getPath();
 

core/native-bridge.ts

@@ -480,6 +480,28 @@ const initBridge = (w: any): void => {
             return win.CapacitorWebFetch(resource, options);
           }
 
+          if (
+            !options?.method ||
+            options.method.toLocaleUpperCase() === 'GET' ||
+            options.method.toLocaleUpperCase() === 'HEAD' ||
+            options.method.toLocaleUpperCase() === 'OPTIONS' ||
+            options.method.toLocaleUpperCase() === 'TRACE'
+          ) {
+            const url = new URL(resource.toString());
+            if (platform === 'ios') {
+              url.protocol = win.WEBVIEW_SERVER_URL ?? '';
+            }
+            url.pathname = '/_capacitor_http_interceptor_' + url.pathname;
+
+            const modifiedResource = url.toString();
+            const response = await win.CapacitorWebFetch(
+              modifiedResource,
+              options,
+            );
+
+            return response;
+          }
+
           const tag = `CapacitorHttp fetch ${Date.now()} ${resource}`;
           console.time(tag);
           try {
@@ -578,7 +600,9 @@ const initBridge = (w: any): void => {
           const prototype = win.CapacitorWebXMLHttpRequest.prototype;
 
           const isRelativeURL = (url: string | undefined) =>
-            !url || !(url.startsWith('http:') || url.startsWith('https:'));
+            !url ||
+            !(url.startsWith('http:') || url.startsWith('https:')) ||
+            url.indexOf('/_capacitor_http_interceptor_') > -1;
           const isProgressEventAvailable = () =>
             typeof ProgressEvent !== 'undefined' &&
             ProgressEvent.prototype instanceof Event;
@@ -597,14 +621,37 @@ const initBridge = (w: any): void => {
 
           // XHR patch open
           prototype.open = function (method: string, url: string) {
+            this._method = method.toLocaleUpperCase();
             this._url = url;
-            this._method = method;
 
-            if (isRelativeURL(url)) {
+            if (
+              !this._method ||
+              this._method === 'GET' ||
+              this._method === 'HEAD' ||
+              this._method === 'OPTIONS' ||
+              this._method === 'TRACE'
+            ) {
+              if (isRelativeURL(url)) {
+                return win.CapacitorWebXMLHttpRequest.open.call(
+                  this,
+                  method,
+                  url,
+                );
+              }
+
+              const modifiedUrl = new URL(this._url);
+              if (platform === 'ios') {
+                modifiedUrl.protocol = win.WEBVIEW_SERVER_URL ?? '';
+              }
+              modifiedUrl.pathname =
+                '/_capacitor_http_interceptor_' + modifiedUrl.pathname;
+
+              this._url = modifiedUrl.toString();
+
               return win.CapacitorWebXMLHttpRequest.open.call(
                 this,
                 method,
-                url,
+                this._url,
               );
             }
 

ios/Capacitor/Capacitor/CapacitorBridge.swift

@@ -90,6 +90,7 @@ internal class CapacitorBridge: NSObject, CAPBridgeProtocol {
     static let tmpVCAppeared = Notification(name: Notification.Name(rawValue: "tmpViewControllerAppeared"))
     public static let capacitorSite = "https://capacitorjs.com/"
     public static let fileStartIdentifier = "/_capacitor_file_"
+    public static let httpInterceptorStartIdentifier = "/_capacitor_http_interceptor_"
     public static let defaultScheme = "capacitor"
 
     var webViewAssetHandler: WebViewAssetHandler

ios/Capacitor/Capacitor/WebViewAssetHandler.swift

@@ -25,6 +25,11 @@ internal class WebViewAssetHandler: NSObject, WKURLSchemeHandler {
         let url = urlSchemeTask.request.url!
         let stringToLoad = url.path
 
+        if url.path.starts(with: CapacitorBridge.httpInterceptorStartIdentifier) {
+            handleCapacitorHttpRequest(urlSchemeTask)
+            return
+        }
+
         if stringToLoad.starts(with: CapacitorBridge.fileStartIdentifier) {
             startPath = stringToLoad.replacingOccurrences(of: CapacitorBridge.fileStartIdentifier, with: "")
         } else {
@@ -121,6 +126,62 @@ internal class WebViewAssetHandler: NSObject, WKURLSchemeHandler {
         return false
     }
 
+    func handleCapacitorHttpRequest(_ urlSchemeTask: WKURLSchemeTask) {
+        var urlRequest = urlSchemeTask.request
+        let url = urlRequest.url!
+        var targetUrl = url.absoluteString
+            .replacingOccurrences(of: CapacitorBridge.httpInterceptorStartIdentifier, with: "")
+
+        // Only replace first occurrence of the scheme
+        if let range = targetUrl.range(of: InstanceDescriptorDefaults.scheme) {
+            targetUrl = targetUrl.replacingCharacters(in: range, with: "https")
+        }
+
+        urlRequest.url = URL(string: targetUrl)
+
+        let urlSession = URLSession.shared
+        let task = urlSession.dataTask(with: urlRequest) { (data, response, error) in
+            urlSession.invalidateAndCancel()
+            if let error = error {
+                urlSchemeTask.didFailWithError(error)
+                return
+            }
+
+            if let response = response as? HTTPURLResponse {
+                let existingHeaders = response.allHeaderFields
+                var newHeaders: [AnyHashable: Any] = [:]
+
+                // if using live reload, then set CORS headers
+                if self.serverUrl != nil && self.serverUrl?.scheme != urlRequest.url?.scheme {
+                    newHeaders = [
+                        "Access-Control-Allow-Origin": self.serverUrl?.absoluteString ?? "",
+                        "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS, TRACE"
+                    ]
+                }
+
+                if let mergedHeaders = existingHeaders.merging(newHeaders, uniquingKeysWith: { (current, _) in current }) as? [String: String] {
+
+                    let modifiedResponse = HTTPURLResponse(
+                        url: response.url!,
+                        statusCode: response.statusCode,
+                        httpVersion: nil,
+                        headerFields: mergedHeaders
+                    )!
+
+                    urlSchemeTask.didReceive(modifiedResponse)
+
+                    if let data = data {
+                        urlSchemeTask.didReceive(data)
+                    }
+                }
+            }
+            urlSchemeTask.didFinish()
+            return
+        }
+
+        task.resume()
+    }
+
     let mimeTypes = [
         "aaf": "application/octet-stream",
         "aca": "application/octet-stream",