@bigcrunch/react-native-ads 0.4.0 → 0.6.0

package/ios/BigCrunchAds/Sources/Internal/HTTPClient.swift

@@ -0,0 +1,146 @@
+import Foundation
+
+/**
+ * HTTP client for making network requests
+ *
+ * Uses URLSession for reliable networking with automatic retries and caching.
+ * All methods are async functions using Swift's async/await.
+ */
+internal class HTTPClient {
+
+    private let session: URLSession
+
+    init(configuration: URLSessionConfiguration? = nil) {
+        let config = configuration ?? {
+            let defaultConfig = URLSessionConfiguration.default
+            defaultConfig.timeoutIntervalForRequest = 10
+            defaultConfig.timeoutIntervalForResource = 10
+            return defaultConfig
+        }()
+        self.session = URLSession(configuration: config)
+    }
+
+    /**
+     * Perform a GET request
+     *
+     * - Parameters:
+     *   - url: The URL to fetch
+     *   - headers: Optional HTTP headers
+     * - Returns: Result containing response body or error
+     */
+    func get(url: String, headers: [String: String] = [:]) async -> Result<String, Error> {
+        guard let url = URL(string: url) else {
+            let error = NSError(
+                domain: "HTTPClient",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(url)"]
+            )
+            BCLogger.error("GET request failed: Invalid URL")
+            return .failure(error)
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        headers.forEach { request.addValue($0.value, forHTTPHeaderField: $0.key) }
+
+        do {
+            let (data, response) = try await session.data(for: request)
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                let error = NSError(
+                    domain: "HTTPClient",
+                    code: -1,
+                    userInfo: [NSLocalizedDescriptionKey: "Invalid response type"]
+                )
+                return .failure(error)
+            }
+
+            if (200...299).contains(httpResponse.statusCode) {
+                let string = String(data: data, encoding: .utf8) ?? ""
+                BCLogger.verbose("GET success: \(url.absoluteString) (\(data.count) bytes)")
+                return .success(string)
+            } else {
+                let error = NSError(
+                    domain: "HTTPClient",
+                    code: httpResponse.statusCode,
+                    userInfo: [NSLocalizedDescriptionKey: "HTTP \(httpResponse.statusCode)"]
+                )
+                BCLogger.warning("GET failed: \(url.absoluteString) - HTTP \(httpResponse.statusCode)")
+                return .failure(error)
+            }
+        } catch {
+            BCLogger.error("GET request failed: \(url.absoluteString) - \(error)")
+            return .failure(error)
+        }
+    }
+
+    /**
+     * Perform a POST request
+     *
+     * - Parameters:
+     *   - url: The URL to post to
+     *   - body: Request body (JSON string)
+     *   - headers: Optional HTTP headers
+     * - Returns: Result containing response body or error
+     */
+    func post(
+        url: String,
+        body: String,
+        headers: [String: String] = [:]
+    ) async -> Result<String, Error> {
+        guard let url = URL(string: url) else {
+            let error = NSError(
+                domain: "HTTPClient",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(url)"]
+            )
+            BCLogger.error("POST request failed: Invalid URL")
+            return .failure(error)
+        }
+
+        // Log the request body for debugging
+        BCLogger.debug("POST to: \(url.absoluteString)")
+        BCLogger.debug("Request body: \(body)")
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.httpBody = body.data(using: .utf8)
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        headers.forEach { request.addValue($0.value, forHTTPHeaderField: $0.key) }
+
+        do {
+            let (data, response) = try await session.data(for: request)
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                let error = NSError(
+                    domain: "HTTPClient",
+                    code: -1,
+                    userInfo: [NSLocalizedDescriptionKey: "Invalid response type"]
+                )
+                return .failure(error)
+            }
+
+            if (200...299).contains(httpResponse.statusCode) {
+                let string = String(data: data, encoding: .utf8) ?? ""
+                BCLogger.verbose("POST success: \(url.absoluteString)")
+                return .success(string)
+            } else {
+                // Log response body for 4xx errors to see what the server says
+                let errorBody = String(data: data, encoding: .utf8) ?? ""
+                let error = NSError(
+                    domain: "HTTPClient",
+                    code: httpResponse.statusCode,
+                    userInfo: [NSLocalizedDescriptionKey: "HTTP \(httpResponse.statusCode)"]
+                )
+                BCLogger.warning("POST failed: \(url.absoluteString) - HTTP \(httpResponse.statusCode)")
+                if !errorBody.isEmpty {
+                    BCLogger.warning("Error response body: \(errorBody)")
+                }
+                return .failure(error)
+            }
+        } catch {
+            BCLogger.error("POST request failed: \(url.absoluteString) - \(error)")
+            return .failure(error)
+        }
+    }
+}

package/ios/BigCrunchAds/Sources/Internal/Logger.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+/**
+ * Internal logger for BigCrunch Ads SDK
+ *
+ * All logs are prefixed with "[BCrunch:LEVEL]" for easy filtering.
+ * Logging can be disabled in production by setting isEnabled = false.
+ * Error logs are always shown regardless of isEnabled flag.
+ */
+internal class BCLogger {
+
+    /**
+     * Enable/disable debug logging
+     * Defaults to false for production builds
+     */
+    static var isEnabled = false
+
+    /**
+     * Verbose log - detailed debugging information
+     */
+    static func verbose(_ message: String) {
+        if isEnabled {
+            print("[BCrunch:VERBOSE] \(message)")
+        }
+    }
+
+    /**
+     * Debug log - general debugging information
+     */
+    static func debug(_ message: String) {
+        if isEnabled {
+            print("[BCrunch:DEBUG] \(message)")
+        }
+    }
+
+    /**
+     * Info log - informational messages
+     */
+    static func info(_ message: String) {
+        if isEnabled {
+            print("[BCrunch:INFO] \(message)")
+        }
+    }
+
+    /**
+     * Warning log - potential issues
+     */
+    static func warning(_ message: String) {
+        if isEnabled {
+            print("[BCrunch:WARNING] \(message)")
+        }
+    }
+
+    /**
+     * Error log - critical errors
+     * Always logs regardless of isEnabled flag
+     */
+    static func error(_ message: String) {
+        // Always log errors
+        print("[BCrunch:ERROR] \(message)")
+    }
+}

package/ios/BigCrunchAds/Sources/Internal/PrivacyStore.swift

@@ -0,0 +1,129 @@
+import Foundation
+
+/**
+ * Centralized privacy signal store
+ *
+ * Manages GDPR, CCPA, and COPPA privacy signals for the SDK.
+ * Reads IAB TCF/USP standard keys from UserDefaults when available,
+ * and provides structured objects for bid request construction.
+ */
+internal class PrivacyStore {
+
+    private let lock = NSLock()
+
+    // SDK-set values (from public API)
+    private var _gdprConsentString: String?
+    private var _gdprApplies: Bool?
+    private var _ccpaString: String?
+    private var _coppaApplies: Bool = false
+
+    // IAB standard UserDefaults keys
+    private static let iabTcfConsentKey = "IABTCF_TCString"
+    private static let iabTcfGdprAppliesKey = "IABTCF_gdprApplies"
+    private static let iabUspStringKey = "IABUSPrivacy_String"
+
+    // MARK: - Setters (called from public API)
+
+    func setGdprConsent(_ consent: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        _gdprApplies = true
+        _gdprConsentString = consent
+        BCLogger.debug("PrivacyStore: GDPR consent set")
+    }
+
+    func setCcpaString(_ ccpa: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        _ccpaString = ccpa
+        // Also write to IAB standard key for CMP interop
+        UserDefaults.standard.set(ccpa, forKey: Self.iabUspStringKey)
+        BCLogger.debug("PrivacyStore: CCPA string set")
+    }
+
+    func setCoppaApplies(_ applies: Bool) {
+        lock.lock()
+        defer { lock.unlock() }
+        _coppaApplies = applies
+        BCLogger.debug("PrivacyStore: COPPA set to \(applies)")
+    }
+
+    // MARK: - Getters
+
+    /// Effective GDPR consent string (SDK-set takes priority, then IAB TCF)
+    var gdprConsentString: String? {
+        lock.lock()
+        defer { lock.unlock() }
+        return _gdprConsentString
+            ?? UserDefaults.standard.string(forKey: Self.iabTcfConsentKey)
+    }
+
+    /// Whether GDPR applies (SDK-set takes priority, then IAB TCF)
+    var gdprApplies: Bool? {
+        lock.lock()
+        defer { lock.unlock() }
+        if let sdkValue = _gdprApplies {
+            return sdkValue
+        }
+        let iabValue = UserDefaults.standard.object(forKey: Self.iabTcfGdprAppliesKey) as? Int
+        return iabValue.map { $0 == 1 }
+    }
+
+    /// Effective CCPA/USP string (SDK-set takes priority, then IAB USP)
+    var ccpaString: String? {
+        lock.lock()
+        defer { lock.unlock() }
+        return _ccpaString
+            ?? UserDefaults.standard.string(forKey: Self.iabUspStringKey)
+    }
+
+    var coppaApplies: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return _coppaApplies
+    }
+
+    // MARK: - Bid Request Helpers
+
+    /// Build the `regs` object for an OpenRTB bid request
+    func buildRegsDict() -> [String: Any] {
+        var regs: [String: Any] = [:]
+        var ext: [String: Any] = [:]
+
+        if coppaApplies {
+            regs["coppa"] = 1
+        } else {
+            regs["coppa"] = 0
+        }
+
+        if let gdpr = gdprApplies {
+            ext["gdpr"] = gdpr ? 1 : 0
+        }
+
+        if let usp = ccpaString {
+            ext["us_privacy"] = usp
+        }
+
+        if !ext.isEmpty {
+            regs["ext"] = ext
+        }
+
+        return regs
+    }
+
+    /// Build the `user` object for an OpenRTB bid request
+    func buildUserDict() -> [String: Any] {
+        var user: [String: Any] = [:]
+        var ext: [String: Any] = [:]
+
+        if let consent = gdprConsentString {
+            ext["consent"] = consent
+        }
+
+        if !ext.isEmpty {
+            user["ext"] = ext
+        }
+
+        return user
+    }
+}

package/ios/BigCrunchAds/Sources/Internal/Storage.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+/**
+ * Key-value storage protocol for persisting SDK data
+ */
+internal protocol KeyValueStore {
+    /**
+     * Get a string value by key
+     *
+     * - Parameters:
+     *   - key: Storage key
+     *   - default: Default value if key doesn't exist
+     * - Returns: Stored value or default
+     */
+    func getString(key: String, default: String?) -> String?
+
+    /**
+     * Store a string value
+     *
+     * - Parameters:
+     *   - key: Storage key
+     *   - value: Value to store (pass nil to remove the key)
+     */
+    func putString(key: String, value: String?)
+
+    /**
+     * Clear all stored data
+     */
+    func clear()
+}
+
+/**
+ * UserDefaults-based implementation of KeyValueStore
+ *
+ * Thread-safe implementation using iOS's UserDefaults.
+ * All keys are prefixed with "bigcrunch_ads_" for namespace isolation.
+ */
+internal class UserDefaultsStore: KeyValueStore {
+
+    private let userDefaults = UserDefaults.standard
+    private let keyPrefix = "bigcrunch_ads_"
+
+    func getString(key: String, default: String? = nil) -> String? {
+        let prefixedKey = keyPrefix + key
+        let value = userDefaults.string(forKey: prefixedKey) ?? `default`
+        if value != nil {
+            BCLogger.verbose("Retrieved value for key: \(key)")
+        }
+        return value
+    }
+
+    func putString(key: String, value: String?) {
+        let prefixedKey = keyPrefix + key
+        if let value = value {
+            userDefaults.set(value, forKey: prefixedKey)
+            BCLogger.verbose("Stored value for key: \(key)")
+        } else {
+            userDefaults.removeObject(forKey: prefixedKey)
+            BCLogger.verbose("Removed value for key: \(key)")
+        }
+    }
+
+    func clear() {
+        let keys = userDefaults.dictionaryRepresentation().keys
+        let prefixedKeys = keys.filter { $0.hasPrefix(keyPrefix) }
+
+        for key in prefixedKeys {
+            userDefaults.removeObject(forKey: key)
+        }
+
+        BCLogger.debug("Cleared all stored data")
+    }
+}