@npaw/forge-react-native 9.6.1

package/ios/ForgeApple/Sources/NPAWForgeCore/NativeUniFFIRuntime.swift

@@ -0,0 +1,594 @@
+/**
+ * Copyright (C) NPAW - All Rights Reserved
+ *
+ * This source code is protected under international copyright law. All rights
+ * reserved and protected by the copyright holders.
+ * This file is confidential and only available to authorized individuals with the
+ * permission of the copyright holders. If you encounter this file and do not have
+ * permission, please contact the copyright holders and delete this file.
+ *
+ *
+ * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
+ * @description: Production Swift runtime adapter backed by generated UniFFI bindings.
+ */
+
+import Foundation
+
+#if FORGE_HAS_UNIFFI
+#if canImport(ForgeKernelUniFFI)
+import ForgeKernelUniFFI
+#endif
+
+final class UniFFIForgeRuntime: ForgeRuntime {
+    private let bridge: ForgeRuntimeBridge
+    private let callbackLock = NSLock()
+    private var contentMetadataProviders: [Int64: UniFFIContentMetadataProvider] = [:]
+    private var videoPreSendHooks: [Int64: UniFFIVideoPreSendHook] = [:]
+    private var sessionPreSendHook: UniFFISessionPreSendHook?
+    private var capturePlanListener: UniFFICapturePlanListener?
+
+    init(config: ForgeAppleConfig) {
+        bridge = ForgeRuntimeBridge(config: AppleRuntimeConfig(
+            accountCode: config.accountCode,
+            pluginVersion: config.pluginVersion,
+            appName: config.appName,
+            buildVariant: config.buildVariant,
+            appReleaseVersion: config.appReleaseVersion,
+            lmaEndpoint: config.lmaEndpoint,
+            analyticsUserAgent: config.analyticsUserAgent,
+            allowLocalHttp: config.allowLocalHttp,
+            logLevel: config.logLevel.wireName,
+            preSessionEventPolicy: ApplePreSessionEventPolicy(
+                processEventsBeforeSessionStart: config.processEventsBeforeSessionStart,
+                queueLimitEvents: UInt64(max(0, config.preSessionEventQueueLimitEvents)),
+                maxAgeMs: u64(config.preSessionEventQueueMaxAgeMs)
+            )
+        ))
+    }
+
+    func start() -> ForgeOutcome {
+        outcome(bridge.start(nowMs: 0))
+    }
+
+    func setLogLevel(_ level: ForgeLogLevel) -> ForgeOutcome {
+        outcome(bridge.setLogLevel(logLevel: level.wireName))
+    }
+
+    func createVideoView(timestampMs: Int64, options: VideoOptions) -> RuntimeVideoView {
+        RuntimeVideoView(id: Int64(clamping: bridge.createVideoView(
+            nowMs: u64(timestampMs),
+            options: AppleVideoOptions(
+                joinTimeCalculationMode: options.joinTimeCalculationMode?.rawValue,
+                adJoinFromAdBreakStart: options.adJoinFromAdBreakStart,
+                adConnectedRequiresAdJoin: options.adConnectedRequiresAdJoin,
+                contentIsLiveNoSeek: options.contentIsLiveNoSeek,
+                ignorePauseSmallEvents: options.ignorePauseSmallEvents
+            )
+        )))
+    }
+
+    func recordEvent(_ event: ForgeRecordedEvent) -> ForgeOutcome {
+        outcome(bridge.recordSessionEvent(
+            eventName: event.eventName,
+            timemarkMs: u64(event.timestampMs),
+            params: event.payload
+        ))
+    }
+
+    func recordIdentityEvent(kind: String, timemarkMs: Int64, fields: [String: String]) -> ForgeOutcome {
+        outcome(bridge.recordIdentityEvent(
+            kind: kind,
+            timemarkMs: u64(timemarkMs),
+            fields: fields
+        ))
+    }
+
+    func recordApplicationForeground(_ foreground: Bool, timestampMs: Int64) -> ForgeOutcome {
+        outcome(bridge.recordApplicationForeground(foreground: foreground, timemarkMs: u64(timestampMs)))
+    }
+
+    func recordNetworkEvent(_ record: NetworkRequestRecord) -> ForgeOutcome {
+        outcome(bridge.recordNetworkEvent(observation: AppleNetworkObservation(
+            eventId: record.eventId,
+            source: record.source.rawValue,
+            targetUrl: record.targetUrl,
+            method: record.method,
+            timemarkMs: u64(record.timestampMs),
+            durationMs: u64(record.durationMs),
+            responseStatusCode: UInt16(clamping: record.responseStatusCode),
+            outcome: record.outcome.rawValue,
+            responseStatusText: record.responseStatusText,
+            errorMessage: record.errorMessage,
+            traceparent: record.traceparent,
+            dnsDurationMs: record.dnsDurationMs.map(u64),
+            connectDurationMs: record.connectDurationMs.map(u64),
+            sslDurationMs: record.sslDurationMs.map(u64),
+            requestDurationMs: record.requestDurationMs.map(u64),
+            timeToFirstByteMs: record.timeToFirstByteMs.map(u64),
+            responseDownloadDurationMs: record.responseDownloadDurationMs.map(u64),
+            redirectDurationMs: record.redirectDurationMs.map(u64),
+            redirectCount: record.redirectCount.map(u64),
+            protocol: record.networkProtocol,
+            requestBytes: record.requestBytes.map(u64),
+            responseBytes: record.responseBytes.map(u64),
+            requestQuery: record.requestQuery.isEmpty ? nil : record.requestQuery,
+            requestHeaders: record.requestHeaders.isEmpty ? nil : record.requestHeaders,
+            responseHeaders: record.responseHeaders.isEmpty ? nil : record.responseHeaders
+        )))
+    }
+
+    func recordPlayerEvent(
+        view: RuntimeVideoView,
+        event: PlayerEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: PlayerMetadataSnapshot
+    ) -> ForgeOutcome {
+        outcome(bridge.recordPlayerEvent(
+            viewId: u64(view.id),
+            event: appleVideoEvent(event),
+            timestamp: AppleSemanticTimestamp(timemarkMs: u64(timemarkMs), elapsedRealtimeMs: u64(elapsedRealtimeMs)),
+            overridesJson: options.overridesJson,
+            metadata: appleContentMetadata(metadata)
+        ))
+    }
+
+    func recordAdEvent(
+        view: RuntimeVideoView,
+        event: AdEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: AdMetadataSnapshot,
+        adapterVersion: String?
+    ) -> ForgeOutcome {
+        outcome(bridge.recordAdEvent(
+            viewId: u64(view.id),
+            event: appleAdEvent(event),
+            timestamp: AppleSemanticTimestamp(timemarkMs: u64(timemarkMs), elapsedRealtimeMs: u64(elapsedRealtimeMs)),
+            overridesJson: options.overridesJson,
+            metadata: appleAdMetadata(metadata),
+            adapterVersion: adapterVersion
+        ))
+    }
+
+    func registerContentMetadataProvider(view: RuntimeVideoView, provider: RuntimeContentMetadataProvider?) -> ForgeOutcome {
+        if let provider {
+            let callback = UniFFIContentMetadataProvider(provider: provider)
+            let result = outcome(bridge.setContentMetadataProvider(viewId: u64(view.id), provider: callback))
+            if result.isAccepted {
+                callbackLock.lock()
+                contentMetadataProviders[view.id] = callback
+                callbackLock.unlock()
+            }
+            return result
+        }
+
+        let result = outcome(bridge.clearContentMetadataProvider(viewId: u64(view.id)))
+        if result.isAccepted {
+            callbackLock.lock()
+            contentMetadataProviders.removeValue(forKey: view.id)
+            callbackLock.unlock()
+        }
+        return result
+    }
+
+    func registerVideoPreSendHook(view: RuntimeVideoView, hook: RuntimeVideoPreSendHook?) -> ForgeOutcome {
+        if let hook {
+            let callback = UniFFIVideoPreSendHook(view: view, hook: hook)
+            let result = outcome(bridge.setVideoPreSendHook(viewId: u64(view.id), hook: callback))
+            if result.isAccepted {
+                callbackLock.lock()
+                videoPreSendHooks[view.id] = callback
+                callbackLock.unlock()
+            }
+            return result
+        }
+
+        let result = outcome(bridge.clearVideoPreSendHook(viewId: u64(view.id)))
+        if result.isAccepted {
+            callbackLock.lock()
+            videoPreSendHooks.removeValue(forKey: view.id)
+            callbackLock.unlock()
+        }
+        return result
+    }
+
+    func registerSessionPreSendHook(_ hook: RuntimeSessionPreSendHook?) -> ForgeOutcome {
+        if let hook {
+            let callback = UniFFISessionPreSendHook(hook: hook)
+            let result = outcome(bridge.setSessionPreSendHook(hook: callback))
+            if result.isAccepted {
+                callbackLock.lock()
+                sessionPreSendHook = callback
+                callbackLock.unlock()
+            }
+            return result
+        }
+
+        let result = outcome(bridge.clearSessionPreSendHook())
+        if result.isAccepted {
+            callbackLock.lock()
+            sessionPreSendHook = nil
+            callbackLock.unlock()
+        }
+        return result
+    }
+
+    func setCapturePlanListener(_ listener: ((ForgeCapturePlan) -> Void)?) -> ForgeOutcome {
+        if let listener {
+            let callback = UniFFICapturePlanListener(callback: listener)
+            // Registering retains the wrapper first so the synchronous
+            // latest-plan replay from the bridge is delivered through a
+            // wrapper the runtime keeps alive.
+            callbackLock.lock()
+            capturePlanListener = callback
+            callbackLock.unlock()
+            let result = outcome(bridge.setCapturePlanListener(listener: callback))
+            if !result.isAccepted {
+                callbackLock.lock()
+                capturePlanListener = nil
+                callbackLock.unlock()
+            }
+            return result
+        }
+
+        let result = outcome(bridge.clearCapturePlanListener())
+        if result.isAccepted {
+            callbackLock.lock()
+            capturePlanListener = nil
+            callbackLock.unlock()
+        }
+        return result
+    }
+
+    func capturePlan() -> ForgeCapturePlan? {
+        bridge.capturePlan().map(forgeCapturePlan)
+    }
+
+    func destroyVideoView(_ view: RuntimeVideoView) -> ForgeOutcome {
+        // Mirror the Android destroyVideoView contract: release both per-view
+        // callback registrations (bridge side and Swift-retained wrappers) so
+        // destroyed views never accumulate callback state across the app lifetime.
+        _ = bridge.clearContentMetadataProvider(viewId: u64(view.id))
+        _ = bridge.clearVideoPreSendHook(viewId: u64(view.id))
+        callbackLock.lock()
+        contentMetadataProviders.removeValue(forKey: view.id)
+        videoPreSendHooks.removeValue(forKey: view.id)
+        callbackLock.unlock()
+        return .accepted
+    }
+
+    func snapshotEvents() -> [ForgeRecordedEvent] {
+        bridge.snapshotEvents().map(recordedEvent)
+    }
+
+    func destroy() -> ForgeOutcome {
+        let result = outcome(bridge.destroy())
+        _ = bridge.clearCapturePlanListener()
+        callbackLock.lock()
+        contentMetadataProviders.removeAll()
+        videoPreSendHooks.removeAll()
+        sessionPreSendHook = nil
+        capturePlanListener = nil
+        callbackLock.unlock()
+        return result
+    }
+}
+
+private func outcome(_ outcome: AppleBindingOutcome) -> ForgeOutcome {
+    switch outcome.status {
+    case .accepted:
+        return .accepted
+    case .deferred:
+        return .deferred
+    case .dropped:
+        return .dropped
+    case .ignoredDuplicate:
+        return .ignoredDuplicate
+    case .ignoredBeforeSessionStart:
+        return .ignoredBeforeSessionStart
+    case .ignoredInvalidState:
+        return .ignoredInvalidState
+    case .failedWithDiagnostic:
+        return .failedWithDiagnostic(outcome.reason ?? "native_runtime_failed")
+    }
+}
+
+private func appleVideoEvent(_ event: PlayerEvent) -> AppleVideoEvent {
+    switch event {
+    case .initEvent: return .`init`
+    case .start: return .start
+    case .join: return .join
+    case .pause: return .pause
+    case .resume: return .resume
+    case .seekBegin: return .seekBegin
+    case .seekEnd: return .seekEnd
+    case .bufferBegin: return .bufferBegin
+    case .bufferEnd: return .bufferEnd
+    case .stop: return .stop
+    case .error: return .error
+    case .fatalError: return .fatalError
+    case .destroy: return .destroy
+    case .customVideoEvent: return .custom
+    case .customVideoEventEnd: return .customEnd
+    case .metadataUpdate: return .metadataUpdate
+    }
+}
+
+private func appleAdEvent(_ event: AdEvent) -> AppleAdEvent {
+    switch event {
+    case .manifest: return .manifest
+    case .breakStart: return .breakStart
+    case .adInit: return .`init`
+    case .start: return .start
+    case .join: return .join
+    case .pause: return .pause
+    case .resume: return .resume
+    case .bufferBegin: return .bufferBegin
+    case .bufferEnd: return .bufferEnd
+    case .quartile: return .quartile
+    case .click: return .click
+    case .skip: return .skip
+    case .stop: return .stop
+    case .error: return .error
+    case .fatalError: return .fatalError
+    case .breakStop: return .breakStop
+    }
+}
+
+private func appleContentMetadata(_ metadata: PlayerMetadataSnapshot) -> AppleContentMetadata {
+    AppleContentMetadata(
+        player: metadata.playerName,
+        playerVersion: metadata.playerVersion,
+        resource: metadata.resourceUrl,
+        parsedResource: metadata.parsedResource,
+        title: metadata.title,
+        program: metadata.program,
+        transactionCode: nil,
+        contentId: nil,
+        contentType: appleContentType(metadata.contentType),
+        playheadMs: metadata.playheadMs.map(u64),
+        durationMs: metadata.durationMs.map(u64),
+        bitrate: metadata.bitrate,
+        throughput: nil,
+        totalBytes: nil,
+        droppedFrames: nil,
+        rendition: metadata.rendition,
+        videoCodec: metadata.videoCodec,
+        audioCodec: metadata.audioCodec,
+        codecProfile: metadata.codecProfile,
+        containerFormat: metadata.containerFormat,
+        legacyCustomDimensions: metadata.legacyCustomDimensions.isEmpty
+            ? nil : metadata.legacyCustomDimensions,
+        customDimensions: metadata.customDimensions.isEmpty
+            ? nil : metadata.customDimensions,
+        customMetrics: metadata.customMetrics.isEmpty
+            ? nil : metadata.customMetrics,
+        errorCode: metadata.errorCode,
+        errorMessage: metadata.errorMessage,
+        errorMetadata: metadata.errorMetadata,
+        errorLevel: metadata.errorLevel,
+        forceInit: metadata.forceInit,
+        convertFromBuffer: metadata.convertFromBuffer,
+        convertFromSeek: metadata.convertFromSeek,
+        customEventJson: metadata.customEvent.flatMap(customEventJson),
+        // Rust fills only unset typed fields from this overlay, so typed
+        // snapshot facts always win over extraParams keys.
+        extraParams: metadata.extraParams.isEmpty ? nil : metadata.extraParams
+    )
+}
+
+private func appleMetadataSnapshot(_ snapshot: MetadataSnapshot) -> AppleMetadataSnapshot {
+    AppleMetadataSnapshot(
+        content: appleContentMetadata(snapshot.content),
+        qos: snapshot.qos.map(appleQosSnapshot)
+    )
+}
+
+private func appleQosSnapshot(_ snapshot: QosSnapshot) -> AppleQosSnapshot {
+    AppleQosSnapshot(
+        throughput: snapshot.throughput,
+        fps: snapshot.fps,
+        latency: snapshot.latency,
+        playrate: snapshot.playrate,
+        droppedFrames: snapshot.droppedFrames.map { UInt64(clamping: $0) },
+        totalBytes: snapshot.totalBytes,
+        packetLoss: nil,
+        packetSent: nil,
+        droppedPackets: nil,
+        lostPackets: nil,
+        multicastAffectionTimeMs: nil
+    )
+}
+
+private func appleAdMetadata(_ metadata: AdMetadataSnapshot) -> AppleAdMetadata {
+    AppleAdMetadata(
+        creativeId: metadata.creativeId ?? metadata.adId,
+        adUrl: metadata.adUrl,
+        adTitle: metadata.adTitle,
+        adDurationMs: metadata.adDurationMs.map(u64),
+        adPlayheadMs: metadata.adPlayheadMs.map(u64),
+        adBitrate: metadata.adBitrate,
+        position: metadata.position.map(appleAdPosition),
+        skippable: nil,
+        quartile: metadata.quartile.map { UInt32(clamping: $0) },
+        insertionType: appleAdInsertionType(metadata.insertionType),
+        viewability: metadata.viewability.map {
+            AppleAdViewabilitySample(
+                maxIntervalMs: $0.maxIntervalMs,
+                viewedDurationMs: $0.viewedDurationMs.map(u64)
+            )
+        },
+        errorCode: metadata.errorCode,
+        errorMessage: metadata.errorMessage,
+        errorMetadata: metadata.errorMetadata,
+        errorLevel: metadata.errorLevel,
+        // Rust fills only unset typed fields from this overlay, so typed
+        // snapshot facts always win over extraParams keys.
+        extraParams: metadata.extraParams.isEmpty ? nil : metadata.extraParams
+    )
+}
+
+private func forgeCapturePlan(_ plan: AppleCapturePlan) -> ForgeCapturePlan {
+    // One-to-one flat passthrough into the shared factory so the typed plan
+    // (including the F3 sections knobs) cannot drift from the UniFFI shape.
+    ForgeCapturePlan.fromUniFFIFlat(
+        planSeq: plan.planSeq,
+        bits: plan.bits,
+        configVersion: plan.configVersion,
+        focusDwellThresholdMs: plan.focusDwellThresholdMs,
+        focusDedupeMs: plan.focusDedupeMs,
+        focusRepeatUnchangedDwell: plan.focusRepeatUnchangedDwell,
+        maxTargetTextLength: plan.maxTargetTextLength,
+        maxPayloadFields: plan.maxPayloadFields,
+        joinMethod: plan.joinMethod,
+        seekHeuristicEnabled: plan.seekHeuristicEnabled,
+        seekJumpThresholdMs: plan.seekJumpThresholdMs,
+        metadataSamplingMs: plan.metadataSamplingMs,
+        sectionsVisibilityThresholdPct: plan.sectionsVisibilityThresholdPct,
+        sectionsImpressionMinVisibleMs: plan.sectionsImpressionMinVisibleMs,
+        sectionsDwellMs: plan.sectionsDwellMs,
+        sectionsMaxTrackedItems: plan.sectionsMaxTrackedItems,
+        sectionsMaxSections: plan.sectionsMaxSections,
+        sectionsSectionSelector: plan.sectionsSectionSelector,
+        sectionsItemSelector: plan.sectionsItemSelector,
+        sectionsSectionNativeIds: plan.sectionsSectionNativeIds,
+        sectionsItemNativeIds: plan.sectionsItemNativeIds,
+        sectionsNameFrom: plan.sectionsNameFrom,
+        targetDataAttributes: plan.targetDataAttributes,
+        attributionExtraQueryKeys: plan.attributionExtraQueryKeys,
+        attributionIncludeLandingUrl: plan.attributionIncludeLandingUrl,
+        attributionDeriveFromDeepLinks: plan.attributionDeriveFromDeepLinks,
+        attributionInstallReferrerEnabled: plan.attributionInstallReferrerEnabled,
+        hash: plan.hash
+    )
+}
+
+private func recordedEvent(_ event: AppleRuntimeEventSnapshot) -> ForgeRecordedEvent {
+    ForgeRecordedEvent(
+        eventName: event.eventName,
+        timestampMs: i64(event.timemarkMs),
+        payload: event.payload,
+        urgent: event.eventName == "sessionstart" || event.eventName == "sessionstop",
+        viewKey: event.viewId.map { String($0) }
+    )
+}
+
+private func appleContentType(_ contentType: ContentType) -> AppleContentType {
+    switch contentType {
+    case .live: return .live
+    case .vod: return .vod
+    case .audio: return .audio
+    case .unknown: return .unknown
+    }
+}
+
+private func appleAdPosition(_ position: AdPosition) -> AppleAdPosition {
+    switch position {
+    case .pre: return .pre
+    case .mid: return .mid
+    case .post: return .post
+    case .unknown: return .unknown
+    }
+}
+
+private func appleAdInsertionType(_ insertionType: AdInsertionType) -> AppleAdInsertionType {
+    switch insertionType {
+    case .clientSide: return .clientSide
+    case .serverSide: return .serverSide
+    case .unknown: return .unknown
+    }
+}
+
+private func customEventJson(_ payload: CustomVideoEventPayload) -> String? {
+    var object: [String: Any] = [
+        "name": payload.name,
+        "dimensions": payload.dimensions,
+        "values": payload.values,
+        "topLevel": payload.topLevel,
+        "hasEndDatetime": payload.hasEndDatetime,
+    ]
+    if let streamKey = payload.streamKey {
+        object["streamKey"] = streamKey
+    }
+    guard JSONSerialization.isValidJSONObject(object),
+          let data = try? JSONSerialization.data(withJSONObject: object, options: [.sortedKeys]) else {
+        return nil
+    }
+    return String(data: data, encoding: .utf8)
+}
+
+private func u64(_ value: Int64) -> UInt64 {
+    UInt64(value < 0 ? 0 : value)
+}
+
+private func i64(_ value: UInt64) -> Int64 {
+    value > UInt64(Int64.max) ? Int64.max : Int64(value)
+}
+
+private final class UniFFIContentMetadataProvider: AppleContentMetadataProvider, @unchecked Sendable {
+    private weak var provider: RuntimeContentMetadataProvider?
+
+    init(provider: RuntimeContentMetadataProvider) {
+        self.provider = provider
+    }
+
+    func metadataSnapshot(viewId: UInt64, timestamp: AppleSemanticTimestamp) -> AppleMetadataSnapshot? {
+        provider?
+            .metadataSnapshot(
+                timemarkMs: i64(timestamp.timemarkMs),
+                elapsedRealtimeMs: i64(timestamp.elapsedRealtimeMs)
+            )
+            .map(appleMetadataSnapshot)
+    }
+}
+
+private final class UniFFIVideoPreSendHook: AppleVideoPreSendHook, @unchecked Sendable {
+    private let view: RuntimeVideoView
+    private let hook: RuntimeVideoPreSendHook
+
+    init(view: RuntimeVideoView, hook: RuntimeVideoPreSendHook) {
+        self.view = view
+        self.hook = hook
+    }
+
+    func willSend(eventName: String, viewId: UInt64, serviceName: String, params: [String: String]) -> [String: String] {
+        var mutableParams = params
+        hook.willSendRequest(
+            eventName: eventName,
+            view: view.id == i64(viewId) ? view : RuntimeVideoView(id: i64(viewId)),
+            serviceName: serviceName,
+            params: &mutableParams
+        )
+        return mutableParams
+    }
+}
+
+private final class UniFFISessionPreSendHook: AppleSessionPreSendHook, @unchecked Sendable {
+    private let hook: RuntimeSessionPreSendHook
+
+    init(hook: RuntimeSessionPreSendHook) {
+        self.hook = hook
+    }
+
+    func willSend(serviceName: String, params: [String: String]) -> [String: String] {
+        var mutableParams = params
+        hook.willSendRequest(serviceName: serviceName, params: &mutableParams)
+        return mutableParams
+    }
+}
+
+private final class UniFFICapturePlanListener: AppleCapturePlanListener, @unchecked Sendable {
+    private let callback: (ForgeCapturePlan) -> Void
+
+    init(callback: @escaping (ForgeCapturePlan) -> Void) {
+        self.callback = callback
+    }
+
+    func onPlan(plan: AppleCapturePlan) {
+        callback(forgeCapturePlan(plan))
+    }
+}
+#endif