@jimrising/easymerchantsdk-react-native 2.4.8 → 2.4.9

package/ios/Helper/GrailPayWebViewController.swift

@@ -0,0 +1,416 @@
+//
+//  GrailPayWebViewController.swift
+//  EasyPay
+//
+//  iOS WKWebView implementation for GrailPay with popup support
+//
+
+import UIKit
+import WebKit
+import Foundation
+
+public class GrailPayWebViewController: UIViewController {
+    // MARK: - Properties
+    private var mainWebView: WKWebView!
+    private var popupWebView: WKWebView?
+    private var popupContainer: UIView?
+    private var progressView: UIProgressView!
+    private var closeButton: UIButton!
+    
+    private var url: URL
+    private var completion: (SDKResult) -> Void
+    private var jsBridge: JavaScriptBridge!
+    private var hasInjectedMessageListener = false
+    private var hasProcessedOAuth = false // Track if OAuth was processed in popup
+    private var popupTimeoutTimer: DispatchWorkItem? // Safety timer to close popup
+    
+    // MARK: - Testing Flag
+    /// QA mode (matches Android's WEBVIEW_LOG_ONLY_ON_CALLBACK_DEEPLINK):
+    /// - When true: if the WebView (main/popup) encounters a callback deep link URL
+    ///   (expediter/expeditor or app scheme), we ONLY log it and do NOT process/inject.
+    /// - External deep links delivered to the app via AppDelegate/URL scheme
+    ///   will still be processed normally.
+    static let WEBVIEW_LOG_ONLY_ON_CALLBACK_DEEPLINK: Bool = false
+    
+    // MARK: - Initialization
+    public init(url: URL, completion: @escaping (SDKResult) -> Void) {
+        self.url = url
+        self.completion = completion
+        super.init(nibName: nil, bundle: nil)
+    }
+    
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    // MARK: - Lifecycle
+    public override func viewDidLoad() {
+        super.viewDidLoad()
+        setupUI()
+        setupWebView()
+        loadGrailPaySDK()
+    }
+
+    public override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        WebViewConfig.enableCookies()
+    }
+    
+    // MARK: - Setup
+    private func setupUI() {
+        view.backgroundColor = .systemBackground
+
+        closeButton = UIButton(type: .system)
+        closeButton.setImage(UIImage(systemName: "xmark.circle.fill"), for: .normal)
+        closeButton.tintColor = .systemGray
+        closeButton.addTarget(self, action: #selector(closeButtonTapped), for: .touchUpInside)
+        closeButton.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(closeButton)
+
+        progressView = UIProgressView(progressViewStyle: .bar)
+        progressView.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(progressView)
+        
+        NSLayoutConstraint.activate([
+            closeButton.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 8),
+            closeButton.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
+            closeButton.widthAnchor.constraint(equalToConstant: 32),
+            closeButton.heightAnchor.constraint(equalToConstant: 32),
+            progressView.topAnchor.constraint(equalTo: closeButton.bottomAnchor, constant: 8),
+            progressView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            progressView.trailingAnchor.constraint(equalTo: view.trailingAnchor)
+        ])
+    }
+
+    private func setupWebView() {
+        jsBridge = JavaScriptBridge(webViewController: self)
+        mainWebView = WebViewConfig.createMainWebView(bridge: jsBridge)
+        mainWebView.navigationDelegate = self
+        mainWebView.uiDelegate = self
+        mainWebView.translatesAutoresizingMaskIntoConstraints = false
+
+        view.addSubview(mainWebView)
+
+        NSLayoutConstraint.activate([
+            mainWebView.topAnchor.constraint(equalTo: progressView.bottomAnchor),
+            mainWebView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            mainWebView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            mainWebView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
+        ])
+
+        mainWebView.addObserver(self, forKeyPath: #keyPath(WKWebView.estimatedProgress), options: .new, context: nil)
+    }
+
+    private func loadGrailPaySDK() {
+        var request = URLRequest(url: url)
+        request.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
+        request.setValue("no-cache", forHTTPHeaderField: "Cache-Control")
+        request.setValue("no-cache", forHTTPHeaderField: "Pragma")
+        mainWebView.load(request)
+    }
+
+    // MARK: - Popup Management
+    private func showPopup(with webView: WKWebView) {
+        let container = UIView()
+        container.backgroundColor = UIColor.black.withAlphaComponent(0.3)
+        container.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(container)
+
+        let popupCloseButton = UIButton(type: .system)
+        popupCloseButton.setTitle("Close", for: .normal)
+        popupCloseButton.backgroundColor = .systemGray5
+        popupCloseButton.layer.cornerRadius = 8
+        popupCloseButton.translatesAutoresizingMaskIntoConstraints = false
+        popupCloseButton.addTarget(self, action: #selector(closePopupButtonTapped), for: .touchUpInside)
+        container.addSubview(popupCloseButton)
+
+        webView.translatesAutoresizingMaskIntoConstraints = false
+        container.addSubview(webView)
+
+        NSLayoutConstraint.activate([
+            container.topAnchor.constraint(equalTo: view.topAnchor),
+            container.leadingAnchor.constraint(equalTo: view.leadingAnchor),
+            container.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            container.bottomAnchor.constraint(equalTo: view.bottomAnchor),
+            popupCloseButton.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 16),
+            popupCloseButton.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
+            popupCloseButton.widthAnchor.constraint(equalToConstant: 80),
+            popupCloseButton.heightAnchor.constraint(equalToConstant: 40),
+            webView.topAnchor.constraint(equalTo: popupCloseButton.bottomAnchor, constant: 8),
+            webView.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            webView.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            webView.bottomAnchor.constraint(equalTo: container.bottomAnchor)
+        ])
+
+        popupContainer = container
+        popupWebView = webView
+
+        // Start safety timeout - close popup after 30 seconds max
+        startPopupTimeoutTimer()
+    }
+
+    private func startPopupTimeoutTimer() {
+        popupTimeoutTimer?.cancel()
+        let timer = DispatchWorkItem { [weak self] in
+            guard let self = self, self.popupWebView != nil else { return }
+            self.closePopup()
+        }
+        popupTimeoutTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + 30.0, execute: timer)
+    }
+
+    @objc private func closePopupButtonTapped() {
+        closePopup()
+    }
+
+    func closePopupFromBridge() {
+        closePopup()
+    }
+
+    private func closePopup() {
+        popupTimeoutTimer?.cancel()
+        popupTimeoutTimer = nil
+        popupWebView?.stopLoading()
+        popupWebView?.removeFromSuperview()
+        popupContainer?.removeFromSuperview()
+        popupWebView = nil
+        popupContainer = nil
+        hasProcessedOAuth = false
+    }
+    
+    // MARK: - Actions
+    @objc private func closeButtonTapped() {
+        closeWebView()
+    }
+
+    func closeWebView() {
+        // Clear reference in helper
+        GrailPayHelper.clearWebViewController()
+        
+        // Just dismiss silently - don't call completion handler
+        dismiss(animated: true)
+    }
+
+    func showAlert(title: String, message: String, onDismiss: (() -> Void)? = nil) {
+        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "OK", style: .default) { _ in
+            onDismiss?()
+        })
+        present(alert, animated: true)
+    }
+
+    func forwardOAuthDataToMainWebView(_ oauthData: [String: String]) {
+        hasProcessedOAuth = true
+        mainWebView.injectOAuthData(oauthData)
+        closePopup()
+    }
+
+    // MARK: - Completion Handler
+    func handleCompletion(result: SDKResult) {
+        GrailPayHelper.clearWebViewController()
+        completion(result)
+        dismiss(animated: true)
+    }
+
+    // MARK: - Progress Observer
+    override public func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
+        if keyPath == "estimatedProgress" {
+            progressView.progress = Float(mainWebView.estimatedProgress)
+            progressView.isHidden = mainWebView.estimatedProgress >= 1.0
+        }
+    }
+
+    deinit {
+        mainWebView?.removeObserver(self, forKeyPath: #keyPath(WKWebView.estimatedProgress))
+    }
+}
+
+// MARK: - WKNavigationDelegate
+extension GrailPayWebViewController: WKNavigationDelegate {
+    public func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        if webView == mainWebView && !hasInjectedMessageListener {
+            mainWebView.injectMessageListener()
+            hasInjectedMessageListener = true
+            injectConsoleLogging()
+        }
+        if webView == popupWebView {
+            handlePopupPageLoad(webView)
+        }
+    }
+
+    private func injectConsoleLogging() {
+        let script = """
+        (function() {
+            const originalError = console.error;
+            console.error = function(...args) {
+                originalError.apply(console, args);
+                try {
+                    var msg = args.map(a => typeof a === 'object' ? JSON.stringify(a) : String(a)).join(' ');
+                    if (window.webkit?.messageHandlers?.androidBridge) {
+                        window.webkit.messageHandlers.androidBridge.postMessage({ type: 'consoleLog', level: 'error', message: msg });
+                    }
+                } catch(e) {}
+            };
+            window.addEventListener('error', function(e) { console.error('Error:', e.message); });
+            window.addEventListener('unhandledrejection', function(e) { console.error('Rejection:', e.reason); });
+        })();
+        """
+        mainWebView.injectJavaScript(script)
+    }
+
+    private func handlePopupPageLoad(_ webView: WKWebView) {
+        let urlString = webView.url?.absoluteString ?? ""
+        if urlString == "about:blank" || urlString.isEmpty {
+            closePopup()
+            return
+        }
+        if hasProcessedOAuth {
+            closePopup()
+            return
+        }
+        if urlString.contains("auth/callback") || urlString.contains("oauth/capture") ||
+           urlString.contains("oauth-callback") || urlString.contains("callback?") {
+            hasProcessedOAuth = true
+            if let url = webView.url,
+               let components = URLComponents(url: url, resolvingAgainstBaseURL: false) {
+                var oauthData: [String: String] = [:]
+                components.queryItems?.forEach { item in
+                    if let value = item.value { oauthData[item.name] = value }
+                }
+                oauthData["url"] = urlString
+                mainWebView.injectOAuthData(oauthData)
+                closePopup()
+            }
+            return
+        }
+        if urlString.contains("connect.moneykit.com/continue") {
+            hasProcessedOAuth = true
+            closePopup()
+            return
+        }
+        if urlString.contains("/success") || urlString.contains("/complete") ||
+           urlString.contains("/done") || urlString.contains("/finish") {
+            closePopup()
+        }
+    }
+    
+    public func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
+        if webView == popupWebView { closePopup() }
+    }
+
+    public func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
+        let nsError = error as NSError
+        if nsError.domain == "WebKitErrorDomain" && nsError.code == 102 { return }
+        if webView == popupWebView { closePopup() }
+    }
+    
+    public func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+        guard let url = navigationAction.request.url else {
+            decisionHandler(.allow)
+            return
+        }
+        let urlString = url.absoluteString
+        let scheme = url.scheme?.lowercased() ?? ""
+
+        if urlString.lowercased().hasPrefix("grailpay://") || scheme == "grailpay" {
+            guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+                  let dataParam = components.queryItems?.first(where: { $0.name == "data" })?.value,
+                  let urlDecoded = dataParam.removingPercentEncoding,
+                  let decodedData = Data(base64Encoded: urlDecoded),
+                  let decodedString = String(data: decodedData, encoding: .utf8),
+                  let jsonData = decodedString.data(using: .utf8),
+                  let json = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any],
+                  let eventType = json["eventType"] as? String,
+                  let data = json["data"] else {
+                decisionHandler(.cancel)
+                return
+            }
+            let result: SDKResult
+            switch eventType {
+            case "defaultAccountSelected", "linkedDefaultAccount":
+                result = SDKResult(type: .success, data: ["data": [data]] as NSDictionary)
+            case "linkExit":
+                if let exitData = data as? [String: Any], let status = exitData["status"] as? String, status == "SUCCESS" {
+                    result = SDKResult(type: .success, data: ["data": [data]] as NSDictionary)
+                } else {
+                    result = SDKResult(type: .cancelled, data: ["data": data] as NSDictionary)
+                }
+            case "error":
+                result = SDKResult(type: .error, data: ["status": false, "message": "GrailPay error: \(data)"] as NSDictionary)
+            default:
+                result = SDKResult(type: .error, data: ["status": false, "message": "Unknown event type: \(eventType)"] as NSDictionary)
+            }
+            handleCompletion(result: result)
+            decisionHandler(.cancel)
+            return
+        }
+
+        if scheme == "expediter" || scheme == "expeditor" {
+            if Self.WEBVIEW_LOG_ONLY_ON_CALLBACK_DEEPLINK {
+                decisionHandler(.cancel)
+                return
+            }
+            hasProcessedOAuth = true
+            var oauthData: [String: String] = [:]
+            URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems?.forEach { item in
+                if let value = item.value { oauthData[item.name] = value }
+            }
+            oauthData["url"] = urlString
+            mainWebView.injectOAuthData(oauthData)
+            closePopup()
+            decisionHandler(.cancel)
+            return
+        }
+            
+        if let sch = url.scheme, ["intent", "bankapp", "plaid"].contains(sch) {
+            if UIApplication.shared.canOpenURL(url) {
+                UIApplication.shared.open(url)
+            }
+            decisionHandler(.cancel)
+            return
+        }
+
+        if scheme != "http" && scheme != "https" && scheme != "about" && scheme != "data" {
+            decisionHandler(.cancel)
+            return
+        }
+        decisionHandler(.allow)
+    }
+}
+
+// MARK: - WKUIDelegate
+extension GrailPayWebViewController: WKUIDelegate {
+    public func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
+        guard navigationAction.request.url != nil else { return nil }
+        let popup = WebViewConfig.createPopupWebView(with: configuration)
+        popup.navigationDelegate = self
+        popup.uiDelegate = self
+        showPopup(with: popup)
+        let script = """
+        (function() {
+            var originalClose = window.close;
+            window.close = function() {
+                try { window.webkit.messageHandlers.androidBridge.postMessage({ type: 'closePopup' }); } catch (e) {}
+                try { originalClose.call(window); } catch (e) {}
+            };
+        })();
+        """
+        popup.evaluateJavaScript(script, completionHandler: nil)
+        return popup
+    }
+    
+    public func webViewDidClose(_ webView: WKWebView) {
+        if webView == popupWebView { closePopup() }
+    }
+    
+    public func webView(_ webView: WKWebView, runJavaScriptAlertPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping () -> Void) {
+        completionHandler()
+    }
+    
+    public func webView(_ webView: WKWebView, runJavaScriptConfirmPanelWithMessage message: String, initiatedByFrame frame: WKFrameInfo, completionHandler: @escaping (Bool) -> Void) {
+        let alert = UIAlertController(title: nil, message: message, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel) { _ in completionHandler(false) })
+        alert.addAction(UIAlertAction(title: "OK", style: .default) { _ in completionHandler(true) })
+        present(alert, animated: true)
+    }
+}