@bubblsdk/react-native-sdk 4.1.7 → 5.0.0-alpha.2

package/ios-sdk/BubblCore/Support/AsyncMutex.swift

@@ -0,0 +1,39 @@
+/// A lock for async code: one caller at a time runs the body, the rest wait their turn (in
+/// order) without blocking a thread. An actor alone isn't enough, since an actor lets other
+/// calls in whenever the running one awaits; registering the install must not interleave.
+package actor AsyncMutex {
+    private var locked = false
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+
+    package init() {}
+
+    /// Runs `body` holding the lock, and releases it however `body` ends.
+    package nonisolated func withLock<T: Sendable>(_ body: @Sendable () async throws -> T) async rethrows -> T {
+        await lock()
+        do {
+            let result = try await body()
+            await unlock()
+            return result
+        } catch {
+            await unlock()
+            throw error
+        }
+    }
+
+    private func lock() async {
+        guard locked else {
+            locked = true
+            return
+        }
+        await withCheckedContinuation { waiters.append($0) }
+    }
+
+    private func unlock() {
+        if waiters.isEmpty {
+            locked = false
+        } else {
+            // The lock passes straight to the next waiter: it stays held.
+            waiters.removeFirst().resume()
+        }
+    }
+}

package/ios-sdk/BubblCore/Support/BubblLog.swift

@@ -0,0 +1,52 @@
+import Foundation
+
+/// How much the SDK says (BubblOptions.logLevel), most important first.
+package enum LogSeverity: Int, Sendable, Comparable, CaseIterable {
+    case error, warning, info, debug
+
+    package static func < (lhs: LogSeverity, rhs: LogSeverity) -> Bool { lhs.rawValue < rhs.rawValue }
+}
+
+/// The SDK's log, as Android's BubblLog: one place the core reports whatever it drops or holds
+/// back (a question type a newer dashboard added, a refused event, a batch the server rejected),
+/// so a developer can see why. Silent until the iOS layer points it at os.Logger and sets the
+/// level BubblOptions asks for; a message below that level is never even built.
+///
+/// **What a message may say.** It can end up in Console and sysdiagnose for anyone holding the
+/// device, so: ids, types, counts, codes and statuses only. Never coordinates or fixes, push
+/// tokens, the credential or its secret, survey answers, or the app's own event properties.
+package enum BubblLog {
+    private static let lock = NSLock()
+    nonisolated(unsafe) private static var sink: @Sendable (LogSeverity, String) -> Void = { _, _ in }
+    nonisolated(unsafe) private static var level: LogSeverity = .warning
+    nonisolated(unsafe) private static var lastErrorMessage: String?
+
+    /// Where messages go from now on (the iOS layer, or a test), and from which level up.
+    package static func setSink(level: LogSeverity = .debug, _ sink: @escaping @Sendable (LogSeverity, String) -> Void) {
+        lock.sync {
+            self.sink = sink
+            self.level = level
+        }
+    }
+
+    /// The level messages are kept from (BubblOptions.logLevel).
+    package static func setLevel(_ level: LogSeverity) {
+        lock.sync { self.level = level }
+    }
+
+    /// The last error logged, for diagnostics (kept whatever the level).
+    package static var lastError: String? { lock.sync { lastErrorMessage } }
+
+    package static func error(_ message: @autoclosure () -> String) { log(.error, message) }
+    package static func warning(_ message: @autoclosure () -> String) { log(.warning, message) }
+    package static func info(_ message: @autoclosure () -> String) { log(.info, message) }
+    package static func debug(_ message: @autoclosure () -> String) { log(.debug, message) }
+
+    private static func log(_ level: LogSeverity, _ message: () -> String) {
+        let (sink, wanted) = lock.sync { (self.sink, level <= self.level) }
+        guard wanted || level == .error else { return }
+        let text = message()
+        if level == .error { lock.sync { lastErrorMessage = text } }
+        if wanted { sink(level, text) }
+    }
+}

package/ios-sdk/BubblCore/Support/JSON.swift

@@ -0,0 +1,31 @@
+import Foundation
+
+/// JSON as the device API speaks it, read loosely: a body that isn't the expected shape is nil
+/// rather than an error, since a proxy's error page or an empty 304 must not throw.
+package enum JSON {
+    /// The object in `text`, or nil when it isn't a JSON object.
+    package static func object(_ text: String) -> [String: Any]? {
+        guard let data = text.data(using: .utf8) else { return nil }
+        return (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
+    }
+
+    /// A JSON number as Int64, however the platform's JSONSerialization boxed it (NSNumber on
+    /// Apple platforms, Swift numbers elsewhere); nil when it isn't a number.
+    package static func int64(_ value: Any?) -> Int64? {
+        switch value {
+        case let value as Int: Int64(value)
+        case let value as Int64: value
+        case let value as Double: Int64(exactly: value.rounded(.towardZero))
+        case let value as NSNumber: value.int64Value
+        default: nil
+        }
+    }
+
+    /// `value` (a dictionary or array of JSON values) as compact JSON text.
+    package static func string(_ value: Any) -> String {
+        guard JSONSerialization.isValidJSONObject(value),
+              let data = try? JSONSerialization.data(withJSONObject: value, options: [.sortedKeys])
+        else { return "{}" }
+        return String(decoding: data, as: UTF8.self)
+    }
+}

package/ios-sdk/BubblCore/Support/JSONValue.swift

@@ -0,0 +1,94 @@
+/// Any JSON value, as Codable: for the parts of the device API that carry free-form JSON (an
+/// event's `data`, a rejection's `errors`). JSONEncoder and JSONDecoder read and write it the same
+/// way on every platform the core runs on, unlike JSONSerialization's boxed numbers.
+package enum JSONValue: Sendable, Hashable, Codable {
+    case null
+    case bool(Bool)
+    case int(Int64)
+    case double(Double)
+    case string(String)
+    case array([JSONValue])
+    case object([String: JSONValue])
+
+    package init(from decoder: any Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if container.decodeNil() {
+            self = .null
+        } else if let value = try? container.decode(Bool.self) {
+            self = .bool(value)
+        } else if let value = try? container.decode(Int64.self) {
+            self = .int(value)
+        } else if let value = try? container.decode(Double.self) {
+            self = .double(value)
+        } else if let value = try? container.decode(String.self) {
+            self = .string(value)
+        } else if let value = try? container.decode([JSONValue].self) {
+            self = .array(value)
+        } else {
+            self = .object(try container.decode([String: JSONValue].self))
+        }
+    }
+
+    package func encode(to encoder: any Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case .null: try container.encodeNil()
+        case .bool(let value): try container.encode(value)
+        case .int(let value): try container.encode(value)
+        case .double(let value): try container.encode(value)
+        case .string(let value): try container.encode(value)
+        case .array(let value): try container.encode(value)
+        case .object(let value): try container.encode(value)
+        }
+    }
+
+    /// The value at `key`, when this is an object.
+    package subscript(key: String) -> JSONValue? {
+        if case .object(let object) = self { object[key] } else { nil }
+    }
+
+    package var stringValue: String? {
+        if case .string(let value) = self { value } else { nil }
+    }
+
+    /// A number as a whole Int64, never trapping: fractions are cut, and values beyond Int64
+    /// (1e30 from a server) are clamped. Nil for anything that isn't a finite number.
+    package var int64: Int64? {
+        switch self {
+        case .int(let value): return value
+        case .double(let value):
+            guard value.isFinite else { return nil }
+            let whole = value.rounded(.towardZero)
+            if let exact = Int64(exactly: whole) { return exact }
+            return whole > 0 ? .max : .min
+        default: return nil
+        }
+    }
+
+    /// int64, clamped to `range`: for a server number that sets a limit or an interval.
+    package func int64(in range: ClosedRange<Int64>) -> Int64? {
+        int64.map { min(max($0, range.lowerBound), range.upperBound) }
+    }
+
+    /// Whether every number in it is finite: JSON has no NaN or infinity, so JSONEncoder refuses
+    /// them (Android's JSONObject does too).
+    package var isEncodable: Bool {
+        switch self {
+        case .double(let value): value.isFinite
+        case .array(let values): values.allSatisfy(\.isEncodable)
+        case .object(let values): values.values.allSatisfy(\.isEncodable)
+        case .null, .bool, .int, .string: true
+        }
+    }
+}
+
+extension JSONValue: ExpressibleByStringLiteral, ExpressibleByIntegerLiteral, ExpressibleByBooleanLiteral,
+    ExpressibleByFloatLiteral, ExpressibleByDictionaryLiteral, ExpressibleByArrayLiteral, ExpressibleByNilLiteral {
+    package init(stringLiteral value: String) { self = .string(value) }
+    package init(integerLiteral value: Int64) { self = .int(value) }
+    package init(booleanLiteral value: Bool) { self = .bool(value) }
+    package init(floatLiteral value: Double) { self = .double(value) }
+    package init(dictionaryLiteral elements: (String, JSONValue)...) { self = .object(Dictionary(uniqueKeysWithValues: elements)) }
+    package init(arrayLiteral elements: JSONValue...) { self = .array(elements) }
+    package init(nilLiteral: ()) { self = .null }
+}

package/ios-sdk/BubblCore/Support/Locking.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+extension NSLock {
+    /// Runs `body` holding the lock. (Foundation's own `withLock` isn't on every platform the
+    /// core builds for.)
+    package func sync<T>(_ body: () throws -> T) rethrows -> T {
+        lock()
+        defer { unlock() }
+        return try body()
+    }
+}

package/ios-sdk/BubblCore/Support/ValueStore.swift

@@ -0,0 +1,109 @@
+import Foundation
+
+/// A small piece of the engine's state kept between launches (what's been shown, the config, the
+/// device's segments…). `load` is nil when nothing has been saved yet.
+package protocol ValueStore<Value>: Sendable {
+    associatedtype Value: Codable & Sendable
+    func load() throws -> Value?
+    func save(_ value: Value) throws
+    func delete() throws
+}
+
+/// The file couldn't be read or written, so it did neither. Before the first unlock after a reboot
+/// iOS keeps protected files closed; an unreadable file is never taken for "nothing saved".
+package struct ValueStoreUnavailable: Error {
+    package let underlying: any Error
+}
+
+/// A value read once and then kept in memory, for state that's asked for often. Only a successful
+/// read is kept: one that failed (the file locked) is tried again next time.
+package final class Cached<Value: Sendable>: @unchecked Sendable {
+    private let lock = NSLock()
+    private var loaded = false
+    private var stored: Value?
+
+    package init() {}
+
+    /// The kept value, or `load`'s result (kept) the first time.
+    package func value(_ load: () throws -> Value?) rethrows -> Value? {
+        try lock.sync {
+            if loaded { return stored }
+            let value = try load()
+            stored = value
+            loaded = true
+            return value
+        }
+    }
+
+    package func set(_ value: Value?) {
+        lock.sync {
+            stored = value
+            loaded = true
+        }
+    }
+}
+
+/// A ValueStore in memory: for tests.
+package final class InMemoryValueStore<Value: Codable & Sendable>: ValueStore, @unchecked Sendable {
+    private let lock = NSLock()
+    private var value: Value?
+
+    package init(_ value: Value? = nil) {
+        self.value = value
+    }
+
+    package func load() -> Value? { lock.sync { value } }
+    package func save(_ value: Value) { lock.sync { self.value = value } }
+    package func delete() { lock.sync { value = nil } }
+}
+
+/// A ValueStore as one JSON file, written atomically (on iOS, with file protection). A missing
+/// file is nothing saved, and so is one that reads but doesn't decode (from an older build, or
+/// corrupt); one that can't be read at all throws ValueStoreUnavailable.
+package final class FileValueStore<Value: Codable & Sendable>: ValueStore, @unchecked Sendable {
+    private let lock = NSLock()
+    private let url: URL
+    private let writeOptions: Data.WritingOptions
+
+    /// - Parameter writeOptions: added to `.atomic`; on iOS, the file protection class.
+    package init(url: URL, writeOptions: Data.WritingOptions = []) {
+        self.url = url
+        self.writeOptions = writeOptions.union(.atomic)
+    }
+
+    package func load() throws -> Value? {
+        try lock.sync {
+            guard FileManager.default.fileExists(atPath: url.path) else { return nil }
+            let data: Data
+            do {
+                data = try Data(contentsOf: url)
+            } catch {
+                throw ValueStoreUnavailable(underlying: error)
+            }
+            return try? JSONDecoder().decode(Value.self, from: data)
+        }
+    }
+
+    package func save(_ value: Value) throws {
+        try lock.sync {
+            let data = try JSONEncoder().encode(value)
+            do {
+                try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+                try data.write(to: url, options: writeOptions)
+            } catch {
+                throw ValueStoreUnavailable(underlying: error)
+            }
+        }
+    }
+
+    package func delete() throws {
+        try lock.sync {
+            guard FileManager.default.fileExists(atPath: url.path) else { return }
+            do {
+                try FileManager.default.removeItem(at: url)
+            } catch {
+                throw ValueStoreUnavailable(underlying: error)
+            }
+        }
+    }
+}

package/ios-sdk/BubblLaunch/BubblLaunch.m

@@ -0,0 +1,45 @@
+#import "BubblLaunch.h"
+#import <Foundation/Foundation.h>
+#if TARGET_OS_IOS
+#import <UIKit/UIKit.h>
+#endif
+
+// Bubbl's own start at launch, with no app code (as Android's App Startup). Swift has no +load, so
+// this Objective-C class registers, before main(), for the end of every launch. There it asks the
+// Swift side (BubblLaunchHook, found by name, since this target can't import the one that depends
+// on it) to start Bubbl again if an earlier launch started it and it wasn't stopped. So an app that
+// iOS launches for a geofence, a push or a tap has Bubbl running before a wrapper's JavaScript or
+// Dart could call start.
+@interface BubblLaunchLoader : NSObject
+@end
+
+@implementation BubblLaunchLoader
+
++ (void)load {
+#if TARGET_OS_IOS
+    // Below iOS 17 Bubbl does nothing (Bubbl.isSupported): no background task, no start at launch.
+    if (@available(iOS 17.0, *)) {} else { return; }
+
+    // Background refresh's handler must be registered before launch finishes: now, before main().
+    Class hook = NSClassFromString(@"BubblLaunchHook");
+    SEL registerTasks = NSSelectorFromString(@"registerBackgroundTasks");
+    if ([hook respondsToSelector:registerTasks]) {
+        ((void (*)(id, SEL))[hook methodForSelector:registerTasks])(hook, registerTasks);
+    }
+
+    [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationDidFinishLaunchingNotification
+                                                      object:nil
+                                                       queue:nil
+                                                  usingBlock:^(NSNotification *notification) {
+        Class hook = NSClassFromString(@"BubblLaunchHook");
+        SEL launched = NSSelectorFromString(@"applicationDidFinishLaunching");
+        if ([hook respondsToSelector:launched]) {
+            ((void (*)(id, SEL))[hook methodForSelector:launched])(hook, launched);
+        }
+    }];
+#endif
+}
+
+@end
+
+void BubblLaunchLinked(void) {}

package/ios-sdk/BubblLaunch/include/BubblLaunch.h

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+
+/// Called by the Swift side so the linker keeps this target's object file, and with it the class
+/// whose +load watches for the end of launch (a static library's unreferenced files are dropped).
+FOUNDATION_EXPORT void BubblLaunchLinked(void);