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

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

@@ -0,0 +1,269 @@
+#if os(iOS)
+import CoreTelephony
+import CrumbCore
+import Darwin
+import Foundation
+import Network
+
+enum OnDemandDiagnosticsCollector {
+    static func capture(
+        location: String,
+        options: CrumbDiagnosticsOptions,
+        evidence: Set<CrumbEvidenceCategory> = Set(CrumbEvidenceCategory.allCases),
+        screenContext: CrumbScreenContext? = nil
+    ) -> CrumbDiagnosticsSnapshot {
+        let capturesPerformance = evidence.contains(.performance)
+        let threads = capturesPerformance ? threadDiagnostics() : []
+        let cpuUsagePercent: Double? = if !capturesPerformance || threads.isEmpty {
+            nil
+        } else {
+            threads.compactMap(\.cpuUsagePercent).reduce(0, +)
+        }
+        let memory = capturesPerformance ? memoryDiagnostics() : nil
+        let network = evidence.contains(.network)
+            ? networkDiagnostics(
+                options: CrumbDiagnosticsOptions(
+                    healthCheckURL: evidence.contains(.healthCheck) ? options.healthCheckURL : nil,
+                    timeout: options.timeout,
+                    logs: options.logs
+                )
+            )
+            : CrumbNetworkDiagnostic(
+                status: "unknown",
+                transport: "unknown",
+                cellularGeneration: nil,
+                isExpensive: false,
+                isConstrained: false,
+                healthCheck: nil
+            )
+        let logs: CrumbLogDiagnostic
+        if evidence.contains(.logs) {
+            logs = OnDemandLogCollector.capture(options: options.logs)
+        } else {
+            logs = CrumbLogDiagnostic(
+                status: options.logs.enabled ? .disabledByPolicy : .disabled,
+                sources: [],
+                entries: [],
+                truncated: false,
+                droppedEntryCount: 0,
+                failures: options.logs.enabled ? ["disabled_by_policy"] : []
+            )
+        }
+        let stackTraces = evidence.contains(.threadStacks)
+            ? CrumbStackTraceDiagnostic(
+                status: .unavailable,
+                scope: "none",
+                threads: [],
+                truncated: false,
+                unavailableReason: "all_thread_stacks_unavailable_without_sampling"
+            )
+            : CrumbStackTraceDiagnostic(
+                status: .unavailable,
+                scope: "none",
+                threads: [],
+                truncated: false,
+                unavailableReason: "disabled_by_policy"
+            )
+
+        return CrumbDiagnosticsSnapshot(
+            capturedAt: Date(),
+            location: location,
+            processName: ProcessInfo.processInfo.processName,
+            processID: getpid(),
+            cpuUsagePercent: cpuUsagePercent,
+            residentMemoryBytes: memory?.resident,
+            physicalFootprintBytes: memory?.footprint,
+            thermalState: capturesPerformance ? thermalState() : "unavailable_by_policy",
+            threadCount: threads.count,
+            busiestThreads: Array(
+                threads
+                    .sorted { ($0.cpuUsagePercent ?? 0) > ($1.cpuUsagePercent ?? 0) }
+                    .prefix(12)
+            ),
+            gpuStatus: "Unavailable on demand on iOS",
+            network: network,
+            logs: logs,
+            stackTraces: stackTraces,
+            rendering: options.renderingEnabled && capturesPerformance ? CrumbRenderingBuffer.shared.snapshot() : nil,
+            screenContext: evidence.contains(.customContext) ? screenContext : nil
+        )
+    }
+
+    private static func memoryDiagnostics() -> (resident: UInt64, footprint: UInt64)? {
+        var info = task_vm_info_data_t()
+        var count = mach_msg_type_number_t(
+            MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<natural_t>.size
+        )
+        let result = withUnsafeMutablePointer(to: &info) { pointer in
+            pointer.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { rebound in
+                task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), rebound, &count)
+            }
+        }
+        guard result == KERN_SUCCESS else { return nil }
+        return (UInt64(info.resident_size), UInt64(info.phys_footprint))
+    }
+
+    private static func threadDiagnostics() -> [CrumbThreadDiagnostic] {
+        var threadList: thread_act_array_t?
+        var threadCount: mach_msg_type_number_t = 0
+        guard task_threads(mach_task_self_, &threadList, &threadCount) == KERN_SUCCESS,
+              let threadList else {
+            return []
+        }
+        defer {
+            let byteCount = vm_size_t(Int(threadCount) * MemoryLayout<thread_t>.stride)
+            vm_deallocate(
+                mach_task_self_,
+                vm_address_t(UInt(bitPattern: threadList)),
+                byteCount
+            )
+        }
+
+        var snapshots: [CrumbThreadDiagnostic] = []
+        snapshots.reserveCapacity(Int(threadCount))
+        for index in 0..<Int(threadCount) {
+            let thread = threadList[index]
+            defer { mach_port_deallocate(mach_task_self_, thread) }
+
+            var info = thread_basic_info_data_t()
+            var infoCount = mach_msg_type_number_t(
+                MemoryLayout<thread_basic_info_data_t>.size / MemoryLayout<integer_t>.size
+            )
+            let result = withUnsafeMutablePointer(to: &info) { pointer in
+                pointer.withMemoryRebound(to: integer_t.self, capacity: Int(infoCount)) { rebound in
+                    thread_info(thread, thread_flavor_t(THREAD_BASIC_INFO), rebound, &infoCount)
+                }
+            }
+            guard result == KERN_SUCCESS else { continue }
+
+            let cpu: Double? = (info.flags & TH_FLAGS_IDLE) == 0
+                ? Double(info.cpu_usage) / Double(TH_USAGE_SCALE) * 100
+                : 0
+            snapshots.append(
+                CrumbThreadDiagnostic(
+                    id: UInt64(thread),
+                    name: threadName(thread) ?? "thread-\(thread)",
+                    state: threadState(info.run_state),
+                    cpuUsagePercent: cpu
+                )
+            )
+        }
+        return snapshots
+    }
+
+    private static func threadName(_ thread: thread_t) -> String? {
+        guard let pthread = pthread_from_mach_thread_np(thread) else { return nil }
+        var buffer = [CChar](repeating: 0, count: 64)
+        let result = buffer.withUnsafeMutableBufferPointer { pointer in
+            pthread_getname_np(pthread, pointer.baseAddress!, pointer.count)
+        }
+        guard result == 0 else { return nil }
+        let name = String(
+            decoding: buffer.prefix { $0 != 0 }.map { UInt8(bitPattern: $0) },
+            as: UTF8.self
+        )
+        return name.isEmpty ? nil : name
+    }
+
+    private static func threadState(_ state: Int32) -> String {
+        switch state {
+        case TH_STATE_RUNNING: "running"
+        case TH_STATE_STOPPED: "stopped"
+        case TH_STATE_WAITING: "waiting"
+        case TH_STATE_UNINTERRUPTIBLE: "uninterruptible"
+        case TH_STATE_HALTED: "halted"
+        default: "unknown"
+        }
+    }
+
+    private static func thermalState() -> String {
+        switch ProcessInfo.processInfo.thermalState {
+        case .nominal: "nominal"
+        case .fair: "fair"
+        case .serious: "serious"
+        case .critical: "critical"
+        @unknown default: "unknown"
+        }
+    }
+
+    private static func networkDiagnostics(
+        options: CrumbDiagnosticsOptions
+    ) -> CrumbNetworkDiagnostic {
+        // Connectivity is useful context, but it must never consume the report-time
+        // diagnostics budget. NWPathMonitor normally publishes immediately; when a
+        // device does not, preserve an honest `unknown` value rather than blocking.
+        let path = currentNetworkPath(timeout: min(options.timeout, 0.1))
+        let transport = path.map(networkTransport) ?? "unknown"
+        let health = options.healthCheckURL.map {
+            CrumbInfrastructureHealthProbe.capture(url: $0, timeout: options.timeout)
+        }
+        return CrumbNetworkDiagnostic(
+            status: path.map { $0.status == .satisfied ? "reachable" : "unreachable" } ?? "unknown",
+            transport: transport,
+            cellularGeneration: transport == "cellular" ? cellularGeneration() : nil,
+            isExpensive: path?.isExpensive ?? false,
+            isConstrained: path?.isConstrained ?? false,
+            healthCheck: health
+        )
+    }
+
+    private static func currentNetworkPath(timeout: TimeInterval) -> NWPath? {
+        let monitor = NWPathMonitor()
+        let result = LockedValue<NWPath>()
+        let semaphore = DispatchSemaphore(value: 0)
+        monitor.pathUpdateHandler = { path in
+            result.setIfEmpty(path)
+            semaphore.signal()
+        }
+        monitor.start(queue: DispatchQueue(label: "dev.crumb.network-probe"))
+        _ = semaphore.wait(timeout: .now() + timeout)
+        monitor.cancel()
+        return result.value
+    }
+
+    private static func networkTransport(_ path: NWPath) -> String {
+        if path.usesInterfaceType(.wifi) { return "wifi" }
+        if path.usesInterfaceType(.cellular) { return "cellular" }
+        if path.usesInterfaceType(.wiredEthernet) { return "ethernet" }
+        if path.usesInterfaceType(.loopback) { return "loopback" }
+        return "other"
+    }
+
+    private static func cellularGeneration() -> String? {
+        let technologies = CTTelephonyNetworkInfo()
+            .serviceCurrentRadioAccessTechnology
+            .map { Array($0.values) } ?? []
+        guard let technology = technologies.first else { return nil }
+        if #available(iOS 14.1, *),
+           technology == CTRadioAccessTechnologyNR || technology == CTRadioAccessTechnologyNRNSA {
+            return "5G"
+        }
+        if technology == CTRadioAccessTechnologyLTE { return "4G/LTE" }
+        if [CTRadioAccessTechnologyWCDMA, CTRadioAccessTechnologyHSDPA,
+            CTRadioAccessTechnologyHSUPA, CTRadioAccessTechnologyCDMAEVDORev0,
+            CTRadioAccessTechnologyCDMAEVDORevA, CTRadioAccessTechnologyCDMAEVDORevB,
+            CTRadioAccessTechnologyeHRPD].contains(technology) {
+            return "3G"
+        }
+        return "2G"
+    }
+
+}
+
+private final class LockedValue<Value>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: Value?
+
+    var value: Value? {
+        lock.lock()
+        defer { lock.unlock() }
+        return storage
+    }
+
+    func setIfEmpty(_ value: Value) {
+        lock.lock()
+        defer { lock.unlock() }
+        if storage == nil { storage = value }
+    }
+}
+#endif

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

@@ -0,0 +1,213 @@
+#if os(iOS)
+import CrumbCore
+import Foundation
+import OSLog
+
+enum OnDemandLogCollector {
+    private static let scanLimit = 2_000
+    private static let unifiedLogDeadline = DispatchTimeInterval.milliseconds(250)
+
+    static func capture(options: CrumbLogOptions) -> CrumbLogDiagnostic {
+        guard options.enabled else {
+            return CrumbLogDiagnostic(
+                status: .disabled,
+                sources: [],
+                entries: [],
+                truncated: false,
+                droppedEntryCount: 0,
+                failures: []
+            )
+        }
+
+        let capturedAt = Date()
+        let earliest = capturedAt.addingTimeInterval(-options.lookback)
+        var candidates: [CrumbLogEntry] = []
+        var sources: [String] = []
+        var failures: [String] = []
+        var droppedBeforeBounding = 0
+
+        if let unified = timeboxedUnifiedLogs(earliest: earliest) {
+            candidates.append(contentsOf: unified.entries)
+            droppedBeforeBounding += unified.dropped
+            if let failure = unified.failure {
+                failures.append(failure)
+            } else {
+                sources.append("os_log")
+            }
+        } else {
+            failures.append("os_log_unavailable:timeout")
+        }
+
+        if let provider = options.provider {
+            do {
+                candidates.append(contentsOf: try provider.recentLogs())
+                sources.append("host_provider")
+            } catch {
+                failures.append("host_provider_failed:\(String(describing: type(of: error)))")
+            }
+        }
+
+        let bounded = bound(
+            candidates,
+            capturedAt: capturedAt,
+            earliest: earliest,
+            options: options,
+            alreadyDropped: droppedBeforeBounding
+        )
+        let status: CrumbLogCaptureStatus
+        if !bounded.entries.isEmpty {
+            status = .captured
+        } else if !sources.isEmpty {
+            status = .empty
+        } else {
+            status = .unavailable
+        }
+
+        return CrumbLogDiagnostic(
+            status: status,
+            sources: Array(Set(sources)).sorted(),
+            entries: bounded.entries,
+            truncated: bounded.dropped > 0,
+            droppedEntryCount: bounded.dropped,
+            failures: failures
+        )
+    }
+
+    private static func timeboxedUnifiedLogs(earliest: Date) -> UnifiedLogCapture? {
+        let result = UnifiedLogCaptureBox()
+        let semaphore = DispatchSemaphore(value: 0)
+        DispatchQueue.global(qos: .userInitiated).async {
+            result.set(captureUnifiedLogs(earliest: earliest))
+            semaphore.signal()
+        }
+        guard semaphore.wait(timeout: .now() + unifiedLogDeadline) == .success else {
+            return nil
+        }
+        return result.value
+    }
+
+    private static func captureUnifiedLogs(earliest: Date) -> UnifiedLogCapture {
+        var entries: [CrumbLogEntry] = []
+        do {
+            let store = try OSLogStore(scope: .currentProcessIdentifier)
+            // Start at the newest entry and stop once the configured window is
+            // crossed. Forward enumeration from `earliest` can scan a large store
+            // before reaching the evidence the report actually keeps.
+            for case let entry as OSLogEntryLog in try store.getEntries(
+                with: .reverse,
+                at: nil,
+                matching: nil
+            ) {
+                guard entry.date >= earliest else { break }
+                entries.append(
+                    CrumbLogEntry(
+                        timestamp: entry.date,
+                        level: level(entry.level),
+                        source: "os_log",
+                        category: [entry.subsystem, entry.category]
+                            .filter { !$0.isEmpty }
+                            .joined(separator: "/"),
+                        message: entry.composedMessage
+                    )
+                )
+                if entries.count >= scanLimit {
+                    return UnifiedLogCapture(entries: entries, dropped: 1, failure: nil)
+                }
+            }
+            return UnifiedLogCapture(entries: entries, dropped: 0, failure: nil)
+        } catch {
+            return UnifiedLogCapture(
+                entries: [],
+                dropped: 0,
+                failure: "os_log_unavailable:\(String(describing: type(of: error)))"
+            )
+        }
+    }
+
+    private static func bound(
+        _ entries: [CrumbLogEntry],
+        capturedAt: Date,
+        earliest: Date,
+        options: CrumbLogOptions,
+        alreadyDropped: Int
+    ) -> (entries: [CrumbLogEntry], dropped: Int) {
+        let futureTolerance = capturedAt.addingTimeInterval(5)
+        let candidates = entries
+            .filter { $0.timestamp >= earliest && $0.timestamp <= futureTolerance }
+            .sorted { $0.timestamp > $1.timestamp }
+        var selected: [CrumbLogEntry] = []
+        var usedBytes = 0
+        var dropped = alreadyDropped
+
+        for entry in candidates {
+            guard selected.count < options.maximumEntries else {
+                dropped += 1
+                continue
+            }
+            let sanitized = CrumbLogEntry(
+                timestamp: entry.timestamp,
+                level: entry.level,
+                source: bounded(
+                    CrumbLogSanitizer.sanitize(entry.source).isEmpty
+                        ? "application"
+                        : CrumbLogSanitizer.sanitize(entry.source),
+                    length: 64
+                ),
+                category: bounded(CrumbLogSanitizer.sanitize(entry.category), length: 256),
+                message: bounded(CrumbLogSanitizer.sanitize(entry.message), length: 65_536)
+            )
+            let byteCount = sanitized.source.utf8.count
+                + sanitized.category.utf8.count
+                + sanitized.message.utf8.count
+                + 32
+            guard usedBytes + byteCount <= options.maximumBytes else {
+                dropped += 1
+                continue
+            }
+            selected.append(sanitized)
+            usedBytes += byteCount
+        }
+
+        return (selected.sorted { $0.timestamp < $1.timestamp }, dropped)
+    }
+
+    private static func bounded(_ value: String, length: Int) -> String {
+        String(value.prefix(length))
+    }
+
+    private static func level(_ value: OSLogEntryLog.Level) -> CrumbLogLevel {
+        switch value {
+        case .debug: .debug
+        case .info: .info
+        case .notice: .notice
+        case .error: .error
+        case .fault: .fault
+        case .undefined: .debug
+        @unknown default: .debug
+        }
+    }
+}
+
+private struct UnifiedLogCapture: Sendable {
+    let entries: [CrumbLogEntry]
+    let dropped: Int
+    let failure: String?
+}
+
+private final class UnifiedLogCaptureBox: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: UnifiedLogCapture?
+
+    var value: UnifiedLogCapture? {
+        lock.lock()
+        defer { lock.unlock() }
+        return storage
+    }
+
+    func set(_ value: UnifiedLogCapture) {
+        lock.lock()
+        storage = value
+        lock.unlock()
+    }
+}
+#endif

package/native/ios/packages/ios/Sources/CrumbUI/Resources/en.lproj/Localizable.strings

@@ -0,0 +1,75 @@
+/* English source catalog for the reporter flow. */
+"Report a problem" = "Report a problem";
+"Report a problem?" = "Report a problem?";
+"We noticed a shake on this screen." = "We noticed a shake on this screen.";
+"Report" = "Report";
+"Cancel" = "Cancel";
+"Review" = "Review";
+"Bug" = "Bug";
+"Feedback" = "Feedback";
+"Other" = "Other";
+"Problem description" = "Problem description";
+"What happened?" = "What happened?";
+"Your own words are the most useful part of the report." = "Your own words are the most useful part of the report.";
+"Gathering context" = "Gathering context";
+"Context ready" = "Context ready";
+"Collecting a small, on-demand diagnostic snapshot." = "Collecting a small, on-demand diagnostic snapshot.";
+"Masked screenshot preview" = "Masked screenshot preview";
+"Screenshot attached" = "Screenshot attached";
+"Screenshot attached. Text fields masked." = "Screenshot attached. Text fields masked.";
+"Screenshot attached. Text-field masking is off." = "Screenshot attached. Text-field masking is off.";
+"Screenshot · masked" = "Screenshot · masked";
+"Text fields masked" = "Text fields masked";
+"Text-field masking is off" = "Text-field masking is off";
+"Sensitive fields masked · tap to preview" = "Sensitive fields masked · tap to preview";
+"Tap to preview" = "Tap to preview";
+"Opens the screenshot preview" = "Opens the screenshot preview";
+"Remove" = "Remove";
+"Review report" = "Review report";
+"Add a description to continue." = "Add a description to continue.";
+"Finishing context collection…" = "Finishing context collection…";
+"Report context is ready" = "Report context is ready";
+"Couldn’t create draft" = "Couldn’t create draft";
+"The local report envelope could not be serialized." = "The local report envelope could not be serialized.";
+"OK" = "OK";
+"Discard this report?" = "Discard this report?";
+"Your description and category changes will be lost." = "Your description and category changes will be lost.";
+"Keep editing" = "Keep editing";
+"Discard report" = "Discard report";
+"Close" = "Close";
+"Back" = "Back";
+"Nothing has been sent yet. This is saved only on your phone." = "Nothing has been sent yet. This is saved only on your phone.";
+"Edit" = "Edit";
+"What’s attached" = "What’s attached";
+"Unavailable" = "Unavailable";
+"App release" = "App release";
+"Device" = "Device";
+"Device & OS" = "Device & OS";
+"Screen" = "Screen";
+"Network" = "Network";
+"Performance" = "Performance";
+"Recent logs" = "Recent logs";
+"%lld sanitized entry" = "%lld sanitized entry";
+"%lld sanitized entries" = "%lld sanitized entries";
+"See everything that’s attached ›" = "See everything that’s attached ›";
+"Hide technical detail" = "Hide technical detail";
+"Send report" = "Send report";
+"No passwords, card numbers, keystrokes or location are ever included." = "No passwords, card numbers, keystrokes or location are ever included.";
+"Screenshot on" = "Screenshot on";
+"Screenshot off" = "Screenshot off";
+"What’s attached · 21 items" = "What’s attached · 21 items";
+"Screen at the time" = "Screen at the time";
+"Memory & CPU" = "Memory & CPU";
+"Recent app logs" = "Recent app logs";
+"Not available" = "Not available";
+"3 items" = "3 items";
+"4 text fields hidden" = "4 text fields hidden";
+"Saving locally…" = "Saving locally…";
+"Saving report locally" = "Saving report locally";
+"Report saved" = "Report saved";
+"Safely queued on this device. You can close Crumb without losing it." = "Safely queued on this device. You can close Crumb without losing it.";
+"Done" = "Done";
+"Try again" = "Try again";
+"The on-device queue is full. No existing report was deleted." = "The on-device queue is full. No existing report was deleted.";
+"The report was not saved. Nothing was sent; please try again." = "The report was not saved. Nothing was sent; please try again.";
+"Couldn’t save report" = "Couldn’t save report";

package/native/ios/provenance.json

@@ -0,0 +1,8 @@
+{
+  "nativeVersion": "0.0.1-rc.4",
+  "PLCrashReporter": {
+    "version": "1.12.0",
+    "url": "https://github.com/microsoft/plcrashreporter/releases/download/1.12.0/PLCrashReporter-Static-1.12.0.xcframework.zip",
+    "sha256": "9e7124d63316a5e354fdeec631a3d669b1eaa533d3767a0089a05ab0eedc02b5"
+  }
+}

package/nitrogen/generated/android/c++/JHybridCrumbReactNativeSpec.cpp

@@ -50,6 +50,15 @@ namespace margelo::nitro::crumbsdk_reactnative {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* configurationJson */)>("start");
     method(_javaPart, jni::make_jstring(configurationJson));
   }
+  void JHybridCrumbReactNativeSpec::setScreenContext(const std::string& screenJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* screenJson */)>("setScreenContext");
+    method(_javaPart, jni::make_jstring(screenJson));
+  }
+  bool JHybridCrumbReactNativeSpec::canCollectLogs() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("canCollectLogs");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
   std::shared_ptr<Promise<bool>> JHybridCrumbReactNativeSpec::installReporter() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("installReporter");
     auto __result = method(_javaPart);
@@ -66,9 +75,9 @@ namespace margelo::nitro::crumbsdk_reactnative {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<bool>> JHybridCrumbReactNativeSpec::show() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("show");
-    auto __result = method(_javaPart);
+  std::shared_ptr<Promise<bool>> JHybridCrumbReactNativeSpec::show(const std::string& screenJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* screenJson */)>("show");
+    auto __result = method(_javaPart, jni::make_jstring(screenJson));
     return [&]() {
       auto __promise = Promise<bool>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
@@ -90,5 +99,25 @@ namespace margelo::nitro::crumbsdk_reactnative {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("clearLogs");
     method(_javaPart);
   }
+  void JHybridCrumbReactNativeSpec::recordJavaScriptCrash(const std::string& recordJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* recordJson */)>("recordJavaScriptCrash");
+    method(_javaPart, jni::make_jstring(recordJson));
+  }
+  std::shared_ptr<Promise<bool>> JHybridCrumbReactNativeSpec::recoverJavaScriptCrashes() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("recoverJavaScriptCrashes");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::crumbsdk_reactnative

package/nitrogen/generated/android/c++/JHybridCrumbReactNativeSpec.hpp

@@ -55,10 +55,14 @@ namespace margelo::nitro::crumbsdk_reactnative {
   public:
     // Methods
     void start(const std::string& configurationJson) override;
+    void setScreenContext(const std::string& screenJson) override;
+    bool canCollectLogs() override;
     std::shared_ptr<Promise<bool>> installReporter() override;
-    std::shared_ptr<Promise<bool>> show() override;
+    std::shared_ptr<Promise<bool>> show(const std::string& screenJson) override;
     void addLog(const std::string& entryJson) override;
     void clearLogs() override;
+    void recordJavaScriptCrash(const std::string& recordJson) override;
+    std::shared_ptr<Promise<bool>> recoverJavaScriptCrashes() override;
 
   private:
     jni::global_ref<JHybridCrumbReactNativeSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/crumbsdk/reactnative/HybridCrumbReactNativeSpec.kt

@@ -34,13 +34,21 @@ abstract class HybridCrumbReactNativeSpec: HybridObject() {
   @Keep
   abstract fun start(configurationJson: String): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun setScreenContext(screenJson: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun canCollectLogs(): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun installReporter(): Promise<Boolean>
   
   @DoNotStrip
   @Keep
-  abstract fun show(): Promise<Boolean>
+  abstract fun show(screenJson: String): Promise<Boolean>
   
   @DoNotStrip
   @Keep
@@ -49,6 +57,14 @@ abstract class HybridCrumbReactNativeSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun clearLogs(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun recordJavaScriptCrash(recordJson: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun recoverJavaScriptCrashes(): Promise<Boolean>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {