@crumbsdk/react-native 0.0.1-rc.3 → 0.0.1-rc.4

package/native/ios/packages/ios/Sources/CrumbUI/CrumbReporterLifecycle.swift

@@ -0,0 +1,119 @@
+import CrumbCore
+#if canImport(UIKit) && canImport(CoreMotion)
+import CoreMotion
+import UIKit
+
+public extension Crumb {
+    /// Installs foreground-only automatic reporter invocation. Call once after `start`.
+    @MainActor
+    @discardableResult
+    static func installReporter() -> Bool {
+        CrumbReporterLifecycle.shared.install()
+    }
+}
+
+@MainActor
+final class CrumbReporterLifecycle: NSObject {
+    static let shared = CrumbReporterLifecycle()
+
+    private let motionManager = CMMotionManager()
+    private var recognizer = CrumbShakeGestureRecognizer()
+    private var sampleTimer: Timer?
+    private var isInstalled = false
+
+    func install() -> Bool {
+        guard (try? Crumb.reportSettings()) != nil else { return false }
+        guard !isInstalled else {
+            startShakeMonitoringIfNeeded()
+            return true
+        }
+
+        isInstalled = true
+        CrumbRenderingMonitor.shared.install()
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(applicationDidBecomeActive),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(applicationWillResignActive),
+            name: UIApplication.willResignActiveNotification,
+            object: nil
+        )
+        Task {
+            try? await CrumbReportQueue.shared.recoverInterruptedUploads()
+        }
+        CrumbWorkspacePolicyCoordinator.shared.install()
+        CrumbUploadCoordinator.shared.resume()
+        startShakeMonitoringIfNeeded()
+        return true
+    }
+
+    func reporterPresentationDidBegin() {
+        stopShakeMonitoring()
+    }
+
+    func reporterPresentationDidEnd() {
+        startShakeMonitoringIfNeeded()
+    }
+
+    func reportDidQueue() {
+        CrumbUploadCoordinator.shared.reportDidQueue()
+    }
+
+    @objc private func applicationDidBecomeActive() {
+        CrumbWorkspacePolicyCoordinator.shared.refresh()
+        CrumbUploadCoordinator.shared.resume()
+        startShakeMonitoringIfNeeded()
+    }
+
+    @objc private func applicationWillResignActive() {
+        CrumbUploadCoordinator.shared.pause()
+        stopShakeMonitoring()
+    }
+
+    private func startShakeMonitoringIfNeeded() {
+        guard isInstalled,
+              UIApplication.shared.applicationState == .active,
+              let settings = try? Crumb.reportSettings(),
+              settings.invocation.contains(.shake),
+              motionManager.isAccelerometerAvailable,
+              sampleTimer == nil else {
+            return
+        }
+
+        recognizer.reset()
+        motionManager.accelerometerUpdateInterval = 0.1
+        motionManager.startAccelerometerUpdates()
+        let timer = Timer(timeInterval: 0.1, repeats: true) { [weak self] _ in
+            MainActor.assumeIsolated {
+                self?.sampleMotion()
+            }
+        }
+        RunLoop.main.add(timer, forMode: .common)
+        sampleTimer = timer
+    }
+
+    private func stopShakeMonitoring() {
+        sampleTimer?.invalidate()
+        sampleTimer = nil
+        motionManager.stopAccelerometerUpdates()
+        recognizer.reset()
+    }
+
+    private func sampleMotion() {
+        guard let acceleration = motionManager.accelerometerData?.acceleration else { return }
+        let didShake = recognizer.record(
+            accelerationX: acceleration.x,
+            y: acceleration.y,
+            z: acceleration.z,
+            at: ProcessInfo.processInfo.systemUptime
+        )
+        if didShake {
+            Crumb.show(trigger: .shake)
+        }
+    }
+}
+#endif

package/native/ios/packages/ios/Sources/CrumbUI/CrumbScreenshotArtifact.swift

@@ -0,0 +1,186 @@
+import CrumbCore
+#if canImport(UIKit)
+import CryptoKit
+import ObjectiveC
+import UIKit
+
+private enum CrumbScreenshotMaskAssociation {
+    nonisolated(unsafe) static var key: UInt8 = 0
+}
+
+public extension UIView {
+    /// Marks this view's visible bounds as an opaque region in Crumb screenshots.
+    var crumbMaskInScreenshots: Bool {
+        get {
+            (objc_getAssociatedObject(self, &CrumbScreenshotMaskAssociation.key) as? Bool) == true
+        }
+        set {
+            objc_setAssociatedObject(
+                self,
+                &CrumbScreenshotMaskAssociation.key,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+}
+
+package struct CrumbScreenshotArtifact {
+    package let preview: UIImage
+    package let encodedData: Data
+    package let manifest: CrumbArtifactManifest
+    package let maskingState: CrumbScreenshotMaskingState
+}
+
+@MainActor
+package enum CrumbScreenshotArtifactPipeline {
+    package static func capture(
+        window: UIWindow,
+        capture: CrumbCaptureOptions,
+        privacy: CrumbPrivacyOptions
+    ) -> CrumbScreenshotArtifact? {
+        guard window.bounds.width > 0, window.bounds.height > 0 else { return nil }
+
+        let maskViews = sensitiveViews(
+            in: window,
+            includeTextInputs: privacy.maskAllTextInputs
+        )
+        let maskingConfigured = privacy.maskScreenshotsBeforeUpload
+            || privacy.maskAllTextInputs
+            || !maskViews.isEmpty
+
+        let format = UIGraphicsImageRendererFormat()
+        format.scale = window.screen.scale
+        format.opaque = true
+        let rendered = UIGraphicsImageRenderer(bounds: window.bounds, format: format).image { renderer in
+            window.layer.render(in: renderer.cgContext)
+            renderer.cgContext.setFillColor(UIColor.black.cgColor)
+            for view in maskViews where isVisible(view) {
+                let frame = view.convert(view.bounds, to: window)
+                    .insetBy(dx: -3, dy: -3)
+                    .intersection(window.bounds)
+                guard !frame.isNull, !frame.isEmpty else { continue }
+                renderer.cgContext.fill(frame)
+            }
+        }
+
+        guard let encoded = encode(
+            rendered,
+            maximumDimension: capture.maximumScreenshotDimension,
+            maximumBytes: capture.maximumScreenshotBytes
+        ) else { return nil }
+
+        let digest = SHA256.hash(data: encoded.data).map { String(format: "%02x", $0) }.joined()
+        let token = UUID().uuidString.replacingOccurrences(of: "-", with: "")
+        let maskingState: CrumbScreenshotMaskingState = maskingConfigured ? .applied : .notApplicable
+        return CrumbScreenshotArtifact(
+            preview: encoded.image,
+            encodedData: encoded.data,
+            manifest: CrumbArtifactManifest(
+                id: "art_\(token)",
+                kind: "screenshot",
+                mimeType: "image/png",
+                byteSize: encoded.data.count,
+                sha256: digest,
+                redactionState: maskingConfigured ? "masked" : "not_applicable",
+                uploadID: "upl_\(token)"
+            ),
+            maskingState: maskingState
+        )
+    }
+
+    private static func sensitiveViews(
+        in view: UIView,
+        includeTextInputs: Bool
+    ) -> [UIView] {
+        var matches: [UIView] = []
+        if view.crumbMaskInScreenshots
+            || (includeTextInputs && (view is UITextField || view is UITextView)) {
+            matches.append(view)
+        }
+        for child in view.subviews {
+            matches.append(contentsOf: sensitiveViews(in: child, includeTextInputs: includeTextInputs))
+        }
+        return matches
+    }
+
+    private static func isVisible(_ view: UIView) -> Bool {
+        !view.isHidden && view.alpha > 0 && view.window != nil && view.bounds.width > 0 && view.bounds.height > 0
+    }
+
+    private static func encode(
+        _ image: UIImage,
+        maximumDimension: Int,
+        maximumBytes: Int
+    ) -> (image: UIImage, data: Data)? {
+        var current = resized(image, maximumDimension: maximumDimension)
+        for _ in 0..<10 {
+            guard let data = current.pngData() else { return nil }
+            if data.count <= maximumBytes {
+                return (current, data)
+            }
+
+            let pixelSize = pixels(of: current)
+            guard pixelSize.width > 160, pixelSize.height > 160 else { return nil }
+            let ratio = sqrt(Double(maximumBytes) / Double(data.count)) * 0.9
+            let nextMaximum = max(160, Int(max(pixelSize.width, pixelSize.height) * min(0.9, ratio)))
+            guard nextMaximum < Int(max(pixelSize.width, pixelSize.height)) else { return nil }
+            current = resized(current, maximumDimension: nextMaximum)
+        }
+        return nil
+    }
+
+    private static func resized(_ image: UIImage, maximumDimension: Int) -> UIImage {
+        let pixelSize = pixels(of: image)
+        let longest = max(pixelSize.width, pixelSize.height)
+        guard longest > CGFloat(maximumDimension) else { return image }
+
+        let scale = CGFloat(maximumDimension) / longest
+        let target = CGSize(
+            width: max(1, floor(pixelSize.width * scale)),
+            height: max(1, floor(pixelSize.height * scale))
+        )
+        let format = UIGraphicsImageRendererFormat()
+        format.scale = 1
+        format.opaque = true
+        return UIGraphicsImageRenderer(size: target, format: format).image { _ in
+            image.draw(in: CGRect(origin: .zero, size: target))
+        }
+    }
+
+    private static func pixels(of image: UIImage) -> CGSize {
+        if let cgImage = image.cgImage {
+            return CGSize(width: cgImage.width, height: cgImage.height)
+        }
+        return CGSize(width: image.size.width * image.scale, height: image.size.height * image.scale)
+    }
+}
+
+#if canImport(SwiftUI)
+import SwiftUI
+
+public extension SwiftUI.View {
+    /// Marks this SwiftUI view's rendered bounds as an opaque region in Crumb screenshots.
+    func crumbMaskInScreenshots(_ masked: Bool = true) -> some SwiftUI.View {
+        overlay(CrumbScreenshotMaskRegion(masked: masked).allowsHitTesting(false))
+    }
+}
+
+private struct CrumbScreenshotMaskRegion: UIViewRepresentable {
+    let masked: Bool
+
+    func makeUIView(context: Context) -> UIView {
+        let view = UIView(frame: .zero)
+        view.backgroundColor = .clear
+        view.isAccessibilityElement = false
+        view.isUserInteractionEnabled = false
+        view.crumbMaskInScreenshots = masked
+        return view
+    }
+
+    func updateUIView(_ uiView: UIView, context: Context) {
+        uiView.crumbMaskInScreenshots = masked
+    }
+}
+#endif
+#endif

package/native/ios/packages/ios/Sources/CrumbUI/CrumbShakeGestureRecognizer.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+struct CrumbShakeGestureRecognizer {
+    private let thresholdG: Double
+    private let requiredHits: Int
+    private let hitWindow: TimeInterval
+    private let cooldown: TimeInterval
+
+    private var gravity = [Double](repeating: 0, count: 3)
+    private var hitTimes: [TimeInterval] = []
+    private var lastTriggerAt: TimeInterval?
+
+    init(
+        thresholdG: Double = 2.2,
+        requiredHits: Int = 2,
+        hitWindow: TimeInterval = 0.6,
+        cooldown: TimeInterval = 1.5
+    ) {
+        self.thresholdG = thresholdG
+        self.requiredHits = requiredHits
+        self.hitWindow = hitWindow
+        self.cooldown = cooldown
+    }
+
+    mutating func record(
+        accelerationX: Double,
+        y: Double,
+        z: Double,
+        at timestamp: TimeInterval
+    ) -> Bool {
+        let values = [accelerationX, y, z]
+        var magnitudeSquared = 0.0
+        for index in values.indices {
+            gravity[index] = 0.8 * gravity[index] + 0.2 * values[index]
+            let linear = values[index] - gravity[index]
+            magnitudeSquared += linear * linear
+        }
+        return record(linearMagnitudeG: magnitudeSquared.squareRoot(), at: timestamp)
+    }
+
+    mutating func record(linearMagnitudeG: Double, at timestamp: TimeInterval) -> Bool {
+        guard linearMagnitudeG >= thresholdG else { return false }
+        hitTimes.append(timestamp)
+        hitTimes.removeAll { timestamp - $0 > hitWindow }
+
+        guard hitTimes.count >= requiredHits else { return false }
+        guard lastTriggerAt.map({ timestamp - $0 >= cooldown }) ?? true else {
+            hitTimes.removeAll()
+            return false
+        }
+
+        lastTriggerAt = timestamp
+        hitTimes.removeAll()
+        return true
+    }
+
+    mutating func reset() {
+        gravity = [Double](repeating: 0, count: 3)
+        hitTimes.removeAll()
+        lastTriggerAt = nil
+    }
+}

package/native/ios/packages/ios/Sources/CrumbUI/CrumbUploadCoordinator.swift

@@ -0,0 +1,113 @@
+import CrumbCore
+#if canImport(UIKit) && canImport(Network)
+import Network
+import UIKit
+
+@MainActor
+final class CrumbUploadCoordinator {
+    static let shared = CrumbUploadCoordinator()
+
+    private let monitorQueue = DispatchQueue(label: "dev.crumb.upload-connectivity")
+    private var worker: CrumbReportUploadWorker?
+    private var uploadTask: Task<Void, Never>?
+    private var retryTask: Task<Void, Never>?
+    private var pathMonitor: NWPathMonitor?
+    private var retryStep = 0
+    private var isForeground = false
+
+    private init() {}
+
+    func resume() {
+        isForeground = true
+        wake()
+    }
+
+    func pause() {
+        isForeground = false
+        retryTask?.cancel()
+        retryTask = nil
+        uploadTask?.cancel()
+        stopConnectivityMonitoring()
+    }
+
+    func reportDidQueue() {
+        wake()
+    }
+
+    private func wake() {
+        guard isForeground else { return }
+        if worker == nil {
+            guard let settings = try? Crumb.uploadSettings() else { return }
+            worker = CrumbReportUploadWorker(settings: settings)
+        }
+        guard let worker else { return }
+
+        startConnectivityMonitoring()
+        guard uploadTask == nil else { return }
+        retryTask?.cancel()
+        retryTask = nil
+        uploadTask = Task { [weak self] in
+            let result = await worker.runPass()
+            guard let self else { return }
+            self.uploadTask = nil
+            self.handle(result)
+        }
+    }
+
+    private func handle(_ result: CrumbUploadPassResult) {
+        if result.remainingReportCount == 0 {
+            retryStep = 0
+            stopConnectivityMonitoring()
+            return
+        }
+        guard isForeground else { return }
+        if result.wasCancelled {
+            wake()
+        } else if result.shouldRetry {
+            scheduleRetry()
+        } else {
+            // Permanent failures remain durable, but do not consume battery in a retry loop.
+            stopConnectivityMonitoring()
+        }
+    }
+
+    private func scheduleRetry() {
+        let delays: [UInt64] = [1, 2, 4, 8, 16, 32, 60]
+        let seconds = delays[min(retryStep, delays.count - 1)]
+        retryStep = min(retryStep + 1, delays.count - 1)
+        retryTask?.cancel()
+        retryTask = Task { [weak self] in
+            do {
+                try await Task.sleep(nanoseconds: seconds * 1_000_000_000)
+            } catch {
+                return
+            }
+            guard let self else { return }
+            self.retryTask = nil
+            self.wake()
+        }
+    }
+
+    private func startConnectivityMonitoring() {
+        guard pathMonitor == nil else { return }
+        let monitor = NWPathMonitor()
+        monitor.pathUpdateHandler = { [weak self] path in
+            guard path.status == .satisfied else { return }
+            Task { @MainActor [weak self] in
+                guard let self, self.isForeground else { return }
+                self.retryStep = 0
+                self.retryTask?.cancel()
+                self.retryTask = nil
+                self.wake()
+            }
+        }
+        pathMonitor = monitor
+        monitor.start(queue: monitorQueue)
+    }
+
+    private func stopConnectivityMonitoring() {
+        pathMonitor?.cancel()
+        pathMonitor = nil
+    }
+}
+#endif

package/native/ios/packages/ios/Sources/CrumbUI/CrumbWorkspacePolicyCoordinator.swift

@@ -0,0 +1,86 @@
+import CrumbCore
+#if canImport(UIKit)
+import Foundation
+import UIKit
+
+/// Loads only the small, versioned privacy policy document. The request is
+/// best-effort and never delays reporter presentation or local report saving.
+@MainActor
+final class CrumbWorkspacePolicyCoordinator {
+    static let shared = CrumbWorkspacePolicyCoordinator()
+
+    private var isInstalled = false
+    private var fetchTask: Task<Void, Never>?
+
+    private init() {}
+
+    func install() {
+        guard !isInstalled else {
+            refresh()
+            return
+        }
+        isInstalled = true
+        loadCachedPolicy()
+        refresh()
+    }
+
+    func refresh() {
+        guard fetchTask == nil,
+              let settings = try? Crumb.workspacePolicyFetchSettings() else {
+            return
+        }
+        Crumb.beginWorkspacePolicyFetch()
+        fetchTask = Task { [weak self] in
+            await self?.fetch(settings)
+        }
+    }
+
+    private func loadCachedPolicy() {
+        guard let key = try? Crumb.workspacePolicyCacheKey(),
+              let data = UserDefaults.standard.data(forKey: key) else {
+            Crumb.markWorkspacePolicyUnavailable()
+            return
+        }
+        guard let policy = CrumbPolicyCache.load(data: data) else {
+            UserDefaults.standard.removeObject(forKey: key)
+            Crumb.markWorkspacePolicyUnavailable()
+            return
+        }
+        Crumb.applyWorkspacePolicy(policy, source: .cached)
+    }
+
+    private func fetch(_ settings: CrumbPolicyFetchSettings) async {
+        defer { fetchTask = nil }
+        var request = URLRequest(
+            url: settings.url,
+            cachePolicy: .reloadIgnoringLocalCacheData,
+            timeoutInterval: settings.timeout
+        )
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(settings.projectKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+
+        do {
+            let (data, response) = try await URLSession.shared.data(for: request)
+            guard data.count <= CrumbPolicyCache.maximumBytes,
+                  let response = response as? HTTPURLResponse,
+                  (200..<300).contains(response.statusCode) else {
+                throw PolicyFetchError.invalidResponse
+            }
+            let policy = try CrumbWorkspacePolicy.decode(data)
+            let accepted = Crumb.applyWorkspacePolicy(policy, source: .fresh)
+            if accepted, let key = try? Crumb.workspacePolicyCacheKey() {
+                UserDefaults.standard.set(data, forKey: key)
+            }
+        } catch is CancellationError {
+            return
+        } catch {
+            Crumb.markWorkspacePolicyUnavailable()
+        }
+    }
+}
+
+private enum PolicyFetchError: Error {
+    case invalidResponse
+}
+#endif