catalyst-core 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/native/iosnativeWebView/Sources/Core/WebView/NativeBridge.swift

@@ -17,11 +17,17 @@ class NativeBridge: NSObject, BridgeCommandHandlerDelegate, BridgeFileHandlerDel
     weak var webView: WKWebView?
     private weak var viewController: UIViewController?
     private weak var webViewModel: WebViewModel?
+    private var cameraManager: NativeCameraManager?
+    private var messageHandlerProxy: WeakScriptMessageHandler?
+    private var isRegistered = false
 
     // Protocol-based notification handler (injected at runtime)
     private var notificationHandler: NotificationHandlerProtocol = NullNotificationHandler.shared
     private var networkStatusListenerId: UUID?
 
+    // Transition manager — snapshot overlay pattern for native page transitions
+    private var transitionManager: TransitionManager?
+
     // Lazy initialization for non-critical handlers
     private lazy var imageHandler: ImageHandler = {
         logWithTimestamp("🔧 ImageHandler initialized (lazy)")
@@ -68,17 +74,38 @@ class NativeBridge: NSObject, BridgeCommandHandlerDelegate, BridgeFileHandlerDel
         return handler
     }()
 
-    init(webView: WKWebView, viewController: UIViewController) {
+    init(webView: WKWebView, viewController: UIViewController, cameraManager: NativeCameraManager? = nil) {
         let initStart = CFAbsoluteTimeGetCurrent()
 
         self.webView = webView
         self.viewController = viewController
+        self.cameraManager = cameraManager
 
         // Only initialize critical JS interface immediately
         self.jsInterface = BridgeJavaScriptInterface(webView: webView)
 
         super.init()
 
+        // Wire camera events back through the bridge
+        cameraManager?.rewireEvents { [weak self] eventName, payload in
+            if let payload {
+                self?.sendJSONCallback(eventName: eventName, data: payload)
+            } else {
+                self?.sendCallback(eventName: eventName)
+            }
+        }
+        cameraManager?.rewireError { [weak self] message in
+            self?.sendErrorCallback(eventName: "ON_CAMERA_ERROR", error: message, code: "CAMERA_ERROR")
+        }
+
+        // Wire transition manager
+        let tm = TransitionManager(webView: webView)
+        tm.onEvent = { [weak self] eventName in
+            self?.sendCallback(eventName: eventName)
+        }
+        self.transitionManager = tm
+
+
         setupNotificationNavigationHandler()
 
         let initTime = (CFAbsoluteTimeGetCurrent() - initStart) * 1000
@@ -133,10 +160,16 @@ class NativeBridge: NSObject, BridgeCommandHandlerDelegate, BridgeFileHandlerDel
 
     // Register the JavaScript interface with the WebView
     func register() {
+        guard !isRegistered else { return }
         let registerStart = CFAbsoluteTimeGetCurrent()
 
-        let userContentController = webView?.configuration.userContentController
-        userContentController?.add(self, name: "NativeBridge")
+        guard let userContentController = webView?.configuration.userContentController else {
+            return
+        }
+        let proxy = WeakScriptMessageHandler(delegate: self)
+        userContentController.add(proxy, name: "NativeBridge")
+        messageHandlerProxy = proxy
+        isRegistered = true
 
         let registerTime = (CFAbsoluteTimeGetCurrent() - registerStart) * 1000
         logWithTimestamp("✅ NativeBridge registered (took \(String(format: "%.2f", registerTime))ms)")
@@ -144,12 +177,19 @@ class NativeBridge: NSObject, BridgeCommandHandlerDelegate, BridgeFileHandlerDel
     
     // Unregister to prevent memory leaks
     func unregister() {
+        guard isRegistered else { return }
         webView?.configuration.userContentController.removeScriptMessageHandler(forName: "NativeBridge")
-        
+        messageHandlerProxy = nil
+        isRegistered = false
+
+
         if let listenerId = networkStatusListenerId {
             NetworkMonitor.shared.removeListener(listenerId)
             networkStatusListenerId = nil
         }
+
+        transitionManager?.cleanup()
+        transitionManager = nil
     }
 
     private func startNetworkMonitoringIfNeeded() {
@@ -282,6 +322,25 @@ extension NativeBridge: WKScriptMessageHandler {
             commandHandler.unsubscribeFromTopic(config)
         case "getSubscribedTopics":
             commandHandler.getSubscribedTopics()
+        // Video stream commands
+        case "startVideoStream":
+            handleStartVideoStream(params: params)
+        case "stopVideoStream":
+            logger.info("📹 stopVideoStream received")
+            if cameraManager == nil { logger.error("📹 stopVideoStream — cameraManager is nil") }
+            cameraManager?.stop()
+        case "flipVideoStream":
+            logger.info("📹 flipVideoStream received")
+            if cameraManager == nil { logger.error("📹 flipVideoStream — cameraManager is nil") }
+            cameraManager?.flip()
+        case "sendVideoStreamCommand":
+            handleVideoStreamCommand(params: params)
+        case "setVideoStreamZoom":
+            handleSetVideoStreamZoom(params: params)
+        case "setVideoStreamTorch":
+            handleSetVideoStreamTorch(params: params)
+        case "setVideoStreamFps":
+            handleSetVideoStreamFps(params: params)
         case "getSafeArea":
             getSafeArea()
         case "setScreenSecure":
@@ -290,12 +349,176 @@ extension NativeBridge: WKScriptMessageHandler {
             commandHandler.getScreenSecure()
         case "clearWebData":
             commandHandler.clearWebData()
+
+        // Transition commands
+        case "startTransition":
+            let optionsString = delegateHandler.extractStringParam(from: params)
+            handleStartTransition(optionsString: optionsString)
+        case "commitTransition":
+            DispatchQueue.main.async { [weak self] in self?.transitionManager?.commitTransition() }
+        case "cancelTransition":
+            DispatchQueue.main.async { [weak self] in self?.transitionManager?.cancelTransition() }
+
         default:
             // This should never happen due to validation, but keeping for safety
             logger.error("Unexpected command reached execution: \(command)")
         }
     }
 
+    // MARK: - Video Stream Helpers
+
+    /// JS always sends params as JSON.stringify(options) — a String — because Android requires it.
+    /// Parse it into a dictionary here rather than removing the stringify on the JS side.
+    private func jsonStringToDict(_ params: Any?) -> [String: Any]? {
+        // Fast path: WKWebView decoded it already (unlikely for video stream commands but handle gracefully)
+        if let d = params as? [String: Any] { return d }
+        if let d = (params as? NSDictionary) as? [String: Any] { return d }
+        // Normal path: params is a JSON string from JSON.stringify()
+        guard let str = params as? String,
+              let data = str.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data),
+              let dict = obj as? [String: Any] else { return nil }
+        return dict
+    }
+
+    private func handleStartVideoStream(params: Any?) {
+        logger.info("📹 startVideoStream received — raw params type: \(type(of: params))")
+        guard let cam = cameraManager else {
+            logger.error("📹 startVideoStream — cameraManager is nil")
+            return
+        }
+        var facing = "back"
+        var autoZoom = false
+        var initialZoom: Float = 1.0
+        var scanFormat = "all"
+        var fpsMin: Int? = nil
+        var fpsMax: Int? = nil
+
+        if let dict = jsonStringToDict(params) {
+            logger.info("📹 startVideoStream — dict keys: \(dict.keys.sorted().joined(separator: ", "))")
+            facing     = dict["facing"]   as? String ?? facing
+            autoZoom   = dict["autoZoom"] as? Bool   ?? autoZoom
+            scanFormat = dict["format"]   as? String ?? scanFormat
+            // zoom options are nested under 'zoom' key: { auto: Bool, initial: Float }
+            if let zoomDict = dict["zoom"] as? [String: Any] {
+                autoZoom    = (zoomDict["auto"]    as? NSNumber)?.boolValue  ?? autoZoom
+                initialZoom = (zoomDict["initial"] as? NSNumber)?.floatValue ?? initialZoom
+            }
+            if let fps = dict["fps"] as? [String: Any] {
+                fpsMin = fps["min"] as? Int
+                fpsMax = fps["max"] as? Int
+            }
+        } else {
+            logger.warning("📹 startVideoStream — could not parse params (type=\(type(of: params))), using defaults")
+        }
+
+        logger.info("📹 startVideoStream — starting with facing=\(facing) autoZoom=\(autoZoom) initialZoom=\(initialZoom) format=\(scanFormat) fpsMin=\(String(describing: fpsMin)) fpsMax=\(String(describing: fpsMax))")
+        cam.start(facing: facing, autoZoom: autoZoom, initialZoom: initialZoom,
+                  scanFormat: scanFormat, fpsMin: fpsMin, fpsMax: fpsMax)
+    }
+
+    private func handleVideoStreamCommand(params: Any?) {
+        guard let cam = cameraManager,
+              let dict = jsonStringToDict(params),
+              let type = dict["type"] as? String else {
+            logger.error("📹 handleVideoStreamCommand — guard failed: cameraManager=\(self.cameraManager != nil) params=\(String(describing: params))")
+            return
+        }
+
+        switch type {
+        case "zoom":
+            if let value = dict["value"] as? NSNumber {
+                cam.setZoom(multiplier: value.floatValue)
+            }
+        case "torch":
+            if let value = dict["value"] as? Bool {
+                cam.setTorch(value)
+            }
+        case "fps":
+            let fpsDict = dict["value"] as? [String: Any]
+            let min = fpsDict?["min"] as? Int
+            let max = fpsDict?["max"] as? Int
+            cam.setFps(min: min, max: max)
+        default:
+            logger.warning("Unknown videoStream command type: \(type)")
+        }
+    }
+
+    private func handleSetVideoStreamZoom(params: Any?) {
+        logger.info("📹 setVideoStreamZoom received — raw params: \(String(describing: params))")
+        guard let cam = cameraManager else {
+            logger.error("📹 setVideoStreamZoom — cameraManager is nil")
+            return
+        }
+        guard let raw = params as? String, let multiplier = Float(raw) else {
+            logger.error("📹 setVideoStreamZoom — expected String number, got: \(String(describing: params))")
+            return
+        }
+        logger.info("📹 setVideoStreamZoom — multiplier=\(multiplier)x")
+        cam.setZoom(multiplier: multiplier)
+    }
+
+    private func handleSetVideoStreamTorch(params: Any?) {
+        logger.info("📹 setVideoStreamTorch received — raw params: \(String(describing: params))")
+        guard let cam = cameraManager else {
+            logger.error("📹 setVideoStreamTorch — cameraManager is nil")
+            return
+        }
+        // JS sends JSON.stringify({on: bool})
+        guard let dict = jsonStringToDict(params), let on = dict["on"] as? Bool else {
+            logger.error("📹 setVideoStreamTorch — expected JSON string {on: Bool}, got: \(String(describing: params))")
+            return
+        }
+        logger.info("📹 setVideoStreamTorch — on=\(on)")
+        cam.setTorch(on)
+    }
+
+    private func handleSetVideoStreamFps(params: Any?) {
+        logger.info("📹 setVideoStreamFps received — raw params: \(String(describing: params))")
+        guard let cam = cameraManager else {
+            logger.error("📹 setVideoStreamFps — cameraManager is nil")
+            return
+        }
+        // JS sends JSON.stringify({min, max})
+        guard let dict = jsonStringToDict(params) else {
+            logger.error("📹 setVideoStreamFps — expected JSON string {min, max}, got: \(String(describing: params))")
+            return
+        }
+        let min = dict["min"] as? Int
+        let max = dict["max"] as? Int
+        logger.info("📹 setVideoStreamFps — min=\(String(describing: min)) max=\(String(describing: max))")
+        cam.setFps(min: min, max: max)
+    }
+
+    // MARK: - Transition Helpers
+
+    private func handleStartTransition(optionsString: String?) {
+        let options: [String: Any]
+        if let str = optionsString,
+           let data = str.data(using: .utf8),
+           let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+            options = obj
+        } else {
+            options = [:]
+        }
+
+        let type      = options["type"]      as? String ?? "slide"
+        let direction = options["direction"] as? String ?? "left"
+        let duration  = min(max((options["duration"] as? Int ?? 300), 0), 2000)
+        let defaultTimeout = max(duration * 3, 800)
+        let timeout   = min(max((options["timeout"] as? Int ?? defaultTimeout), 100), 10000)
+
+        DispatchQueue.main.async { [weak self] in
+            self?.transitionManager?.startTransition(
+                type: type,
+                direction: direction,
+                duration: duration,
+                timeout: timeout
+            )
+        }
+    }
+
+
     // MARK: - Safe Area Methods
 
     /// Get current safe area insets and send via callback

package/dist/native/iosnativeWebView/Sources/Core/WebView/TransitionManager.swift

@@ -0,0 +1,169 @@
+import UIKit
+import WebKit
+import os
+
+private let transitionLogger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "TransitionManager")
+
+/// Manages native page transitions using a snapshot-overlay pattern.
+///
+/// Flow:
+///   startTransition()  — captures a snapshotView of the current WebView, places it as an
+///                        overlay on the key window covering the skeleton rendered by the router.
+///   commitTransition() — animates the overlay out (slide or fade) to reveal the new page.
+///   cancelTransition() — removes the overlay immediately without animating.
+///
+/// Safety timer: a DispatchWorkItem fires after `timeout` ms if commitTransition() was
+///   never called. It force-removes the overlay and fires ON_TRANSITION_TIMEOUT to JS.
+///
+/// Thread safety: all public methods must be called on the main thread.
+class TransitionManager {
+
+    private weak var webView: WKWebView?
+    private var overlayView: UIView?
+    private var safetyItem: DispatchWorkItem?
+    private var activeDuration: TimeInterval = 0.3
+    private var activeType: String = "slide"
+    private var activeDirection: String = "left"
+
+    // Callback to fire JS events — injected by NativeBridge
+    var onEvent: (String) -> Void = { _ in }
+
+    init(webView: WKWebView) {
+        self.webView = webView
+    }
+
+    // MARK: - Public API
+
+    func startTransition(type: String, direction: String, duration: Int, timeout: Int) {
+        // Cancel any orphaned transition first
+        cancelTransitionInternal(notify: false)
+
+        activeType = type
+        activeDirection = direction
+        activeDuration = Double(duration) / 1000.0
+
+        guard let snapshot = captureSnapshot() else {
+            transitionLogger.warning("startTransition — snapshot failed, transition skipped")
+            return
+        }
+
+        guard let window = webView?.window ?? UIApplication.shared.connectedScenes
+            .compactMap({ ($0 as? UIWindowScene)?.keyWindow })
+            .first else {
+            transitionLogger.warning("startTransition — no key window found")
+            return
+        }
+
+        snapshot.frame = window.bounds
+        snapshot.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        window.addSubview(snapshot)
+        overlayView = snapshot
+
+        transitionLogger.debug("startTransition — overlay attached (type=\(type) direction=\(direction) duration=\(duration)ms timeout=\(timeout)ms)")
+
+        // Arm safety timer
+        let item = DispatchWorkItem { [weak self] in
+            transitionLogger.warning("startTransition — safety timeout fired, force-removing overlay")
+            self?.cancelTransitionInternal(notify: false)
+            self?.onEvent("ON_TRANSITION_TIMEOUT")
+        }
+        safetyItem = item
+        DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(timeout), execute: item)
+    }
+
+    func commitTransition() {
+        guard let overlay = overlayView else {
+            transitionLogger.warning("commitTransition — no active overlay, ignoring")
+            return
+        }
+
+        disarmSafetyTimer()
+
+        switch activeType {
+        case "fade":
+            animateFadeOut(overlay: overlay, duration: activeDuration)
+        default:
+            animateSlideOut(overlay: overlay, duration: activeDuration, direction: activeDirection)
+        }
+    }
+
+    func cancelTransition() {
+        cancelTransitionInternal(notify: true)
+    }
+
+    func cleanup() {
+        cancelTransitionInternal(notify: false)
+    }
+
+    // MARK: - Private helpers
+
+    private func captureSnapshot() -> UIView? {
+        guard let webView else { return nil }
+        // snapshotView is GPU-backed and fast — no bitmap copy needed on iOS
+        return webView.snapshotView(afterScreenUpdates: false)
+    }
+
+    private func animateSlideOut(overlay: UIView, duration: TimeInterval, direction: String) {
+        guard let window = overlay.superview else { return }
+        let w = window.bounds.width
+        let h = window.bounds.height
+
+        let endTranslation: CGPoint
+        switch direction {
+        case "right": endTranslation = CGPoint(x: -w, y: 0)
+        case "up":    endTranslation = CGPoint(x: 0,  y: h)
+        case "down":  endTranslation = CGPoint(x: 0,  y: -h)
+        default:      endTranslation = CGPoint(x: w,  y: 0)  // "left" — overlay slides out to the right
+        }
+
+        UIView.animate(
+            withDuration: duration,
+            delay: 0,
+            options: [.curveEaseInOut],
+            animations: {
+                overlay.transform = CGAffineTransform(translationX: endTranslation.x, y: endTranslation.y)
+            },
+            completion: { [weak self] _ in
+                self?.removeOverlay(overlay)
+                self?.onEvent("ON_TRANSITION_COMMITTED")
+            }
+        )
+    }
+
+    private func animateFadeOut(overlay: UIView, duration: TimeInterval) {
+        UIView.animate(
+            withDuration: duration,
+            delay: 0,
+            options: [.curveEaseInOut],
+            animations: {
+                overlay.alpha = 0
+            },
+            completion: { [weak self] _ in
+                self?.removeOverlay(overlay)
+                self?.onEvent("ON_TRANSITION_COMMITTED")
+            }
+        )
+    }
+
+    private func cancelTransitionInternal(notify: Bool) {
+        disarmSafetyTimer()
+        if let overlay = overlayView {
+            removeOverlay(overlay)
+            if notify {
+                onEvent("ON_TRANSITION_CANCELLED")
+            }
+        }
+    }
+
+    private func removeOverlay(_ overlay: UIView) {
+        overlay.removeFromSuperview()
+        if overlayView === overlay {
+            overlayView = nil
+        }
+    }
+
+    private func disarmSafetyTimer() {
+        safetyItem?.cancel()
+        safetyItem = nil
+    }
+}

package/dist/native/iosnativeWebView/Sources/Core/WebView/WeakScriptMessageHandler.swift

@@ -0,0 +1,14 @@
+import WebKit
+
+final class WeakScriptMessageHandler: NSObject, WKScriptMessageHandler {
+    weak var delegate: WKScriptMessageHandler?
+
+    init(delegate: WKScriptMessageHandler) {
+        self.delegate = delegate
+        super.init()
+    }
+
+    func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) {
+        delegate?.userContentController(userContentController, didReceive: message)
+    }
+}

package/dist/native/iosnativeWebView/Sources/Core/WebView/WebView.swift

@@ -7,6 +7,7 @@ private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app"
 public struct WebView: UIViewRepresentable, Equatable {
     let urlString: String
     @ObservedObject var viewModel: WebViewModel
+    let cameraManager: NativeCameraManager
     private let navigationDelegate: WebViewNavigationDelegate
 
     // Equatable conformance - only recreate if URL changes
@@ -14,12 +15,13 @@ public struct WebView: UIViewRepresentable, Equatable {
         return lhs.urlString == rhs.urlString
     }
 
-    public init(urlString: String, viewModel: WebViewModel) {
+    public init(urlString: String, viewModel: WebViewModel, cameraManager: NativeCameraManager) {
         let start = CFAbsoluteTimeGetCurrent()
         self.urlString = urlString
         self.viewModel = viewModel
+        self.cameraManager = cameraManager
         let initialURL = URL(string: urlString)
-        self.navigationDelegate = WebViewNavigationDelegate(viewModel: viewModel, initialURL: initialURL)
+        self.navigationDelegate = WebViewNavigationDelegate(viewModel: viewModel, initialURL: initialURL, cameraManager: cameraManager)
 
         // Register our custom URL protocol for caching
         let protocolStart = CFAbsoluteTimeGetCurrent()
@@ -40,9 +42,6 @@ public struct WebView: UIViewRepresentable, Equatable {
         // Hook kept for legacy behavior; currently a no-op on iOS 15+.
         WebKitConfig.applySharedProcessPoolIfNeeded(to: configuration)
 
-        #if DEBUG
-        configuration.preferences.setValue(true, forKey: "developerExtrasEnabled")
-        #endif
         let preferences = WKWebpagePreferences()
         preferences.allowsContentJavaScript = true
         configuration.defaultWebpagePreferences = preferences
@@ -54,6 +53,15 @@ public struct WebView: UIViewRepresentable, Equatable {
 
         webView.navigationDelegate = navigationDelegate
         webView.allowsBackForwardNavigationGestures = true
+        webView.isOpaque = false
+        webView.backgroundColor = .clear
+        webView.scrollView.backgroundColor = .clear
+
+        // Add our pinch recognizer to route camera zoom when streaming.
+        // Web page zoom is disabled via user-scalable=no in the viewport meta tag.
+        let pinchGesture = UIPinchGestureRecognizer(target: context.coordinator,
+                                                    action: #selector(Coordinator.handleCameraPinch(_:)))
+        webView.addGestureRecognizer(pinchGesture)
 
         #if DEBUG
         // Enable Safari Web Inspector (only available in iOS 16.4+)
@@ -101,7 +109,11 @@ public struct WebView: UIViewRepresentable, Equatable {
     }
     
     public func updateUIView(_ webView: WKWebView, context: Context) {
-        // Intentionally empty to prevent reloading
+        #if DEBUG
+        if #available(iOS 16.4, *) {
+            webView.isInspectable = true
+        }
+        #endif
     }
     
     public func makeCoordinator() -> Coordinator {
@@ -121,6 +133,8 @@ public struct WebView: UIViewRepresentable, Equatable {
         // Clean up native bridge
         coordinator.nativeBridge?.unregister()
         coordinator.nativeBridge = nil
+        coordinator.pluginBridge?.unregister()
+        coordinator.pluginBridge = nil
         coordinator.hostingController = nil
 
         // Unregister custom URL protocol
@@ -132,6 +146,7 @@ public struct WebView: UIViewRepresentable, Equatable {
     public class Coordinator: NSObject {
         var parent: WebView
         var nativeBridge: NativeBridge?
+        var pluginBridge: PluginBridge?
         var hostingController: UIViewController?
         var isObserverAdded = false
 
@@ -145,7 +160,8 @@ public struct WebView: UIViewRepresentable, Equatable {
             self.hostingController = hostingController
 
             // Create and register the native bridge
-            let bridge = NativeBridge(webView: webView, viewController: hostingController)
+            let bridge = NativeBridge(webView: webView, viewController: hostingController, cameraManager: parent.cameraManager)
+            let pluginBridge = PluginBridge(webView: webView, viewController: hostingController)
 
             // Inject WebViewModel for safe area handling
             Task { @MainActor in
@@ -156,9 +172,24 @@ public struct WebView: UIViewRepresentable, Equatable {
             bridge.setNotificationHandler(NotificationHandlerProvider.shared)
 
             bridge.register()
+            pluginBridge.register()
             self.nativeBridge = bridge
+            self.pluginBridge = pluginBridge
         }
         
+        @objc func handleCameraPinch(_ gesture: UIPinchGestureRecognizer) {
+            // No-op when camera is not streaming — don't accidentally zoom the page
+            guard parent.cameraManager.isStreaming else { return }
+            switch gesture.state {
+            case .began:
+                parent.cameraManager.handlePinchBegan()
+            case .changed:
+                parent.cameraManager.handlePinchChanged(scale: gesture.scale)
+            default:
+                break
+            }
+        }
+
         override public func observeValue(forKeyPath keyPath: String?,
                                  of object: Any?,
                                  change: [NSKeyValueChangeKey : Any]?,

package/dist/native/iosnativeWebView/Sources/Core/WebView/WebViewNavigationDelegate.swift

@@ -11,11 +11,13 @@ class WebViewNavigationDelegate: NSObject, WKNavigationDelegate {
     private var offlinePageVisible = false
     private var lastTargetURL: URL?
     private let initialURL: URL?
-    
-    init(viewModel: WebViewModel, initialURL: URL?) {
+    private weak var cameraManager: NativeCameraManager?
+
+    init(viewModel: WebViewModel, initialURL: URL?, cameraManager: NativeCameraManager? = nil) {
         self.viewModel = viewModel
         self.initialURL = initialURL
         self.lastTargetURL = initialURL
+        self.cameraManager = cameraManager
         super.init()
     }
     
@@ -199,6 +201,8 @@ class WebViewNavigationDelegate: NSObject, WKNavigationDelegate {
     
     func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
         logWithTimestamp("📡 didStartProvisionalNavigation - loading started")
+        // Stop camera on navigation — mirrors Android CustomWebview onPageStarted lambda
+        cameraManager?.stop()
         Task { @MainActor in
             if !isOfflinePageURL(webView.url) {
                 offlinePageVisible = false

package/dist/native/iosnativeWebView/iosnativeWebView/ContentView.swift

@@ -7,21 +7,31 @@ private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app"
 
 public struct ContentView: View {
     @StateObject private var webViewModel = WebViewModel()
-    
+    // @StateObject ensures cameraManager survives SwiftUI view rebuilds.
+    @StateObject private var cameraManager = NativeCameraManager(
+        onEvent: { _, _ in },   // placeholder; real handler set in NativeBridge
+        onError: { _ in }
+    )
+
     public init() {}
 
     public var body: some View {
         ZStack {
+            // Camera preview layer — sits behind the WebView (index 0)
+            CameraPreviewView(cameraManager: cameraManager)
+                .ignoresSafeArea()
+                .allowsHitTesting(false)   // touches pass through to WebView
+
             // Normal remote URL - isolated from state changes
             // Conditionally apply edge-to-edge based on config (matches Android behavior)
             if ConfigConstants.EdgeToEdge.enabled {
-                WebViewContainer(urlString: ConfigConstants.url, viewModel: webViewModel)
+                WebViewContainer(urlString: ConfigConstants.url, viewModel: webViewModel, cameraManager: cameraManager)
                     .ignoresSafeArea()
                     .onAppear {
                         logger.info("WebView appeared with URL: \(ConfigConstants.url) [Edge-to-edge: enabled]")
                     }
             } else {
-                WebViewContainer(urlString: ConfigConstants.url, viewModel: webViewModel)
+                WebViewContainer(urlString: ConfigConstants.url, viewModel: webViewModel, cameraManager: cameraManager)
                     .onAppear {
                         logger.info("WebView appeared with URL: \(ConfigConstants.url) [Edge-to-edge: disabled, respecting safe areas]")
                     }
@@ -62,9 +72,10 @@ public struct ContentView: View {
 struct WebViewContainer: View {
     let urlString: String
     @ObservedObject var viewModel: WebViewModel
+    let cameraManager: NativeCameraManager
 
     var body: some View {
-        WebView(urlString: urlString, viewModel: viewModel)
+        WebView(urlString: urlString, viewModel: viewModel, cameraManager: cameraManager)
             .onAppear {
                 logWithTimestamp("🌐 WebView appeared with URL: \(urlString)")
             }