@npaw/forge-react-native 9.6.1

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

@@ -0,0 +1,291 @@
+/**
+ * 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: Apple runtime abstraction that the Swift facade uses to reach the Rust core.
+ */
+
+import Foundation
+
+public struct RuntimeVideoView: Equatable {
+    public let id: Int64
+
+    public init(id: Int64) {
+        self.id = id
+    }
+}
+
+public struct ForgeRecordedEvent: Equatable {
+    public let eventName: String
+    public let timestampMs: Int64
+    public let payload: [String: String]
+    public let urgent: Bool
+    public let viewKey: String?
+
+    public init(
+        eventName: String,
+        timestampMs: Int64,
+        payload: [String: String],
+        urgent: Bool = false,
+        viewKey: String? = nil
+    ) {
+        self.eventName = eventName
+        self.timestampMs = timestampMs
+        self.payload = payload
+        self.urgent = urgent
+        self.viewKey = viewKey
+    }
+}
+
+public protocol RuntimeContentMetadataProvider: AnyObject {
+    func metadataSnapshot(timemarkMs: Int64, elapsedRealtimeMs: Int64) -> MetadataSnapshot?
+}
+
+public protocol RuntimeVideoPreSendHook: AnyObject {
+    func willSendRequest(
+        eventName: String,
+        view: RuntimeVideoView,
+        serviceName: String,
+        params: inout [String: String]
+    )
+}
+
+public protocol RuntimeSessionPreSendHook: AnyObject {
+    func willSendRequest(serviceName: String, params: inout [String: String])
+}
+
+public protocol ForgeRuntime: AnyObject {
+    func start() -> ForgeOutcome
+    func setLogLevel(_ level: ForgeLogLevel) -> ForgeOutcome
+    func createVideoView(timestampMs: Int64, options: VideoOptions) -> RuntimeVideoView
+    func recordEvent(_ event: ForgeRecordedEvent) -> ForgeOutcome
+    /// Records a typed identity transition (`loginSuccess`, `loginFailed`,
+    /// `logout`, `profileCreated`, `profileSelected`, `profileDeleted`). The
+    /// kernel consumes the recognized fields (`userId`, `profileId`,
+    /// `profileType`, `method`, `errorCode`, `reason`, `userType`), forwards
+    /// the rest as extra session-event params, and emits the taxonomy event.
+    func recordIdentityEvent(kind: String, timemarkMs: Int64, fields: [String: String]) -> ForgeOutcome
+    func recordApplicationForeground(_ foreground: Bool, timestampMs: Int64) -> ForgeOutcome
+    func recordNetworkEvent(_ record: NetworkRequestRecord) -> ForgeOutcome
+    func recordPlayerEvent(
+        view: RuntimeVideoView,
+        event: PlayerEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: PlayerMetadataSnapshot
+    ) -> ForgeOutcome
+    func recordAdEvent(
+        view: RuntimeVideoView,
+        event: AdEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: AdMetadataSnapshot,
+        adapterVersion: String?
+    ) -> ForgeOutcome
+    func registerContentMetadataProvider(view: RuntimeVideoView, provider: RuntimeContentMetadataProvider?) -> ForgeOutcome
+    func registerVideoPreSendHook(view: RuntimeVideoView, hook: RuntimeVideoPreSendHook?) -> ForgeOutcome
+    func registerSessionPreSendHook(_ hook: RuntimeSessionPreSendHook?) -> ForgeOutcome
+    func destroyVideoView(_ view: RuntimeVideoView) -> ForgeOutcome
+    func snapshotEvents() -> [ForgeRecordedEvent]
+    func destroy() -> ForgeOutcome
+    /// Registers (or clears with `nil`) the kernel capture-plan observer. The
+    /// latest plan is replayed to a late-registered listener when available.
+    func setCapturePlanListener(_ listener: ((ForgeCapturePlan) -> Void)?) -> ForgeOutcome
+    /// Latest kernel-emitted capture plan, or `nil` before the first emission.
+    func capturePlan() -> ForgeCapturePlan?
+}
+
+/// Additive defaults so existing `ForgeRuntime` conformances (including the
+/// non-native fallback) keep compiling; runtimes without a kernel capture
+/// plan simply never deliver one and bindings stay on local options only.
+public extension ForgeRuntime {
+    func setCapturePlanListener(_ listener: ((ForgeCapturePlan) -> Void)?) -> ForgeOutcome { .accepted }
+    func capturePlan() -> ForgeCapturePlan? { nil }
+    /// Additive default: runtimes without kernel identity support report the
+    /// capability gap instead of silently accepting the transition.
+    func recordIdentityEvent(kind: String, timemarkMs: Int64, fields: [String: String]) -> ForgeOutcome { .unsupportedCapability }
+}
+
+public protocol ForgeRuntimeFactory: AnyObject {
+    func create(config: ForgeAppleConfig, services: ForgeAppleServices) -> ForgeRuntime
+}
+
+public final class UnavailableForgeRuntime: ForgeRuntime {
+    private let reason: String
+
+    public init(reason: String) {
+        self.reason = reason
+    }
+
+    public func start() -> ForgeOutcome { failed() }
+    public func setLogLevel(_ level: ForgeLogLevel) -> ForgeOutcome { .accepted }
+    public func createVideoView(timestampMs: Int64, options: VideoOptions) -> RuntimeVideoView { RuntimeVideoView(id: -1) }
+    public func recordEvent(_ event: ForgeRecordedEvent) -> ForgeOutcome { failed() }
+    public func recordIdentityEvent(kind: String, timemarkMs: Int64, fields: [String: String]) -> ForgeOutcome { failed() }
+    public func recordApplicationForeground(_ foreground: Bool, timestampMs: Int64) -> ForgeOutcome { failed() }
+    public func recordNetworkEvent(_ record: NetworkRequestRecord) -> ForgeOutcome { failed() }
+    public func recordPlayerEvent(
+        view: RuntimeVideoView,
+        event: PlayerEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: PlayerMetadataSnapshot
+    ) -> ForgeOutcome { failed() }
+    public func recordAdEvent(
+        view: RuntimeVideoView,
+        event: AdEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: AdMetadataSnapshot,
+        adapterVersion: String?
+    ) -> ForgeOutcome { failed() }
+    public func registerContentMetadataProvider(view: RuntimeVideoView, provider: RuntimeContentMetadataProvider?) -> ForgeOutcome { .accepted }
+    public func registerVideoPreSendHook(view: RuntimeVideoView, hook: RuntimeVideoPreSendHook?) -> ForgeOutcome { .accepted }
+    public func registerSessionPreSendHook(_ hook: RuntimeSessionPreSendHook?) -> ForgeOutcome { .accepted }
+    public func destroyVideoView(_ view: RuntimeVideoView) -> ForgeOutcome { .accepted }
+    public func snapshotEvents() -> [ForgeRecordedEvent] { [] }
+    public func destroy() -> ForgeOutcome { .accepted }
+
+    private func failed() -> ForgeOutcome {
+        .failedWithDiagnostic(reason)
+    }
+}
+
+public final class NativeForgeRuntimeFactory: ForgeRuntimeFactory {
+    public init() {}
+
+    public func create(config: ForgeAppleConfig, services: ForgeAppleServices) -> ForgeRuntime {
+        #if FORGE_HAS_UNIFFI
+        return UniFFIForgeRuntime(config: config)
+        #else
+        UnavailableForgeRuntime(reason: "native_runtime_unavailable")
+        #endif
+    }
+}
+
+public final class RecordingForgeRuntime: ForgeRuntime {
+    public private(set) var events: [ForgeRecordedEvent] = []
+    public private(set) var identityEvents: [(kind: String, timemarkMs: Int64, fields: [String: String])] = []
+    public private(set) var playerEvents: [(RuntimeVideoView, PlayerEvent, PlayerMetadataSnapshot)] = []
+    public private(set) var playerEventTimestamps: [(timemarkMs: Int64, elapsedRealtimeMs: Int64)] = []
+    public private(set) var playerEventOptions: [VideoOptions] = []
+    public private(set) var adEvents: [(RuntimeVideoView, AdEvent, AdMetadataSnapshot)] = []
+    public private(set) var adEventTimestamps: [(timemarkMs: Int64, elapsedRealtimeMs: Int64)] = []
+    public private(set) var networkEvents: [NetworkRequestRecord] = []
+    public private(set) var createdVideoTimestamps: [Int64] = []
+    public private(set) var contentMetadataProviders: [Int64: RuntimeContentMetadataProvider] = [:]
+    public private(set) var videoPreSendHooks: [Int64: RuntimeVideoPreSendHook] = [:]
+    public private(set) var destroyedViewIds: [Int64] = []
+    public private(set) var capturePlanListener: ((ForgeCapturePlan) -> Void)?
+    public private(set) var latestCapturePlan: ForgeCapturePlan?
+    private var nextViewId: Int64 = 1
+
+    public init() {}
+
+    public func start() -> ForgeOutcome { .accepted }
+    public func setLogLevel(_ level: ForgeLogLevel) -> ForgeOutcome { .accepted }
+    public func createVideoView(timestampMs: Int64, options: VideoOptions) -> RuntimeVideoView {
+        createdVideoTimestamps.append(timestampMs)
+        defer { nextViewId += 1 }
+        return RuntimeVideoView(id: nextViewId)
+    }
+    public func recordEvent(_ event: ForgeRecordedEvent) -> ForgeOutcome {
+        events.append(event)
+        return .accepted
+    }
+    public func recordIdentityEvent(kind: String, timemarkMs: Int64, fields: [String: String]) -> ForgeOutcome {
+        identityEvents.append((kind, timemarkMs, fields))
+        return .accepted
+    }
+    public func recordApplicationForeground(_ foreground: Bool, timestampMs: Int64) -> ForgeOutcome {
+        events.append(
+            ForgeRecordedEvent(
+                eventName: foreground ? "raw_application_foreground" : "raw_application_background",
+                timestampMs: timestampMs,
+                payload: [:]
+            )
+        )
+        return .accepted
+    }
+    public func recordNetworkEvent(_ record: NetworkRequestRecord) -> ForgeOutcome {
+        networkEvents.append(record)
+        return .accepted
+    }
+    public func recordPlayerEvent(
+        view: RuntimeVideoView,
+        event: PlayerEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: PlayerMetadataSnapshot
+    ) -> ForgeOutcome {
+        playerEvents.append((view, event, metadata))
+        playerEventTimestamps.append((timemarkMs, elapsedRealtimeMs))
+        playerEventOptions.append(options)
+        return .accepted
+    }
+    public func recordAdEvent(
+        view: RuntimeVideoView,
+        event: AdEvent,
+        timemarkMs: Int64,
+        elapsedRealtimeMs: Int64,
+        options: VideoOptions,
+        metadata: AdMetadataSnapshot,
+        adapterVersion: String?
+    ) -> ForgeOutcome {
+        adEvents.append((view, event, metadata))
+        adEventTimestamps.append((timemarkMs, elapsedRealtimeMs))
+        return .accepted
+    }
+    public func registerContentMetadataProvider(view: RuntimeVideoView, provider: RuntimeContentMetadataProvider?) -> ForgeOutcome {
+        if let provider {
+            contentMetadataProviders[view.id] = provider
+        } else {
+            contentMetadataProviders.removeValue(forKey: view.id)
+        }
+        return .accepted
+    }
+    public func registerVideoPreSendHook(view: RuntimeVideoView, hook: RuntimeVideoPreSendHook?) -> ForgeOutcome {
+        if let hook {
+            videoPreSendHooks[view.id] = hook
+        } else {
+            videoPreSendHooks.removeValue(forKey: view.id)
+        }
+        return .accepted
+    }
+    public func registerSessionPreSendHook(_ hook: RuntimeSessionPreSendHook?) -> ForgeOutcome { .accepted }
+    public func destroyVideoView(_ view: RuntimeVideoView) -> ForgeOutcome {
+        destroyedViewIds.append(view.id)
+        contentMetadataProviders.removeValue(forKey: view.id)
+        videoPreSendHooks.removeValue(forKey: view.id)
+        return .accepted
+    }
+    public func snapshotEvents() -> [ForgeRecordedEvent] { events }
+    public func destroy() -> ForgeOutcome { .accepted }
+    public func setCapturePlanListener(_ listener: ((ForgeCapturePlan) -> Void)?) -> ForgeOutcome {
+        capturePlanListener = listener
+        if let listener, let latest = latestCapturePlan {
+            listener(latest)
+        }
+        return .accepted
+    }
+    public func capturePlan() -> ForgeCapturePlan? { latestCapturePlan }
+
+    /// Test hook mirroring the native runtime's push path: stores the latest
+    /// plan and dispatches it to the registered listener.
+    public func emitCapturePlan(_ plan: ForgeCapturePlan) {
+        latestCapturePlan = plan
+        capturePlanListener?(plan)
+    }
+}

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

@@ -0,0 +1,70 @@
+/**
+ * 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: Apple storage abstraction used by the native runtime for bounded remote-config persistence.
+ */
+
+import Foundation
+
+public protocol ForgeStorage: AnyObject {
+    func read(_ key: String) -> String?
+    func write(_ key: String, value: String) -> ForgeOutcome
+    func delete(_ key: String) -> ForgeOutcome
+}
+
+public final class MemoryStorage: ForgeStorage {
+    private var values: [String: String] = [:]
+    private let lock = NSLock()
+
+    public init() {}
+
+    public func read(_ key: String) -> String? {
+        lock.lock()
+        defer { lock.unlock() }
+        return values[key]
+    }
+
+    public func write(_ key: String, value: String) -> ForgeOutcome {
+        lock.lock()
+        defer { lock.unlock() }
+        values[key] = value
+        return .accepted
+    }
+
+    public func delete(_ key: String) -> ForgeOutcome {
+        lock.lock()
+        defer { lock.unlock() }
+        values.removeValue(forKey: key)
+        return .accepted
+    }
+}
+
+public final class UserDefaultsStorage: ForgeStorage {
+    private let defaults: UserDefaults
+
+    public init(suiteName: String = "com.npaw.forge.apple.storage") {
+        self.defaults = UserDefaults(suiteName: suiteName) ?? .standard
+    }
+
+    public func read(_ key: String) -> String? {
+        defaults.string(forKey: key)
+    }
+
+    public func write(_ key: String, value: String) -> ForgeOutcome {
+        defaults.set(value, forKey: key)
+        return defaults.synchronize() ? .accepted : .failedWithDiagnostic("storage_write_failed")
+    }
+
+    public func delete(_ key: String) -> ForgeOutcome {
+        defaults.removeObject(forKey: key)
+        return defaults.synchronize() ? .accepted : .failedWithDiagnostic("storage_delete_failed")
+    }
+}

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

@@ -0,0 +1,180 @@
+/**
+ * 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: Manual Apple ad reporting facade for adapterless video integrations.
+ */
+
+import Foundation
+
+public final class ManualAdReporter {
+    private weak var videoAdapter: VideoAdapter?
+    private let adapterVersion: String?
+
+    init(videoAdapter: VideoAdapter, adapterVersion: String?) {
+        self.videoAdapter = videoAdapter
+        self.adapterVersion = adapterVersion
+    }
+
+    public func fireManifest(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.manifest, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireBreakStart(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.breakStart, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireAdInit(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.adInit, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireStart(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.start, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireJoin(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.join, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func firePause(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.pause, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireResume(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.resume, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireBufferBegin(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.bufferBegin, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireBufferEnd(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.bufferEnd, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireQuartile(_ quartile: Int? = nil, timestampMs: Int64 = 0) -> ForgeOutcome {
+        var metadata = AdMetadataSnapshot()
+        metadata.quartile = quartile
+        return record(.quartile, metadata, timestampMs)
+    }
+
+    public func fireClick(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.click, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireClick(adUrl: String?) -> ForgeOutcome {
+        fireClick(params: adUrl.map { ["adUrl": $0] } ?? [:])
+    }
+
+    public func fireSkip(timestampMs: Int64 = 0) -> ForgeOutcome {
+        record(.skip, AdMetadataSnapshot(), timestampMs)
+    }
+
+    public func fireStop(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.stop, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireError(
+        errorCode: String? = nil,
+        errorMessage: String? = nil,
+        errorMetadata: String? = nil,
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        var metadata = AdMetadataSnapshot()
+        metadata.errorCode = errorCode
+        metadata.errorMessage = errorMessage
+        metadata.errorMetadata = errorMetadata
+        return record(.error, metadata, timestampMs)
+    }
+
+    public func fireFatalError(
+        errorCode: String? = nil,
+        errorMessage: String? = nil,
+        errorMetadata: String? = nil,
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        var metadata = AdMetadataSnapshot()
+        metadata.errorCode = errorCode
+        metadata.errorMessage = errorMessage
+        metadata.errorMetadata = errorMetadata
+        metadata.errorLevel = "fatal"
+        return record(.fatalError, metadata, timestampMs)
+    }
+
+    public func fireBreakStop(
+        metadata: AdMetadataSnapshot? = nil,
+        params: [String: String]? = [:],
+        timestampMs: Int64 = 0
+    ) -> ForgeOutcome {
+        record(.breakStop, metadata ?? adMetadataFromParams(params), timestampMs)
+    }
+
+    public func fireDestroy(timestampMs: Int64 = 0) -> ForgeOutcome {
+        guard videoAdapter?.isDestroyed == false else { return .ignoredInvalidState }
+        return .unsupportedCapability
+    }
+
+    private func record(_ event: AdEvent, _ metadata: AdMetadataSnapshot, _ timestampMs: Int64) -> ForgeOutcome {
+        videoAdapter?.recordAdEvent(
+            event: event,
+            timestampMs: timestampMs,
+            metadata: metadata,
+            adapterVersion: adapterVersion
+        ) ?? .ignoredInvalidState
+    }
+
+    private func adMetadataFromParams(_ params: [String: String]?) -> AdMetadataSnapshot {
+        videoAdapter?.adMetadataFromParams(params) ?? AdMetadataSnapshot()
+    }
+}