@capawesome/capacitor-in-app-browser 0.0.1

package/ios/Plugin/Classes/WebViewController.swift

@@ -0,0 +1,224 @@
+import Foundation
+import UIKit
+import WebKit
+
+@objc public class WebViewController: UIViewController, WKNavigationDelegate, WKScriptMessageHandler, WKUIDelegate {
+    var onClosed: ((WebViewController) -> Void)?
+    var onMessageReceived: ((String) -> Void)?
+    var onPageLoaded: (() -> Void)?
+    var onPageNavigationCompleted: ((String) -> Void)?
+
+    private static let bridgeJavaScript =
+        "window.CapacitorInAppBrowser = window.CapacitorInAppBrowser || { postMessage: function (data) "
+        + "{ window.webkit.messageHandlers.capacitorInAppBrowser.postMessage(JSON.stringify(data)); } };"
+    private static let messageHandlerName = "capacitorInAppBrowser"
+
+    private let options: OpenInWebViewOptions
+
+    private var backButtonItem: UIBarButtonItem?
+    private var canGoBackObservation: NSKeyValueObservation?
+    private var canGoForwardObservation: NSKeyValueObservation?
+    private var forwardButtonItem: UIBarButtonItem?
+    private var initialLoadNotified = false
+    private var titleObservation: NSKeyValueObservation?
+    private var urlObservation: NSKeyValueObservation?
+    private var webView: WKWebView?
+
+    init(options: OpenInWebViewOptions) {
+        self.options = options
+        super.init(nibName: nil, bundle: nil)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    public func executeScript(_ script: String, completion: @escaping (_ result: Any?, _ error: Error?) -> Void) {
+        guard let webView = webView else {
+            completion(nil, nil)
+            return
+        }
+        webView.evaluateJavaScript(script) { result, error in
+            completion(result, error)
+        }
+    }
+
+    public func postMessage(_ data: String) {
+        webView?.evaluateJavaScript(
+            "window.dispatchEvent(new CustomEvent('capacitorInAppBrowserMessage', { detail: \(data) }));",
+            completionHandler: nil
+        )
+    }
+
+    public func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+        if let data = message.body as? String {
+            onMessageReceived?(data)
+        }
+    }
+
+    override public func viewDidDisappear(_ animated: Bool) {
+        super.viewDidDisappear(animated)
+        if isBeingDismissed || navigationController?.isBeingDismissed == true {
+            cleanup()
+            onClosed?(self)
+        }
+    }
+
+    override public func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .systemBackground
+        let webView = createWebView()
+        self.webView = webView
+        view.addSubview(webView)
+        NSLayoutConstraint.activate([
+            webView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
+            webView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            webView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            webView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
+        ])
+        configureNavigationBar()
+        loadUrl()
+    }
+
+    public func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
+        if navigationAction.targetFrame == nil {
+            webView.load(navigationAction.request)
+        }
+        return nil
+    }
+
+    public func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        updateNavigationButtons()
+        updateTitle()
+        if !initialLoadNotified {
+            initialLoadNotified = true
+            onPageLoaded?()
+        }
+        if let url = webView.url?.absoluteString {
+            onPageNavigationCompleted?(url)
+        }
+    }
+
+    public func webView(_ webView: WKWebView, requestMediaCapturePermissionFor origin: WKSecurityOrigin, initiatedByFrame frame: WKFrameInfo, type: WKMediaCaptureType, decisionHandler: @escaping (WKPermissionDecision) -> Void) {
+        decisionHandler(.grant)
+    }
+
+    private func cleanup() {
+        webView?.configuration.userContentController.removeScriptMessageHandler(forName: Self.messageHandlerName)
+    }
+
+    private func configureNavigationBar() {
+        let closeButtonItem = UIBarButtonItem(
+            title: options.toolbar.closeButtonText,
+            style: .plain,
+            target: self,
+            action: #selector(handleClose)
+        )
+        navigationItem.leftBarButtonItem = closeButtonItem
+        if options.toolbar.showNavigationButtons {
+            let backButtonItem = UIBarButtonItem(
+                image: UIImage(systemName: "chevron.left"),
+                style: .plain,
+                target: self,
+                action: #selector(handleGoBack)
+            )
+            let forwardButtonItem = UIBarButtonItem(
+                image: UIImage(systemName: "chevron.right"),
+                style: .plain,
+                target: self,
+                action: #selector(handleGoForward)
+            )
+            navigationItem.rightBarButtonItems = [forwardButtonItem, backButtonItem]
+            self.backButtonItem = backButtonItem
+            self.forwardButtonItem = forwardButtonItem
+            updateNavigationButtons()
+        }
+        if let backgroundColor = options.toolbar.backgroundColor {
+            let appearance = UINavigationBarAppearance()
+            appearance.configureWithOpaqueBackground()
+            appearance.backgroundColor = backgroundColor
+            if let color = options.toolbar.color {
+                appearance.titleTextAttributes = [.foregroundColor: color]
+            }
+            navigationController?.navigationBar.standardAppearance = appearance
+            navigationController?.navigationBar.scrollEdgeAppearance = appearance
+            navigationController?.navigationBar.compactAppearance = appearance
+        }
+        if let color = options.toolbar.color {
+            navigationController?.navigationBar.tintColor = color
+        }
+        updateTitle()
+    }
+
+    private func createWebView() -> WKWebView {
+        let configuration = WKWebViewConfiguration()
+        configuration.allowsInlineMediaPlayback = true
+        configuration.mediaTypesRequiringUserActionForPlayback = options.mediaPlaybackRequiresUserAction ? .all : []
+        configuration.websiteDataStore = options.isolatedDataStore ? .nonPersistent() : .default()
+        let userContentController = WKUserContentController()
+        userContentController.addUserScript(WKUserScript(source: Self.bridgeJavaScript, injectionTime: .atDocumentStart, forMainFrameOnly: true))
+        userContentController.add(self, name: Self.messageHandlerName)
+        configuration.userContentController = userContentController
+        let webView = WKWebView(frame: .zero, configuration: configuration)
+        webView.translatesAutoresizingMaskIntoConstraints = false
+        webView.navigationDelegate = self
+        webView.uiDelegate = self
+        webView.allowsBackForwardNavigationGestures = options.allowsBackForwardNavigationGestures
+        webView.scrollView.bounces = options.overscroll
+        if let userAgent = options.userAgent {
+            webView.customUserAgent = userAgent
+        }
+        canGoBackObservation = webView.observe(\.canGoBack, options: [.new]) { [weak self] _, _ in
+            self?.updateNavigationButtons()
+        }
+        canGoForwardObservation = webView.observe(\.canGoForward, options: [.new]) { [weak self] _, _ in
+            self?.updateNavigationButtons()
+        }
+        titleObservation = webView.observe(\.title, options: [.new]) { [weak self] _, _ in
+            self?.updateTitle()
+        }
+        urlObservation = webView.observe(\.url, options: [.new]) { [weak self] _, _ in
+            self?.updateTitle()
+        }
+        return webView
+    }
+
+    @objc private func handleClose() {
+        dismiss(animated: true)
+    }
+
+    @objc private func handleGoBack() {
+        if webView?.canGoBack == true {
+            webView?.goBack()
+        }
+    }
+
+    @objc private func handleGoForward() {
+        if webView?.canGoForward == true {
+            webView?.goForward()
+        }
+    }
+
+    private func loadUrl() {
+        var request = URLRequest(url: options.url)
+        for (key, value) in options.headers {
+            request.setValue(value, forHTTPHeaderField: key)
+        }
+        webView?.load(request)
+    }
+
+    private func updateNavigationButtons() {
+        backButtonItem?.isEnabled = webView?.canGoBack == true
+        forwardButtonItem?.isEnabled = webView?.canGoForward == true
+    }
+
+    private func updateTitle() {
+        if let title = options.toolbar.title {
+            navigationItem.title = title
+        } else if options.toolbar.showUrl {
+            navigationItem.title = webView?.url?.absoluteString
+        } else {
+            navigationItem.title = webView?.title
+        }
+    }
+}

package/ios/Plugin/Enums/CustomError.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+enum CustomError: Error {
+    case backgroundColorInvalid
+    case browserNotFound
+    case colorInvalid
+    case dataMissing
+    case noBrowserOpen
+    case scriptMissing
+    case toolbarColorInvalid
+    case urlInvalid
+    case urlMissing
+
+    var code: String? {
+        switch self {
+        case .browserNotFound:
+            return "BROWSER_NOT_FOUND"
+        case .noBrowserOpen:
+            return "NO_BROWSER_OPEN"
+        default:
+            return nil
+        }
+    }
+}
+
+extension CustomError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .backgroundColorInvalid:
+            return NSLocalizedString("backgroundColor must be a valid hex color code.", comment: "backgroundColorInvalid")
+        case .browserNotFound:
+            return NSLocalizedString("No app was found on the device that can open the URL.", comment: "browserNotFound")
+        case .colorInvalid:
+            return NSLocalizedString("color must be a valid hex color code.", comment: "colorInvalid")
+        case .dataMissing:
+            return NSLocalizedString("data must be provided.", comment: "dataMissing")
+        case .noBrowserOpen:
+            return NSLocalizedString("No browser is currently open.", comment: "noBrowserOpen")
+        case .scriptMissing:
+            return NSLocalizedString("script must be provided.", comment: "scriptMissing")
+        case .toolbarColorInvalid:
+            return NSLocalizedString("toolbarColor must be a valid hex color code.", comment: "toolbarColorInvalid")
+        case .urlInvalid:
+            return NSLocalizedString("url is invalid.", comment: "urlInvalid")
+        case .urlMissing:
+            return NSLocalizedString("url must be provided.", comment: "urlMissing")
+        }
+    }
+}

package/ios/Plugin/InAppBrowser.swift

@@ -0,0 +1,194 @@
+import Foundation
+import Capacitor
+import SafariServices
+import UIKit
+import WebKit
+
+@objc public class InAppBrowser: NSObject, SFSafariViewControllerDelegate {
+    let plugin: InAppBrowserPlugin
+
+    private var safariViewController: SFSafariViewController?
+    private var webViewController: WebViewController?
+
+    init(plugin: InAppBrowserPlugin) {
+        self.plugin = plugin
+    }
+
+    @objc public func clearCache(completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            let types: Set<String> = [WKWebsiteDataTypeDiskCache, WKWebsiteDataTypeMemoryCache]
+            WKWebsiteDataStore.default().removeData(ofTypes: types, modifiedSince: .distantPast) {
+                completion(nil)
+            }
+        }
+    }
+
+    @objc public func clearSessionData(completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            let types: Set<String> = [WKWebsiteDataTypeCookies, WKWebsiteDataTypeLocalStorage, WKWebsiteDataTypeSessionStorage]
+            WKWebsiteDataStore.default().removeData(ofTypes: types, modifiedSince: .distantPast) {
+                completion(nil)
+            }
+        }
+    }
+
+    @objc public func close(completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            if let webViewController = self.webViewController {
+                webViewController.dismiss(animated: true) {
+                    completion(nil)
+                }
+                return
+            }
+            if let safariViewController = self.safariViewController {
+                safariViewController.dismiss(animated: true) {
+                    self.safariViewController = nil
+                    self.plugin.notifyBrowserClosedListeners()
+                    completion(nil)
+                }
+                return
+            }
+            completion(CustomError.noBrowserOpen)
+        }
+    }
+
+    @objc public func executeScript(_ options: ExecuteScriptOptions, completion: @escaping (_ result: ExecuteScriptResult?, _ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            guard let webViewController = self.webViewController else {
+                completion(nil, CustomError.noBrowserOpen)
+                return
+            }
+            webViewController.executeScript(options.script) { result, _ in
+                completion(ExecuteScriptResult(value: result), nil)
+            }
+        }
+    }
+
+    @objc public func getCookies(_ options: GetCookiesOptions, completion: @escaping (_ result: GetCookiesResult?, _ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            WKWebsiteDataStore.default().httpCookieStore.getAllCookies { cookies in
+                var result: [String: String] = [:]
+                for cookie in cookies where InAppBrowserHelper.isCookie(cookie, matchingURL: options.url) {
+                    result[cookie.name] = cookie.value
+                }
+                completion(GetCookiesResult(cookies: result), nil)
+            }
+        }
+    }
+
+    @objc public func openInExternalBrowser(_ options: OpenInExternalBrowserOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            UIApplication.shared.open(options.url, options: [:]) { success in
+                completion(success ? nil : CustomError.browserNotFound)
+            }
+        }
+    }
+
+    @objc public func openInSystemBrowser(_ options: OpenInSystemBrowserOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            self.dismissActiveBrowser {
+                guard let bridgeViewController = self.plugin.bridge?.viewController else {
+                    completion(CustomError.noBrowserOpen)
+                    return
+                }
+                let configuration = SFSafariViewController.Configuration()
+                configuration.barCollapsingEnabled = options.barCollapsing
+                configuration.entersReaderIfAvailable = options.readerMode
+                let safariViewController = SFSafariViewController(url: options.url, configuration: configuration)
+                safariViewController.delegate = self
+                safariViewController.dismissButtonStyle = options.dismissButtonStyle
+                if let toolbarColor = options.toolbarColor {
+                    safariViewController.preferredBarTintColor = toolbarColor
+                }
+                self.safariViewController = safariViewController
+                bridgeViewController.present(safariViewController, animated: true) {
+                    completion(nil)
+                }
+            }
+        }
+    }
+
+    @objc public func openInWebView(_ options: OpenInWebViewOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            self.dismissActiveBrowser {
+                guard let bridgeViewController = self.plugin.bridge?.viewController else {
+                    completion(CustomError.noBrowserOpen)
+                    return
+                }
+                let webViewController = WebViewController(options: options)
+                webViewController.onClosed = { [weak self] viewController in
+                    guard let self = self else {
+                        return
+                    }
+                    if self.webViewController === viewController {
+                        self.webViewController = nil
+                    }
+                    self.plugin.notifyBrowserClosedListeners()
+                }
+                webViewController.onMessageReceived = { [weak self] data in
+                    self?.handleMessageReceived(data)
+                }
+                webViewController.onPageLoaded = { [weak self] in
+                    self?.plugin.notifyBrowserPageLoadedListeners()
+                }
+                webViewController.onPageNavigationCompleted = { [weak self] url in
+                    self?.plugin.notifyBrowserPageNavigationCompletedListeners(BrowserPageNavigationCompletedEvent(url: url))
+                }
+                let navigationController = UINavigationController(rootViewController: webViewController)
+                navigationController.modalPresentationStyle = .fullScreen
+                navigationController.setNavigationBarHidden(!options.toolbar.visible, animated: false)
+                self.webViewController = webViewController
+                bridgeViewController.present(navigationController, animated: true) {
+                    completion(nil)
+                }
+            }
+        }
+    }
+
+    @objc public func postMessage(_ options: PostMessageOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            guard let webViewController = self.webViewController else {
+                completion(CustomError.noBrowserOpen)
+                return
+            }
+            let data = (try? JSONSerialization.data(withJSONObject: options.data)).flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
+            webViewController.postMessage(data)
+            completion(nil)
+        }
+    }
+
+    public func safariViewController(_ controller: SFSafariViewController, didCompleteInitialLoad didLoadSuccessfully: Bool) {
+        if didLoadSuccessfully {
+            plugin.notifyBrowserPageLoadedListeners()
+        }
+    }
+
+    public func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
+        safariViewController = nil
+        plugin.notifyBrowserClosedListeners()
+    }
+
+    private func dismissActiveBrowser(_ completion: @escaping () -> Void) {
+        if let webViewController = self.webViewController {
+            webViewController.dismiss(animated: false) {
+                completion()
+            }
+        } else if let safariViewController = self.safariViewController {
+            safariViewController.dismiss(animated: false) {
+                self.safariViewController = nil
+                self.plugin.notifyBrowserClosedListeners()
+                completion()
+            }
+        } else {
+            completion()
+        }
+    }
+
+    private func handleMessageReceived(_ data: String) {
+        var value: Any = data
+        if let jsonData = data.data(using: .utf8), let parsedValue = try? JSONSerialization.jsonObject(with: jsonData, options: [.fragmentsAllowed]) {
+            value = parsedValue
+        }
+        plugin.notifyMessageReceivedListeners(MessageReceivedEvent(data: value))
+    }
+}

package/ios/Plugin/InAppBrowserHelper.swift

@@ -0,0 +1,49 @@
+import Foundation
+import UIKit
+
+public class InAppBrowserHelper {
+    public static func isCookie(_ cookie: HTTPCookie, matchingURL url: URL) -> Bool {
+        guard let host = url.host else {
+            return false
+        }
+        guard isHost(host, matchingDomain: cookie.domain) else {
+            return false
+        }
+        return isPath(url.path.isEmpty ? "/" : url.path, matchingCookiePath: cookie.path)
+    }
+
+    public static func parseColor(_ string: String) -> UIColor? {
+        guard string.hasPrefix("#") else {
+            return nil
+        }
+        let hex = String(string.dropFirst())
+        guard hex.count == 6 || hex.count == 8, let value = UInt64(hex, radix: 16) else {
+            return nil
+        }
+        let alpha = hex.count == 8 ? CGFloat((value >> 24) & 0xFF) / 255.0 : 1.0
+        let red = CGFloat((value >> 16) & 0xFF) / 255.0
+        let green = CGFloat((value >> 8) & 0xFF) / 255.0
+        let blue = CGFloat(value & 0xFF) / 255.0
+        return UIColor(red: red, green: green, blue: blue, alpha: alpha)
+    }
+
+    private static func isHost(_ host: String, matchingDomain domain: String) -> Bool {
+        let normalizedDomain = (domain.hasPrefix(".") ? String(domain.dropFirst()) : domain).lowercased()
+        let normalizedHost = host.lowercased()
+        return normalizedHost == normalizedDomain || normalizedHost.hasSuffix("." + normalizedDomain)
+    }
+
+    private static func isPath(_ path: String, matchingCookiePath cookiePath: String) -> Bool {
+        if path == cookiePath {
+            return true
+        }
+        guard path.hasPrefix(cookiePath) else {
+            return false
+        }
+        if cookiePath.hasSuffix("/") {
+            return true
+        }
+        let index = path.index(path.startIndex, offsetBy: cookiePath.count)
+        return path[index] == "/"
+    }
+}