@capgo/capacitor-inappbrowser 8.6.31 → 8.6.34

package/CapgoCapacitorInappbrowser.podspec

@@ -11,6 +11,7 @@ Pod::Spec.new do |s|
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.resources = ['ios/Sources/InAppBrowserPlugin/Resources/proxy-bridge.js']
   s.ios.deployment_target = '15.0'
   s.dependency 'Capacitor'
   s.swift_version = '5.1'

package/Package.swift

@@ -19,7 +19,8 @@ let package = Package(
                 .product(name: "Capacitor", package: "capacitor-swift-pm"),
                 .product(name: "Cordova", package: "capacitor-swift-pm")
             ],
-            path: "ios/Sources/InAppBrowserPlugin"),
+            path: "ios/Sources/InAppBrowserPlugin",
+            resources: [.process("Resources")]),
         .testTarget(
             name: "InappbrowserPluginTests",
             dependencies: ["InappbrowserPlugin"],

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/WebViewDialog.java

@@ -6053,6 +6053,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
 
         // If both width and height are specified, use custom dimensions
         if (width != null && height != null) {
+            params.gravity = Gravity.TOP | Gravity.LEFT;
             params.width = (int) getPixels(width);
             params.height = (int) getPixels(height);
             params.x = (x != null) ? (int) getPixels(x) : 0;
@@ -6060,6 +6061,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
             params.gravity = Gravity.TOP | Gravity.START;
         } else if (height != null && width == null) {
             // If only height is specified, use custom height with fullscreen width
+            params.gravity = Gravity.TOP | Gravity.LEFT;
             params.width = WindowManager.LayoutParams.MATCH_PARENT;
             params.height = (int) getPixels(height);
             params.x = 0;

package/ios/Sources/InAppBrowserPlugin/InAppBrowserPlugin.swift

@@ -98,7 +98,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         case aware = "AWARE"
         case fakeVisible = "FAKE_VISIBLE"
     }
-    private let pluginVersion: String = "8.6.31"
+    private let pluginVersion: String = "8.6.34"
     public let identifier = "CapgoInAppBrowserPlugin"
     public let jsName = "CapgoInAppBrowser"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -135,6 +135,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
     var webViewController: WKWebViewController?
     private var webViewControllers: [String: WKWebViewController] = [:]
     private var proxySchemeHandlers: [String: ProxySchemeHandler] = [:]
+    private var proxyBridges: [String: ProxyBridge] = [:]
     private var webViewStack: [String] = []
     private var activeWebViewId: String?
     private weak var presentationContainerView: UIView?
@@ -186,6 +187,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         }
         proxySchemeHandlers[id]?.cancelAllPendingTasks()
         proxySchemeHandlers[id] = nil
+        proxyBridges[id] = nil
         webViewControllers[id] = nil
         navigationControllers[id] = nil
         webViewStack.removeAll { $0 == id }
@@ -893,16 +895,23 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
             }
 
             var proxyHandler: ProxySchemeHandler?
+            var proxyBridge: ProxyBridge?
+            var proxyBridgeAccessToken: String?
             if legacyProxyRequests.isEnabled || !outboundProxyRules.isEmpty || !inboundProxyRules.isEmpty {
+                let bridgeAccessToken = UUID().uuidString
+                proxyBridgeAccessToken = bridgeAccessToken
+                proxyBridge = ProxyBridge(accessToken: bridgeAccessToken)
                 proxyHandler = ProxySchemeHandler(
                     plugin: self,
                     webviewId: webViewId,
                     legacyProxyRequests: legacyProxyRequests.isEnabled,
                     legacyProxyRequestURLRegex: legacyProxyRequests.urlRegex,
                     outboundRules: outboundProxyRules,
-                    inboundRules: inboundProxyRules
+                    inboundRules: inboundProxyRules,
+                    proxyBridge: proxyBridge
                 )
                 self.proxySchemeHandlers[webViewId] = proxyHandler
+                self.proxyBridges[webViewId] = proxyBridge
             }
 
             self.webViewController = WKWebViewController.init(
@@ -921,6 +930,9 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
                 captureConsoleLogs: captureConsoleLogs,
                 proxyRequests: legacyProxyRequests.isEnabled,
                 proxySchemeHandler: proxyHandler,
+                proxyBridge: proxyBridge,
+                proxyBridgeAccessToken: proxyBridgeAccessToken,
+                legacyProxyRequestURLRegexPattern: legacyProxyRequests.urlRegex?.pattern,
                 documentStartUserScripts: self.documentStartUserScripts(
                     authorizedAppLinks: authorizedAppLinks,
                     openBlankTargetInWebView: openBlankTargetInWebView

package/ios/Sources/InAppBrowserPlugin/ProxyBridge.swift

@@ -0,0 +1,210 @@
+import Foundation
+
+struct ProxyBridgeStoredRequest {
+    let method: String
+    let headersJson: String
+    let base64Body: String
+    let credentialsMode: String
+    let storedAt: Date
+}
+
+public final class ProxyBridge {
+    static let storedRequestTTL: TimeInterval = 120
+
+    private let accessToken: String
+    private var storedRequests: [String: ProxyBridgeStoredRequest] = [:]
+    private var storedRequestOrder: [String] = []
+    private let lock = NSLock()
+    private let clock: () -> Date
+
+    init(accessToken: String, clock: @escaping () -> Date = Date.init) {
+        self.accessToken = accessToken
+        self.clock = clock
+    }
+
+    func storeRequest(
+        token: String,
+        requestId: String,
+        method: String,
+        headersJson: String,
+        base64Body: String,
+        credentialsMode: String
+    ) {
+        guard token == accessToken, !requestId.isEmpty else {
+            return
+        }
+
+        let now = clock()
+        lock.lock()
+        cleanupExpiredRequests(now: now)
+        storedRequests[requestId] = ProxyBridgeStoredRequest(
+            method: method,
+            headersJson: headersJson,
+            base64Body: base64Body,
+            credentialsMode: credentialsMode,
+            storedAt: now
+        )
+        storedRequestOrder.append(requestId)
+        lock.unlock()
+    }
+
+    func getAndRemove(requestId: String) -> ProxyBridgeStoredRequest? {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let storedRequest = storedRequests.removeValue(forKey: requestId) else {
+            return nil
+        }
+        storedRequestOrder.removeAll { $0 == requestId }
+        return storedRequest
+    }
+
+    private func cleanupExpiredRequests(now: Date) {
+        while let oldestRequestId = storedRequestOrder.first {
+            guard let oldestRequest = storedRequests[oldestRequestId] else {
+                storedRequestOrder.removeFirst()
+                continue
+            }
+
+            if now.timeIntervalSince(oldestRequest.storedAt) < Self.storedRequestTTL {
+                return
+            }
+
+            storedRequests.removeValue(forKey: oldestRequestId)
+            storedRequestOrder.removeFirst()
+        }
+    }
+}
+
+enum ProxyBridgeSupport {
+    struct BridgeMarkerRequest {
+        let originalURL: String
+        let requestId: String
+    }
+
+    static func isBridgeMarkerRequestURL(_ requestURL: String) -> Bool {
+        guard let components = URLComponents(string: requestURL),
+              components.path == "/_capgo_proxy_",
+              let query = components.query,
+              !query.isEmpty else {
+            return false
+        }
+        return true
+    }
+
+    static func parseBridgeMarkerRequest(_ requestURL: String) -> BridgeMarkerRequest? {
+        guard isBridgeMarkerRequestURL(requestURL),
+              let components = URLComponents(string: requestURL) else {
+            return nil
+        }
+
+        let queryItems = components.queryItems ?? []
+        guard let originalURL = queryItems.first(where: { $0.name == "u" })?.value,
+              let requestId = queryItems.first(where: { $0.name == "rid" })?.value,
+              !originalURL.isEmpty,
+              !requestId.isEmpty else {
+            return nil
+        }
+
+        return BridgeMarkerRequest(originalURL: originalURL, requestId: requestId)
+    }
+
+    static func decodeStoredHeaders(_ headersJson: String) -> [String: String] {
+        guard let data = headersJson.data(using: .utf8),
+              let headers = try? JSONSerialization.jsonObject(with: data) as? [String: String] else {
+            return [:]
+        }
+        return headers
+    }
+
+    static func shouldInjectBridge(hasProxySchemeHandler: Bool) -> Bool {
+        hasProxySchemeHandler
+    }
+
+    static func usesLegacyJsProxyMode(
+        legacyProxyRequests: Bool,
+        legacyProxyRequestURLRegex: NSRegularExpression?,
+        hasOutboundRules: Bool,
+        hasInboundRules: Bool
+    ) -> Bool {
+        (legacyProxyRequests || legacyProxyRequestURLRegex != nil) &&
+            hasOutboundRules == false &&
+            hasInboundRules == false
+    }
+
+    static func shouldDelegateLegacyJsProxyRequest(
+        legacyProxyRequests: Bool,
+        legacyProxyRequestURLRegex: NSRegularExpression?,
+        hasOutboundRules: Bool,
+        hasInboundRules: Bool,
+        requestURL: String
+    ) -> Bool {
+        guard usesLegacyJsProxyMode(
+            legacyProxyRequests: legacyProxyRequests,
+            legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
+            hasOutboundRules: hasOutboundRules,
+            hasInboundRules: hasInboundRules
+        ) else {
+            return false
+        }
+
+        guard let legacyProxyRequestURLRegex else {
+            return legacyProxyRequests
+        }
+
+        let range = NSRange(location: 0, length: requestURL.utf16.count)
+        return legacyProxyRequestURLRegex.firstMatch(in: requestURL, options: [], range: range) != nil
+    }
+
+    static func escapeJavaScriptLiteral(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "'", with: "\\'")
+            .replacingOccurrences(of: "\r", with: "\\r")
+            .replacingOccurrences(of: "\n", with: "\\n")
+            .replacingOccurrences(of: "\u{2028}", with: "\\u2028")
+            .replacingOccurrences(of: "\u{2029}", with: "\\u2029")
+    }
+
+    static func bootstrapScriptSource() -> String {
+        """
+        (function() {
+          if (window.__capgoProxy && window.__capgoProxy.__capgoNativeBridgeInstalled) {
+            return;
+          }
+          window.__capgoProxy = {
+            __capgoNativeBridgeInstalled: true,
+            storeRequest: function(token, requestId, method, headersJson, base64Body, credentialsMode) {
+              if (!window.webkit || !window.webkit.messageHandlers || !window.webkit.messageHandlers.capgoProxyBridge) {
+                return;
+              }
+              window.webkit.messageHandlers.capgoProxyBridge.postMessage({
+                token: token,
+                requestId: requestId,
+                method: method,
+                headersJson: headersJson,
+                base64Body: base64Body,
+                credentialsMode: credentialsMode
+              });
+            }
+          };
+        })();
+        """
+    }
+
+    static func loadBundledBridgeScript(accessToken: String, proxyRegexSource: String) -> String? {
+        #if SWIFT_PACKAGE
+        let bundle = Bundle.module
+        #else
+        let bundle = Bundle(for: ProxyBridge.self)
+        #endif
+
+        guard let scriptURL = bundle.url(forResource: "proxy-bridge", withExtension: "js"),
+              let rawScript = try? String(contentsOf: scriptURL) else {
+            return nil
+        }
+
+        return rawScript
+            .replacingOccurrences(of: "___CAPGO_PROXY_TOKEN___", with: escapeJavaScriptLiteral(accessToken))
+            .replacingOccurrences(of: "___CAPGO_PROXY_REGEX___", with: escapeJavaScriptLiteral(proxyRegexSource))
+    }
+}

package/ios/Sources/InAppBrowserPlugin/ProxySchemeHandler.swift

@@ -460,16 +460,17 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
     private let legacyProxyRequestURLRegex: NSRegularExpression?
     private let outboundRules: [NativeProxyRule]
     private let inboundRules: [NativeProxyRule]
+    private weak var proxyBridge: ProxyBridge?
 
     private lazy var session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)
-
     init(
         plugin: CapgoInAppBrowserPlugin,
         webviewId: String,
         legacyProxyRequests: Bool,
         legacyProxyRequestURLRegex: NSRegularExpression?,
         outboundRules: [NativeProxyRule],
-        inboundRules: [NativeProxyRule]
+        inboundRules: [NativeProxyRule],
+        proxyBridge: ProxyBridge? = nil
     ) {
         self.plugin = plugin
         self.webviewId = webviewId
@@ -477,6 +478,7 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         self.legacyProxyRequestURLRegex = legacyProxyRequestURLRegex
         self.outboundRules = outboundRules
         self.inboundRules = inboundRules
+        self.proxyBridge = proxyBridge
         super.init()
     }
 
@@ -488,7 +490,8 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
             legacyProxyRequests: legacyProxyRequests,
             legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
             outboundRules: outboundRules,
-            inboundRules: inboundRules
+            inboundRules: inboundRules,
+            proxyBridge: proxyBridge
         )
     }
 
@@ -505,13 +508,10 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         }
 
         let requestId = UUID().uuidString
-        let requestContext = NativeRequestContext(
-            url: url.absoluteString,
-            method: ProxySchemeRequestSupport.normalizedRequestMethod(urlSchemeTask.request.httpMethod),
-            headers: urlSchemeTask.request.allHTTPHeaderFields ?? [:],
-            base64Body: extractBody(from: urlSchemeTask.request),
-            isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
-        )
+        guard let requestContext = makeInitialRequestContext(from: urlSchemeTask, requestURL: url) else {
+            finishCanceledSchemeTask(urlSchemeTask)
+            return
+        }
         let pendingTask = PendingProxyTask(requestId: requestId, schemeTask: urlSchemeTask, requestContext: requestContext, phase: "outbound")
 
         taskLock.lock()
@@ -1169,6 +1169,80 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         }
     }
 
+
+    private func makeInitialRequestContext(from urlSchemeTask: WKURLSchemeTask, requestURL: URL) -> NativeRequestContext? {
+        let requestURLString = requestURL.absoluteString
+
+        if let bridgeRequest = ProxyBridgeSupport.parseBridgeMarkerRequest(requestURLString) {
+            if ProxyBridgeSupport.usesLegacyJsProxyMode(
+                legacyProxyRequests: legacyProxyRequests,
+                legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
+                hasOutboundRules: !outboundRules.isEmpty,
+                hasInboundRules: !inboundRules.isEmpty
+            ),
+            !ProxyBridgeSupport.shouldDelegateLegacyJsProxyRequest(
+                legacyProxyRequests: legacyProxyRequests,
+                legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
+                hasOutboundRules: !outboundRules.isEmpty,
+                hasInboundRules: !inboundRules.isEmpty,
+                requestURL: bridgeRequest.originalURL
+            ) {
+                _ = proxyBridge?.getAndRemove(requestId: bridgeRequest.requestId)
+                return nil
+            }
+
+            guard let stored = proxyBridge?.getAndRemove(requestId: bridgeRequest.requestId) else {
+                return nil
+            }
+
+            var headers = ProxyBridgeSupport.decodeStoredHeaders(stored.headersJson)
+            let markerHeaders = urlSchemeTask.request.allHTTPHeaderFields ?? [:]
+            for (key, value) in markerHeaders where headers[key] == nil {
+                headers[key] = value
+            }
+
+            let base64Body = stored.base64Body.isEmpty ? nil : stored.base64Body
+            return NativeRequestContext(
+                url: bridgeRequest.originalURL,
+                method: ProxySchemeRequestSupport.normalizedRequestMethod(stored.method),
+                headers: headers,
+                base64Body: base64Body,
+                isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
+            )
+        }
+
+        return NativeRequestContext(
+            url: requestURLString,
+            method: ProxySchemeRequestSupport.normalizedRequestMethod(urlSchemeTask.request.httpMethod),
+            headers: urlSchemeTask.request.allHTTPHeaderFields ?? [:],
+            base64Body: extractBody(from: urlSchemeTask.request),
+            isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
+        )
+    }
+
+    private func finishCanceledSchemeTask(_ schemeTask: WKURLSchemeTask) {
+        guard let url = schemeTask.request.url,
+              let httpResponse = HTTPURLResponse(
+                url: url,
+                statusCode: 204,
+                httpVersion: "HTTP/1.1",
+                headerFields: [:]
+              )
+        else {
+            schemeTask.didFailWithError(
+                NSError(
+                    domain: "ProxySchemeHandler",
+                    code: -4,
+                    userInfo: [NSLocalizedDescriptionKey: "Failed to create canceled response"]
+                )
+            )
+            return
+        }
+
+        schemeTask.didReceive(httpResponse)
+        schemeTask.didReceive(Data())
+        schemeTask.didFinish()
+    }
     private func extractBody(from request: URLRequest) -> String? {
         if let body = request.httpBody {
             return body.base64EncodedString()