@tamer4lynx/tamer-dev-client 0.0.1

package/ios/tamerdevclient/tamerdevclient/Classes/TamerRelogLogService.swift

@@ -0,0 +1,198 @@
+import Foundation
+import Lynx
+
+private let maxQueue = 100
+private let reconnectDelay: TimeInterval = 3.0
+
+@objcMembers
+public final class TamerRelogLogService: NSObject {
+    public static let shared = TamerRelogLogService()
+
+    private var webSocketTask: URLSessionWebSocketTask?
+    private var urlSession: URLSession?
+    private let queue = DispatchQueue(label: "com.tamerdevclient.relog", qos: .utility)
+    private var pendingQueue: [String] = []
+    private let queueLock = NSLock()
+    private var shouldReconnect = false
+    private var isConnecting = false
+    private var loggingDelegateId: NSInteger = -1
+
+    private let sessionDelegate = RelogURLSessionDelegate()
+
+    public static func connect() {
+        shared.connect()
+    }
+
+    public static func disconnect() {
+        shared.disconnect()
+    }
+
+    public static func forwardLog(level: UInt32, tag: String, message: String) {
+        shared.forwardLog(level: level, tag: tag, message: message)
+    }
+
+    public func connect() {
+        shouldReconnect = true
+        registerLoggingDelegate()
+        guard !isConnecting, webSocketTask == nil else { return }
+        guard let devUrl = DevServerPrefs.getUrl(), !devUrl.isEmpty else { return }
+        guard let wsURL = buildWsURL(devUrl: devUrl) else { return }
+        isConnecting = true
+        let config = URLSessionConfiguration.default
+        config.timeoutIntervalForRequest = 5
+        let session = URLSession(configuration: config, delegate: sessionDelegate, delegateQueue: nil)
+        urlSession = session
+        sessionDelegate.onOpen = { [weak self] in
+            self?.isConnecting = false
+            self?.sendConnected()
+            self?.flushPending()
+        }
+        sessionDelegate.onClose = { [weak self] in
+            self?.webSocketTask = nil
+            self?.isConnecting = false
+            self?.scheduleReconnect()
+        }
+        sessionDelegate.onFailure = { [weak self] _ in
+            self?.webSocketTask = nil
+            self?.isConnecting = false
+            self?.scheduleReconnect()
+        }
+        webSocketTask = session.webSocketTask(with: wsURL)
+        webSocketTask?.resume()
+    }
+
+    public func disconnect() {
+        shouldReconnect = false
+        unregisterLoggingDelegate()
+        webSocketTask?.cancel(with: .goingAway, reason: nil)
+        webSocketTask = nil
+        urlSession?.invalidateAndCancel()
+        urlSession = nil
+        queueLock.lock()
+        pendingQueue.removeAll()
+        queueLock.unlock()
+        isConnecting = false
+    }
+
+    private func registerLoggingDelegate() {
+        guard loggingDelegateId < 0 else { return }
+        SetJSLogsFromExternalChannels(true)
+        guard let delegate = LynxLogDelegate(
+            logFunction: { [weak self] level, message in
+                guard let self = self, let msg = message else { return }
+                self.forwardLog(level: UInt32(level.rawValue), tag: "lynx-console", message: msg)
+            },
+            minLogLevel: .verbose
+        ) else { return }
+        delegate.acceptSource = LynxLogSource(rawValue: 1 << 1)
+        loggingDelegateId = AddLoggingDelegate(delegate)
+    }
+
+    private func unregisterLoggingDelegate() {
+        guard loggingDelegateId >= 0 else { return }
+        RemoveLoggingDelegate(loggingDelegateId)
+        loggingDelegateId = -1
+    }
+
+    func forwardLog(level: UInt32, tag: String, message: String) {
+        let (forwardTag, forwardMsg) = parseConsoleMessage(tag: tag, message: message)
+        let payload: [String: Any] = [
+            "type": "console_log",
+            "tag": forwardTag,
+            "message": [forwardMsg]
+        ]
+        guard let data = try? JSONSerialization.data(withJSONObject: payload),
+              let str = String(data: data, encoding: .utf8) else { return }
+        queue.async { [weak self] in
+            self?.send(payload: str)
+        }
+    }
+
+    private func parseConsoleMessage(tag: String, message: String) -> (String, String) {
+        if tag != "lynx" { return (tag, message) }
+        let pattern = #"\[.*?:(?:INFO|ERROR|WARN(?:ING)?|DEBUG|VERBOSE|FATAL):lynx_console\.cc\(\d+\)]\s*(.+)"#
+        guard let regex = try? NSRegularExpression(pattern: pattern, options: .dotMatchesLineSeparators),
+              let match = regex.firstMatch(in: message, range: NSRange(message.startIndex..., in: message)),
+              let range = Range(match.range(at: 1), in: message) else {
+            return (tag, message)
+        }
+        return ("lynx-console", String(message[range]))
+    }
+
+    private func buildWsURL(devUrl: String) -> URL? {
+        guard let url = URL(string: devUrl),
+              let scheme = url.scheme,
+              let host = url.host else { return nil }
+        let wsScheme = scheme == "https" ? "wss" : "ws"
+        let port = url.port ?? 0
+        let portPart = port > 0 ? ":\(port)" : ""
+        var path = url.path
+        if !path.hasSuffix("/") { path += "/" }
+        path += "__hmr"
+        let wsString = "\(wsScheme)://\(host)\(portPart)\(path)"
+        return URL(string: wsString)
+    }
+
+    private func sendConnected() {
+        let payload: [String: Any] = [
+            "type": "console_log",
+            "tag": "lynx-console",
+            "message": ["[TamerRelog] connected"]
+        ]
+        if let data = try? JSONSerialization.data(withJSONObject: payload),
+           let str = String(data: data, encoding: .utf8) {
+            send(payload: str)
+        }
+    }
+
+    private func send(payload: String) {
+        guard let task = webSocketTask else {
+            queueLock.lock()
+            if pendingQueue.count < maxQueue { pendingQueue.append(payload) }
+            queueLock.unlock()
+            return
+        }
+        task.send(.string(payload)) { [weak self] error in
+            if error != nil {
+                self?.queueLock.lock()
+                if self?.pendingQueue.count ?? 0 < maxQueue { self?.pendingQueue.append(payload) }
+                self?.queueLock.unlock()
+            }
+        }
+    }
+
+    private func flushPending() {
+        queueLock.lock()
+        let toSend = pendingQueue
+        pendingQueue.removeAll()
+        queueLock.unlock()
+        for payload in toSend {
+            webSocketTask?.send(.string(payload)) { _ in }
+        }
+    }
+
+    private func scheduleReconnect() {
+        guard shouldReconnect else { return }
+        queue.asyncAfter(deadline: .now() + reconnectDelay) { [weak self] in
+            self?.connect()
+        }
+    }
+}
+
+private final class RelogURLSessionDelegate: NSObject, URLSessionWebSocketDelegate {
+    var onOpen: (() -> Void)?
+    var onClose: (() -> Void)?
+    var onFailure: ((Error) -> Void)?
+
+    func urlSession(_ session: URLSession, webSocketTask: URLSessionWebSocketTask, didOpenWithProtocol protocol: String?) {
+        DispatchQueue.main.async { self.onOpen?() }
+    }
+
+    func urlSession(_ session: URLSession, webSocketTask: URLSessionWebSocketTask, didCloseWith closeCode: URLSessionWebSocketTask.CloseCode, reason: Data?) {
+        DispatchQueue.main.async { self.onClose?() }
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        if let error = error { DispatchQueue.main.async { self.onFailure?(error) } }
+    }
+}

package/ios/tamerdevclient/tamerdevclient.podspec

@@ -0,0 +1,16 @@
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+
+Pod::Spec.new do |s|
+  s.name             = 'tamerdevclient'
+  s.version          = package["version"]
+  s.summary          = 'Tamer dev client native module for iOS.'
+  s.description      = 'QR scan, HMR, Bonjour discovery, and project reload for the Tamer dev app.'
+  s.homepage         = "https://github.com/nanofuxion"
+  s.license          = package["license"]
+  s.authors          = package["author"]
+  s.source           = { :path => '.' }
+  s.swift_version    = '5.0'
+  s.ios.deployment_target = '13.0'
+  s.source_files     = 'tamerdevclient/Classes/**/*.swift'
+  s.dependency "Lynx"
+end

package/ios/templates/DevClientManager.swift

@@ -0,0 +1,51 @@
+import Foundation
+import tamerdevclient
+
+class DevClientManager {
+    private var webSocketTask: URLSessionWebSocketTask?
+    private let onReload: () -> Void
+    private var session: URLSession?
+
+    init(onReload: @escaping () -> Void) {
+        self.onReload = onReload
+    }
+
+    func connect() {
+        guard let devUrl = DevServerPrefs.getUrl(), !devUrl.isEmpty else { return }
+        guard let base = URL(string: devUrl) else { return }
+
+        let scheme = (base.scheme == "https") ? "wss" : "ws"
+        let host = base.host ?? "localhost"
+        let port = base.port.map { ":\($0)" } ?? ""
+        let rawPath = base.path.isEmpty ? "/" : base.path
+        let dir = rawPath.hasSuffix("/") ? rawPath : rawPath + "/"
+        guard let wsUrl = URL(string: "\(scheme)://\(host)\(port)\(dir)__hmr") else { return }
+
+        session = URLSession(configuration: .default)
+        let task = session!.webSocketTask(with: wsUrl)
+        webSocketTask = task
+        task.resume()
+        receive()
+    }
+
+    private func receive() {
+        webSocketTask?.receive { [weak self] result in
+            guard let self = self else { return }
+            switch result {
+            case .success(let msg):
+                if case .string(let text) = msg, text.contains("\"type\":\"reload\"") {
+                    DispatchQueue.main.async { self.onReload() }
+                }
+                self.receive()
+            case .failure:
+                break
+            }
+        }
+    }
+
+    func disconnect() {
+        webSocketTask?.cancel(with: .normalClosure, reason: nil)
+        webSocketTask = nil
+        session = nil
+    }
+}

package/ios/templates/DevLauncherViewController.swift

@@ -0,0 +1,102 @@
+import UIKit
+import Lynx
+import tamerdevclient
+import tamerinsets
+
+class DevLauncherViewController: UIViewController {
+    private var lynxView: LynxView?
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .black
+        edgesForExtendedLayout = .all
+        extendedLayoutIncludesOpaqueBars = true
+        additionalSafeAreaInsets = .zero
+        view.insetsLayoutMarginsFromSafeArea = false
+        view.preservesSuperviewLayoutMargins = false
+        viewRespectsSystemMinimumLayoutMargins = false
+        setupLynxView()
+        setupDevClientModule()
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        if let lynxView = lynxView {
+            applyFullscreenLayout(to: lynxView)
+        }
+    }
+
+    override func viewSafeAreaInsetsDidChange() {
+        super.viewSafeAreaInsetsDidChange()
+        TamerInsetsModule.reRequestInsets()
+    }
+
+    override var preferredStatusBarStyle: UIStatusBarStyle { .lightContent }
+
+    private func setupLynxView() {
+        let size = fullscreenBounds().size
+        let lv = LynxView { builder in
+            builder.config = LynxConfig(provider: DevTemplateProvider())
+            builder.screenSize = size
+            builder.fontScale = 1.0
+        }
+        lv.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        lv.insetsLayoutMarginsFromSafeArea = false
+        lv.preservesSuperviewLayoutMargins = false
+        view.addSubview(lv)
+        applyFullscreenLayout(to: lv)
+        lv.loadTemplate(fromURL: "dev-client.lynx.bundle", initData: nil)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) { [weak self, weak lv] in
+            guard let self, let lv else { return }
+            self.logViewport("devclient post-load", lynxView: lv)
+            self.applyFullscreenLayout(to: lv)
+        }
+        self.lynxView = lv
+    }
+
+    private func applyFullscreenLayout(to lynxView: LynxView) {
+        let bounds = fullscreenBounds()
+        let size = bounds.size
+        lynxView.frame = bounds
+        lynxView.updateScreenMetrics(withWidth: size.width, height: size.height)
+        lynxView.updateViewport(withPreferredLayoutWidth: size.width, preferredLayoutHeight: size.height, needLayout: true)
+        lynxView.preferredLayoutWidth = size.width
+        lynxView.preferredLayoutHeight = size.height
+        lynxView.layoutWidthMode = .exact
+        lynxView.layoutHeightMode = .exact
+        logViewport("devclient apply", lynxView: lynxView)
+    }
+
+    private func fullscreenBounds() -> CGRect {
+        let bounds = view.bounds
+        if bounds.width > 0, bounds.height > 0 {
+            return bounds
+        }
+        return UIScreen.main.bounds
+    }
+
+    private func logViewport(_ label: String, lynxView: LynxView) {
+        let rootWidth = lynxView.rootWidth()
+        let rootHeight = lynxView.rootHeight()
+        let intrinsic = lynxView.intrinsicContentSize
+        NSLog("[DevLauncher] %@ view=%@ safe=%@ lynxFrame=%@ lynxBounds=%@ root=%0.2fx%0.2f intrinsic=%@", label, NSCoder.string(for: view.bounds), NSCoder.string(for: view.safeAreaInsets), NSCoder.string(for: lynxView.frame), NSCoder.string(for: lynxView.bounds), rootWidth, rootHeight, NSCoder.string(for: intrinsic))
+    }
+
+    private func setupDevClientModule() {
+        DevClientModule.presentQRScanner = { [weak self] completion in
+            let scanner = QRScannerViewController()
+            scanner.onResult = { url in
+                scanner.dismiss(animated: true) { completion(url) }
+            }
+            scanner.modalPresentationStyle = .fullScreen
+            self?.present(scanner, animated: true)
+        }
+
+        DevClientModule.reloadProjectHandler = { [weak self] in
+            guard let self = self else { return }
+            let projectVC = ProjectViewController()
+            projectVC.modalPresentationStyle = .fullScreen
+            self.present(projectVC, animated: true)
+        }
+    }
+}

package/ios/templates/DevTemplateProvider.swift

@@ -0,0 +1,66 @@
+import Foundation
+import Lynx
+import tamerdevclient
+
+class DevTemplateProvider: NSObject, LynxTemplateProvider {
+    private static let devClientBundle = "dev-client.lynx.bundle"
+
+    func loadTemplate(withUrl url: String!, onComplete callback: LynxTemplateLoadBlock!) {
+        DispatchQueue.global(qos: .background).async {
+            if url == Self.devClientBundle || url?.hasSuffix("/" + Self.devClientBundle) == true {
+                self.loadFromBundle(url: Self.devClientBundle, callback: callback)
+                return
+            }
+
+            if let devUrl = DevServerPrefs.getUrl(), !devUrl.isEmpty {
+                let origin: String
+                if let parsed = URL(string: devUrl) {
+                    let scheme = parsed.scheme ?? "http"
+                    let host = parsed.host ?? "localhost"
+                    let port = parsed.port.map { ":\($0)" } ?? ""
+                    origin = "\(scheme)://\(host)\(port)"
+                } else {
+                    origin = devUrl
+                }
+
+                let candidates = ["/\(url!)", "/{{PROJECT_BUNDLE_SEGMENT}}/\(url!)"]
+                for candidate in candidates {
+                    if let data = self.httpFetch(url: origin + candidate) {
+                        callback?(data, nil)
+                        return
+                    }
+                }
+            }
+
+            self.loadFromBundle(url: url, callback: callback)
+        }
+    }
+
+    private func loadFromBundle(url: String?, callback: LynxTemplateLoadBlock!) {
+        guard let url = url,
+              let bundleUrl = Bundle.main.url(forResource: url, withExtension: nil),
+              let data = try? Data(contentsOf: bundleUrl) else {
+            let err = NSError(domain: "DevTemplateProvider", code: 404,
+                              userInfo: [NSLocalizedDescriptionKey: "Bundle not found: \(url ?? "nil")"])
+            callback?(nil, err)
+            return
+        }
+        callback?(data, nil)
+    }
+
+    private func httpFetch(url: String) -> Data? {
+        guard let u = URL(string: url) else { return nil }
+        var req = URLRequest(url: u)
+        req.timeoutInterval = 10
+        var result: Data?
+        let sem = DispatchSemaphore(value: 0)
+        URLSession.shared.dataTask(with: req) { data, response, _ in
+            if let http = response as? HTTPURLResponse, http.statusCode == 200 {
+                result = data
+            }
+            sem.signal()
+        }.resume()
+        sem.wait()
+        return result
+    }
+}

package/ios/templates/LynxInitProcessor.swift

@@ -0,0 +1,37 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+import Foundation
+
+// GENERATED IMPORTS START
+// This section is automatically generated by Tamer4Lynx.
+// Manual edits will be overwritten.
+// GENERATED IMPORTS END
+
+final class LynxInitProcessor {
+    static let shared = LynxInitProcessor()
+    private init() {}
+
+    func setupEnvironment() {
+        TamerIconElement.registerFonts()
+        setupLynxEnv()
+        setupLynxService()
+    }
+
+    private func setupLynxEnv() {
+        let env = LynxEnv.sharedInstance()
+        let globalConfig = LynxConfig(provider: env.config.templateProvider)
+
+        // GENERATED AUTOLINK START
+
+        // GENERATED AUTOLINK END
+
+        env.prepareConfig(globalConfig)
+    }
+
+    private func setupLynxService() {
+        let webPCoder = SDImageWebPCoder.shared
+        SDImageCodersManager.shared.addCoder(webPCoder)
+    }
+}

package/ios/templates/ProjectViewController.swift

@@ -0,0 +1,105 @@
+import UIKit
+import Lynx
+import tamerinsets
+
+class ProjectViewController: UIViewController {
+    private var lynxView: LynxView?
+    private var devClientManager: DevClientManager?
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .black
+        edgesForExtendedLayout = .all
+        extendedLayoutIncludesOpaqueBars = true
+        additionalSafeAreaInsets = .zero
+        view.insetsLayoutMarginsFromSafeArea = false
+        view.preservesSuperviewLayoutMargins = false
+        viewRespectsSystemMinimumLayoutMargins = false
+        setupLynxView()
+        devClientManager = DevClientManager(onReload: { [weak self] in
+            self?.reloadLynxView()
+        })
+        devClientManager?.connect()
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        if let lynxView = lynxView {
+            applyFullscreenLayout(to: lynxView)
+        }
+    }
+
+    override func viewSafeAreaInsetsDidChange() {
+        super.viewSafeAreaInsetsDidChange()
+        TamerInsetsModule.reRequestInsets()
+    }
+
+    override var preferredStatusBarStyle: UIStatusBarStyle { .lightContent }
+
+    private func buildLynxView() -> LynxView {
+        let size = fullscreenBounds().size
+        let lv = LynxView { builder in
+            builder.config = LynxConfig(provider: DevTemplateProvider())
+            builder.screenSize = size
+            builder.fontScale = 1.0
+        }
+        lv.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        lv.insetsLayoutMarginsFromSafeArea = false
+        lv.preservesSuperviewLayoutMargins = false
+        applyFullscreenLayout(to: lv)
+        return lv
+    }
+
+    private func setupLynxView() {
+        let lv = buildLynxView()
+        view.addSubview(lv)
+        lv.loadTemplate(fromURL: "main.lynx.bundle", initData: nil)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) { [weak self, weak lv] in
+            guard let self, let lv else { return }
+            self.logViewport("project post-load", lynxView: lv)
+            self.applyFullscreenLayout(to: lv)
+        }
+        self.lynxView = lv
+    }
+
+    private func reloadLynxView() {
+        lynxView?.removeFromSuperview()
+        lynxView = nil
+        setupLynxView()
+    }
+
+    private func applyFullscreenLayout(to lynxView: LynxView) {
+        let bounds = fullscreenBounds()
+        let size = bounds.size
+        lynxView.frame = bounds
+        lynxView.updateScreenMetrics(withWidth: size.width, height: size.height)
+        lynxView.updateViewport(withPreferredLayoutWidth: size.width, preferredLayoutHeight: size.height, needLayout: true)
+        lynxView.preferredLayoutWidth = size.width
+        lynxView.preferredLayoutHeight = size.height
+        lynxView.layoutWidthMode = .exact
+        lynxView.layoutHeightMode = .exact
+        logViewport("project apply", lynxView: lynxView)
+    }
+
+    private func fullscreenBounds() -> CGRect {
+        let bounds = view.bounds
+        if bounds.width > 0, bounds.height > 0 {
+            return bounds
+        }
+        return UIScreen.main.bounds
+    }
+
+    private func logViewport(_ label: String, lynxView: LynxView) {
+        let rootWidth = lynxView.rootWidth()
+        let rootHeight = lynxView.rootHeight()
+        let intrinsic = lynxView.intrinsicContentSize
+        NSLog("[ProjectVC] %@ view=%@ safe=%@ lynxFrame=%@ lynxBounds=%@ root=%0.2fx%0.2f intrinsic=%@", label, NSCoder.string(for: view.bounds), NSCoder.string(for: view.safeAreaInsets), NSCoder.string(for: lynxView.frame), NSCoder.string(for: lynxView.bounds), rootWidth, rootHeight, NSCoder.string(for: intrinsic))
+    }
+
+    override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        if isBeingDismissed || isMovingFromParent {
+            devClientManager?.disconnect()
+        }
+    }
+}

package/ios/templates/QRScannerViewController.swift

@@ -0,0 +1,83 @@
+import UIKit
+import AVFoundation
+
+class QRScannerViewController: UIViewController {
+    var onResult: ((String?) -> Void)?
+
+    private var captureSession: AVCaptureSession?
+    private var previewLayer: AVCaptureVideoPreviewLayer?
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .black
+        setupCamera()
+        addCancelButton()
+    }
+
+    private func setupCamera() {
+        let session = AVCaptureSession()
+        guard let device = AVCaptureDevice.default(for: .video),
+              let input = try? AVCaptureDeviceInput(device: device) else {
+            onResult?(nil)
+            return
+        }
+
+        let output = AVCaptureMetadataOutput()
+        session.addInput(input)
+        session.addOutput(output)
+        output.setMetadataObjectsDelegate(self, queue: .main)
+        output.metadataObjectTypes = [.qr]
+
+        let preview = AVCaptureVideoPreviewLayer(session: session)
+        preview.frame = view.layer.bounds
+        preview.videoGravity = .resizeAspectFill
+        view.layer.insertSublayer(preview, at: 0)
+        previewLayer = preview
+
+        DispatchQueue.global(qos: .userInitiated).async { session.startRunning() }
+        captureSession = session
+    }
+
+    private func addCancelButton() {
+        let btn = UIButton(type: .system)
+        btn.setTitle("Cancel", for: .normal)
+        btn.setTitleColor(.white, for: .normal)
+        btn.titleLabel?.font = .systemFont(ofSize: 18, weight: .medium)
+        btn.addTarget(self, action: #selector(cancel), for: .touchUpInside)
+        btn.translatesAutoresizingMaskIntoConstraints = false
+        view.addSubview(btn)
+        NSLayoutConstraint.activate([
+            btn.centerXAnchor.constraint(equalTo: view.centerXAnchor),
+            btn.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor, constant: -24),
+        ])
+    }
+
+    @objc private func cancel() {
+        captureSession?.stopRunning()
+        onResult?(nil)
+    }
+
+    override func viewWillAppear(_ animated: Bool) {
+        super.viewWillAppear(animated)
+        if captureSession?.isRunning == false {
+            DispatchQueue.global(qos: .userInitiated).async { self.captureSession?.startRunning() }
+        }
+    }
+
+    override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        captureSession?.stopRunning()
+    }
+}
+
+extension QRScannerViewController: AVCaptureMetadataOutputObjectsDelegate {
+    func metadataOutput(_ output: AVCaptureMetadataOutput,
+                        didOutput objects: [AVMetadataObject],
+                        from connection: AVCaptureConnection) {
+        captureSession?.stopRunning()
+        if let obj = objects.first as? AVMetadataMachineReadableCodeObject,
+           let value = obj.stringValue {
+            onResult?(value)
+        }
+    }
+}

package/lynx.config.ts

@@ -0,0 +1,19 @@
+import { fileURLToPath } from 'url'
+import path from 'path'
+import { pluginReactLynx } from '@lynx-js/react-rsbuild-plugin'
+import { pluginTamer } from '@tamer4lynx/tamer-plugin'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+export default {
+  source: {
+    entry: { 'dev-client': './src/index.tsx' },
+    alias: {
+      '@tamer4lynx/tamer-app-shell': path.resolve(__dirname, '../tamer-app-shell/src/index.tsx'),
+      '@tamer4lynx/tamer-screen': path.resolve(__dirname, '../tamer-screen/src/index.tsx'),
+      '@tamer4lynx/tamer-icons': path.resolve(__dirname, '../tamer-icons/src/index.tsx'),
+      '@tamer4lynx/tamer-insets': path.resolve(__dirname, '../tamer-insets/src/index.ts'),
+    },
+  },
+  plugins: [pluginTamer(), pluginReactLynx()],
+}