react-native-smartlinks 2.0.0

package/ios/Linklytics/Managers/BatchEventManager.swift

@@ -0,0 +1,218 @@
+import Foundation
+import Network
+
+class BatchEventManager {
+    static let shared = BatchEventManager()
+    
+    private let offlineCache = OfflineCache()
+    private var networkManager: NetworkManager?
+    private let monitor = NWPathMonitor()
+    private let queue = DispatchQueue(label: "com.alkashier.linklytics.batcheventmanager")
+    private var isConnected = false
+    private var isSendingBatch = false
+    private var isInitialized = false
+    private var isDebugMode = false
+    
+    // Network Reliability
+    private var consecutiveFailures = 0
+    private var lastFailureTimestamp: Date?
+    private var currentNetworkType: String = "unknown"
+    
+    private let batchSize = 50
+    private let initialBackoff: TimeInterval = 10
+    private let maxBackoff: TimeInterval = 300 // 5 mins
+    
+    private init() {}
+    
+    func initialize(networkManager: NetworkManager, debugMode: Bool) {
+        self.networkManager = networkManager
+        self.isDebugMode = debugMode
+        self.isInitialized = true
+        
+        startMonitoring()
+    }
+    
+    private func startMonitoring() {
+        monitor.pathUpdateHandler = { [weak self] path in
+            self?.queue.async {
+                let wasConnected = self?.isConnected ?? false
+                self?.isConnected = path.status == .satisfied
+                
+                // Track network type
+                if path.usesInterfaceType(.wifi) {
+                    self?.currentNetworkType = "wifi"
+                } else if path.usesInterfaceType(.cellular) {
+                    self?.currentNetworkType = "cellular"
+                } else if path.usesInterfaceType(.wiredEthernet) {
+                    self?.currentNetworkType = "ethernet"
+                } else if path.status == .satisfied {
+                    self?.currentNetworkType = "other"
+                } else {
+                    self?.currentNetworkType = "none"
+                }
+                
+                if self?.isConnected == true && !wasConnected {
+                    if self?.isDebugMode == true {
+                        print("Linklytics: Connectivity restored (\(self?.currentNetworkType ?? "unknown")), attempting to send cached events")
+                    }
+                    // Wait a moment for connection to stabilize (5s matching Android)
+                    self?.queue.asyncAfter(deadline: .now() + 5.0) {
+                        self?.sendCachedEvents()
+                    }
+                }
+            }
+        }
+        monitor.start(queue: queue)
+    }
+
+    func getNetworkType() -> String {
+        return queue.sync { currentNetworkType }
+    }
+    
+    func stopMonitoring() {
+        monitor.cancel()
+    }
+    
+    func sendEvent(_ eventName: String, parameters: [String: Any], deviceInfo: [String: Any], appUserId: String? = nil) {
+        guard isInitialized else {
+            print("Linklytics: BatchEventManager not initialized")
+            return
+        }
+        
+        let offlineEvent = OfflineEvent(eventName: eventName, parameters: parameters, deviceInfo: deviceInfo, appUserId: appUserId, isDebug: self.isDebugMode)
+        
+        queue.async {
+            if self.isConnected {
+                // Try sending immediately
+                self.sendImmediate(offlineEvent)
+            } else {
+                if self.isDebugMode {
+                    print("Linklytics: No connection, caching event: \(eventName)")
+                }
+                self.offlineCache.cacheEvent(offlineEvent)
+            }
+        }
+    }
+    
+    private func sendImmediate(_ event: OfflineEvent) {
+        guard let networkManager = networkManager else { return }
+        
+        // Convert AnyCodable back to [String: Any] for NetworkManager (which currently expects [String: String], we need to update it)
+        // Wait, NetworkManager needs update to accept [String: Any].
+        // For now, let's assume NetworkManager will be updated.
+        
+        networkManager.sendEvent(event: event) { [weak self] result in
+            switch result {
+            case .success:
+                if self?.isDebugMode == true {
+                    print("Linklytics: Event sent immediately: \(event.eventName)")
+                }
+            case .failure(let error):
+                if self?.isDebugMode == true {
+                    print("Linklytics: Failed to send event immediately, caching: \(error)")
+                }
+                self?.offlineCache.cacheEvent(event)
+            }
+        }
+    }
+    
+    private func isInBackoff() -> Bool {
+        guard consecutiveFailures > 0, let lastFailure = lastFailureTimestamp else { return false }
+        let now = Date()
+        let nextAllowedTime = lastFailure.addingTimeInterval(getNextBackoffDelay())
+        return now < nextAllowedTime
+    }
+
+    private func getNextBackoffDelay() -> TimeInterval {
+        if consecutiveFailures == 0 { return 0 }
+        let exponentialDelay = initialBackoff * pow(2.0, Double(consecutiveFailures - 1))
+        return min(exponentialDelay, maxBackoff)
+    }
+
+    private func sendCachedEvents() {
+        guard !isSendingBatch else { return }
+        
+        if isInBackoff() {
+            if isDebugMode {
+                let remaining = lastFailureTimestamp!.addingTimeInterval(getNextBackoffDelay()).timeIntervalSince(Date())
+                print("Linklytics: SDK in backoff period, skipping sync. Remaining: \(Int(remaining))s")
+            }
+            return
+        }
+        
+        isSendingBatch = true
+        
+        let events = offlineCache.getEventsReadyForSending()
+        if events.isEmpty {
+            isSendingBatch = false
+            return
+        }
+        
+        if isDebugMode {
+            print("Linklytics: Found \(events.count) cached events to send")
+        }
+        
+        // Chunk into batches of 50
+        let batches = stride(from: 0, to: events.count, by: 50).map {
+            Array(events[$0..<min($0 + 50, events.count)])
+        }
+        
+        sendBatchesRecursive(batches: batches, index: 0)
+    }
+    
+    private func sendBatchesRecursive(batches: [[OfflineEvent]], index: Int) {
+        guard index < batches.count else {
+            isSendingBatch = false
+            return
+        }
+        
+        let batch = batches[index]
+        
+        // Check connection
+        if !isConnected {
+            if isDebugMode { print("Linklytics: Connection lost during batch send") }
+            isSendingBatch = false
+            return
+        }
+        
+        // Extract common fields for the batch header (optional, backend can also handle per-event)
+        // But for V2 we want the top-level app_user_id if possible
+        let batchAppUserId = batch.first?.appUserId
+        let batchDebug = batch.first?.isDebug ?? self.isDebugMode
+        
+        networkManager?.sendBatchEvents(events: batch, appUserId: batchAppUserId, debug: batchDebug) { [weak self] result in
+            switch result {
+            case .success:
+                if self?.isDebugMode == true {
+                    print("Linklytics: Batch \(index + 1)/\(batches.count) sent successfully")
+                }
+                // Remove successful events
+                let ids = batch.map { $0.id }
+                self?.offlineCache.removeEvents(withIds: ids)
+                
+                // Reset backoff on success
+                self?.consecutiveFailures = 0
+                self?.lastFailureTimestamp = nil
+                
+                // Next batch with delay
+                self?.queue.asyncAfter(deadline: .now() + 1.0) {
+                    self?.sendBatchesRecursive(batches: batches, index: index + 1)
+                }
+                
+            case .failure(let error):
+                if self?.isDebugMode == true {
+                    print("Linklytics: Batch \(index + 1) failed: \(error)")
+                }
+                // Handle failures (increment retry)
+                self?.offlineCache.handleFailedEvents(batch)
+                
+                // Track failure for backoff
+                self?.consecutiveFailures += 1
+                self?.lastFailureTimestamp = Date()
+                
+                // Stop processing remaining batches to backoff
+                self?.isSendingBatch = false
+            }
+        }
+    }
+}

package/ios/Linklytics/Managers/OfflineCache.swift

@@ -0,0 +1,35 @@
+import Foundation
+
+class OfflineCache {
+    private let storage = SQLiteStorage()
+    private let maxRetryCount = 3
+
+    func cacheEvent(_ event: OfflineEvent) {
+        storage.insert(event: event)
+    }
+
+    func getEvents() -> [OfflineEvent] {
+        return storage.getAllEvents()
+    }
+    
+    func getEventsReadyForSending() -> [OfflineEvent] {
+        return storage.getAllEvents().filter { $0.retryCount < self.maxRetryCount }
+    }
+
+    func removeEvents(withIds ids: [String]) {
+        storage.removeEvents(withIds: ids)
+    }
+    
+    func handleFailedEvents(_ failedEvents: [OfflineEvent]) {
+        let ids = failedEvents.map { $0.id }
+        storage.updateRetryCount(forIds: ids)
+    }
+
+    func getCachedCount() -> Int {
+        return storage.getCount()
+    }
+
+    func clearCache() {
+        storage.clear()
+    }
+}

package/ios/Linklytics/Managers/SQLiteStorage.swift

@@ -0,0 +1,225 @@
+import Foundation
+import SQLite3
+
+class SQLiteStorage {
+    private var db: OpaquePointer?
+    private let dbName = "linklytics_events.sqlite"
+    private let queue = DispatchQueue(label: "com.alkashier.linklytics.sqlite", attributes: .concurrent)
+    private let maxCachedEvents = 1000
+
+    init() {
+        openDatabase()
+        createTable()
+    }
+
+    deinit {
+        sqlite3_close(db)
+    }
+
+    private func openDatabase() {
+        let fileURL = try! FileManager.default
+            .url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
+            .appendingPathComponent(dbName)
+
+        if sqlite3_open(fileURL.path, &db) != SQLITE_OK {
+            print("Linklytics: Error opening database")
+        }
+    }
+
+    private func createTable() {
+        let createTableString = """
+        CREATE TABLE IF NOT EXISTS events(
+            id TEXT PRIMARY KEY NOT NULL,
+            event_name TEXT,
+            parameters TEXT,
+            device_info TEXT,
+            timestamp INTEGER,
+            retry_count INTEGER,
+            app_user_id TEXT,
+            debug INTEGER DEFAULT 0
+        );
+        """
+
+        var createTableStatement: OpaquePointer?
+        if sqlite3_prepare_v2(db, createTableString, -1, &createTableStatement, nil) == SQLITE_OK {
+            if sqlite3_step(createTableStatement) == SQLITE_DONE {
+                // Table created
+            } else {
+                print("Linklytics: Events table could not be created.")
+            }
+        }
+        sqlite3_finalize(createTableStatement)
+        
+        // Migration: Ensure debug column exists
+        let alterTableString = "ALTER TABLE events ADD COLUMN debug INTEGER DEFAULT 0;"
+        sqlite3_exec(db, alterTableString, nil, nil, nil)
+    }
+
+    func insert(event: OfflineEvent) {
+        queue.async(flags: .barrier) {
+            let insertStatementString = "INSERT INTO events (id, event_name, parameters, device_info, timestamp, retry_count, app_user_id, debug) VALUES (?, ?, ?, ?, ?, ?, ?, ?);"
+            var insertStatement: OpaquePointer?
+
+            if sqlite3_prepare_v2(self.db, insertStatementString, -1, &insertStatement, nil) == SQLITE_OK {
+                sqlite3_bind_text(insertStatement, 1, (event.id as NSString).utf8String, -1, nil)
+                sqlite3_bind_text(insertStatement, 2, (event.eventName as NSString).utf8String, -1, nil)
+                
+                let paramsData = try? JSONEncoder().encode(event.parameters)
+                let paramsString = paramsData.flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
+                sqlite3_bind_text(insertStatement, 3, (paramsString as NSString).utf8String, -1, nil)
+                
+                let deviceData = try? JSONEncoder().encode(event.deviceInfo)
+                let deviceString = deviceData.flatMap { String(data: $0, encoding: .utf8) } ?? "{}"
+                sqlite3_bind_text(insertStatement, 4, (deviceString as NSString).utf8String, -1, nil)
+                
+                sqlite3_bind_int64(insertStatement, 5, event.timestamp)
+                sqlite3_bind_int(insertStatement, 6, Int32(event.retryCount))
+                
+                if let userId = event.appUserId {
+                    sqlite3_bind_text(insertStatement, 7, (userId as NSString).utf8String, -1, nil)
+                } else {
+                    sqlite3_bind_null(insertStatement, 7)
+                }
+                
+                sqlite3_bind_int(insertStatement, 8, event.isDebug ? 1 : 0)
+
+                if sqlite3_step(insertStatement) != SQLITE_DONE {
+                    print("Linklytics: Could not insert row.")
+                }
+            }
+            sqlite3_finalize(insertStatement)
+            
+            self.checkAndCleanupInternal()
+        }
+    }
+
+    func getAllEvents() -> [OfflineEvent] {
+        return queue.sync {
+            let queryStatementString = "SELECT * FROM events ORDER BY timestamp ASC;"
+            var queryStatement: OpaquePointer?
+            var events: [OfflineEvent] = []
+
+            if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
+                while sqlite3_step(queryStatement) == SQLITE_ROW {
+                    let id = String(cString: sqlite3_column_text(queryStatement, 0))
+                    let name = String(cString: sqlite3_column_text(queryStatement, 1))
+                    let paramsJson = String(cString: sqlite3_column_text(queryStatement, 2))
+                    let deviceJson = String(cString: sqlite3_column_text(queryStatement, 3))
+                    let timestamp = sqlite3_column_int64(queryStatement, 4)
+                    let retryCount = Int(sqlite3_column_int(queryStatement, 5))
+                    let appUserId = sqlite3_column_text(queryStatement, 6).flatMap { String(cString: $0) }
+                    let isDebug = sqlite3_column_int(queryStatement, 7) != 0
+
+                    let params = (try? JSONDecoder().decode([String: AnyCodable].self, from: paramsJson.data(using: .utf8)!)) ?? [:]
+                    let device = (try? JSONDecoder().decode([String: AnyCodable].self, from: deviceJson.data(using: .utf8)!)) ?? [:]
+
+                    let event = OfflineEvent(id: id, eventName: name, parameters: params, deviceInfo: device, timestamp: timestamp, retryCount: retryCount, appUserId: appUserId, isDebug: isDebug)
+                    events.append(event)
+                }
+            }
+            sqlite3_finalize(queryStatement)
+            return events
+        }
+    }
+    
+    func removeEvents(withIds ids: [String]) {
+        queue.async(flags: .barrier) {
+            let placeholders = Array(repeating: "?", count: ids.count).joined(separator: ",")
+            let deleteStatementString = "DELETE FROM events WHERE id IN (\(placeholders));"
+            var deleteStatement: OpaquePointer?
+
+            if sqlite3_prepare_v2(self.db, deleteStatementString, -1, &deleteStatement, nil) == SQLITE_OK {
+                for (index, id) in ids.enumerated() {
+                    sqlite3_bind_text(deleteStatement, Int32(index + 1), (id as NSString).utf8String, -1, nil)
+                }
+
+                if sqlite3_step(deleteStatement) != SQLITE_DONE {
+                    print("Linklytics: Could not delete rows.")
+                }
+            }
+            sqlite3_finalize(deleteStatement)
+        }
+    }
+
+    func updateRetryCount(forIds ids: [String]) {
+        queue.async(flags: .barrier) {
+            let placeholders = Array(repeating: "?", count: ids.count).joined(separator: ",")
+            let updateStatementString = "UPDATE events SET retry_count = retry_count + 1 WHERE id IN (\(placeholders));"
+            var updateStatement: OpaquePointer?
+
+            if sqlite3_prepare_v2(self.db, updateStatementString, -1, &updateStatement, nil) == SQLITE_OK {
+                for (index, id) in ids.enumerated() {
+                    sqlite3_bind_text(updateStatement, Int32(index + 1), (id as NSString).utf8String, -1, nil)
+                }
+
+                if sqlite3_step(updateStatement) != SQLITE_DONE {
+                    print("Linklytics: Could not update retry counts.")
+                }
+            }
+            sqlite3_finalize(updateStatement)
+            
+            // Cleanup events that reached max retry (e.g. 3)
+            let cleanupStatementString = "DELETE FROM events WHERE retry_count >= 3;"
+            var cleanupStatement: OpaquePointer?
+            if sqlite3_prepare_v2(self.db, cleanupStatementString, -1, &cleanupStatement, nil) == SQLITE_OK {
+                _ = sqlite3_step(cleanupStatement)
+            }
+            sqlite3_finalize(cleanupStatement)
+        }
+    }
+
+    func getCount() -> Int {
+        return queue.sync {
+            let queryStatementString = "SELECT COUNT(*) FROM events;"
+            var queryStatement: OpaquePointer?
+            var count = 0
+
+            if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
+                if sqlite3_step(queryStatement) == SQLITE_ROW {
+                    count = Int(sqlite3_column_int(queryStatement, 0))
+                }
+            }
+            sqlite3_finalize(queryStatement)
+            return count
+        }
+    }
+
+    func clear() {
+        queue.async(flags: .barrier) {
+            let deleteStatementString = "DELETE FROM events;"
+            var deleteStatement: OpaquePointer?
+            if sqlite3_prepare_v2(self.db, deleteStatementString, -1, &deleteStatement, nil) == SQLITE_OK {
+                _ = sqlite3_step(deleteStatement)
+            }
+            sqlite3_finalize(deleteStatement)
+        }
+    }
+
+    private func checkAndCleanupInternal() {
+        // Simple FIFO cleanup if over limit
+        let currentCount = getCountInternal()
+        if currentCount > maxCachedEvents {
+            let deleteCount = currentCount - maxCachedEvents + (maxCachedEvents / 10) // Delete overage + 10%
+            let deleteStatementString = "DELETE FROM events WHERE id IN (SELECT id FROM events ORDER BY timestamp ASC LIMIT ?);"
+            var deleteStatement: OpaquePointer?
+            if sqlite3_prepare_v2(db, deleteStatementString, -1, &deleteStatement, nil) == SQLITE_OK {
+                sqlite3_bind_int(deleteStatement, 1, Int32(deleteCount))
+                _ = sqlite3_step(deleteStatement)
+            }
+            sqlite3_finalize(deleteStatement)
+        }
+    }
+    
+    private func getCountInternal() -> Int {
+        let queryStatementString = "SELECT COUNT(*) FROM events;"
+        var queryStatement: OpaquePointer?
+        var count = 0
+        if sqlite3_prepare_v2(db, queryStatementString, -1, &queryStatement, nil) == SQLITE_OK {
+            if sqlite3_step(queryStatement) == SQLITE_ROW {
+                count = Int(sqlite3_column_int(queryStatement, 0))
+            }
+        }
+        sqlite3_finalize(queryStatement)
+        return count
+    }
+}

package/ios/Linklytics/Models/AppResponse.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+// MARK: - App Response Model
+public struct AppResponse: Codable {
+    public let appSlug: String
+    
+    enum CodingKeys: String, CodingKey {
+        case appSlug = "app_slug"
+    }
+
+    public init(
+        appSlug: String
+    ) {
+        self.appSlug = appSlug
+    }
+}

package/ios/Linklytics/Models/DeepLinkRoute.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+// MARK: - Deep Link Route Model
+public struct DeepLinkRoute {
+    public let route: String
+    public let parameters: [String: String]
+    public let link: String?
+    public let appSlug: String?
+    public let isFirstLaunch: Bool
+
+    public init(
+        route: String,
+        parameters: [String: String] = [:],
+        link: String? = nil,
+        appSlug: String? = nil,
+        isFirstLaunch: Bool = false
+    ) {
+        self.route = route
+        self.parameters = parameters
+        self.link = link
+        self.appSlug = appSlug
+        self.isFirstLaunch = isFirstLaunch
+    }
+}

package/ios/Linklytics/Models/DeferredLinkResponse.swift

@@ -0,0 +1,81 @@
+import Foundation
+
+// MARK: - Deferred Link Response Model
+struct DeferredLinkResponse: Decodable {
+    let url: String?
+    let parameters: [String: String]?
+    let campaignInfo: [String: String]?
+    let utmParams: [String: String]?
+    let hasDeferredLink: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case url
+        case parameters
+        case campaignInfo = "campaign_info"
+        case utmParams = "utm_params" // Assuming backend sends snake_case
+        case hasDeferredLink = "has_deferred_link"
+        case success
+        case timestamp
+    }
+    
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        
+        hasDeferredLink = try container.decodeIfPresent(Bool.self, forKey: .hasDeferredLink) ?? false
+        url = try container.decodeIfPresent(String.self, forKey: .url)
+        
+        // Handle campaignInfo (dictionary in JSON)
+        if let campaignContainer = try? container.nestedContainer(keyedBy: DynamicKey.self, forKey: .campaignInfo) {
+            var campaignDict: [String: String] = [:]
+            for key in campaignContainer.allKeys {
+                if let stringVal = try? campaignContainer.decodeIfPresent(String.self, forKey: key) {
+                    campaignDict[key.stringValue] = stringVal
+                }
+            }
+            campaignInfo = campaignDict
+        } else {
+            campaignInfo = nil
+        }
+        
+        // Handle parameters: Mix of String/Int/Bool -> Convert to [String: String]
+        if let paramsContainer = try? container.nestedContainer(keyedBy: DynamicKey.self, forKey: .parameters) {
+            var params: [String: String] = [:]
+            for key in paramsContainer.allKeys {
+                if let stringVal = try? paramsContainer.decode(String.self, forKey: key) {
+                    params[key.stringValue] = stringVal
+                } else if let intVal = try? paramsContainer.decode(Int.self, forKey: key) {
+                    params[key.stringValue] = String(intVal)
+                } else if let boolVal = try? paramsContainer.decode(Bool.self, forKey: key) {
+                    params[key.stringValue] = String(boolVal)
+                } else if let doubleVal = try? paramsContainer.decode(Double.self, forKey: key) {
+                    params[key.stringValue] = String(doubleVal)
+                }
+            }
+            parameters = params
+        } else {
+            parameters = nil
+        }
+        
+        // Handle utmParams: Mix of String/Int/Bool -> Convert to [String: String]
+        if let utmContainer = try? container.nestedContainer(keyedBy: DynamicKey.self, forKey: .utmParams) {
+             var utms: [String: String] = [:]
+            for key in utmContainer.allKeys {
+                if let stringVal = try? utmContainer.decode(String.self, forKey: key) {
+                    utms[key.stringValue] = stringVal
+                }
+                 // Usually UTMs are strings, but safe to cover others
+            }
+            utmParams = utms
+        } else {
+            utmParams = nil
+        }
+    }
+    
+    // Helper for dynamic keys
+    struct DynamicKey: CodingKey {
+        var stringValue: String
+        init?(stringValue: String) { self.stringValue = stringValue }
+        var intValue: Int?
+        init?(intValue: Int) { return nil }
+    }
+}

package/ios/Linklytics/Models/DynamicLinkResponse.swift

@@ -0,0 +1,13 @@
+import Foundation
+
+// MARK: - Dynamic Link Response Model
+struct DynamicLinkResponse: Codable {
+    let success: Bool
+    let short_url: String?
+   
+    
+    enum CodingKeys: String, CodingKey {
+        case success
+        case short_url
+    }
+}

package/ios/Linklytics/Models/EventResponse.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+// MARK: - Event Response Model
+struct EventResponse: Codable {
+    let success: Bool
+    let message: String?
+    
+    
+    enum CodingKeys: String, CodingKey {
+        case success
+        case message
+       
+    }
+}