react-native-smartlinks 2.0.0

package/ios/Linklytics/Linklytics.swift

@@ -0,0 +1,581 @@
+import Foundation
+import UIKit
+
+public class Linklytics: LinklyticsInterface {
+
+    // MARK: - Public Interface
+    public static let shared = Linklytics()
+
+    // MARK: - Constants
+    public static let sdkVersion = "1.2.5"
+    public static let apiVersion = "v2"
+
+    // MARK: - Private Properties
+    private var isInitialized = false
+    private var apiKey: String?
+    private var isDebugMode = false
+    private let userDefaults = UserDefaults.standard
+    private let prefsKey = "linklytics_prefs"
+    private var pendingUniversalLink: URL?
+    private var isAppLaunchComplete = false
+    private var networkManager: NetworkManager?
+    private var deepLinkQueue: [DeepLinkRoute] = []
+    private var linkReceivedListener: ((DeepLinkRoute) -> Void)?
+
+    private var appUserId: String? {
+        get { 
+            if let saved = userDefaults.string(forKey: "\(prefsKey)_app_user_id") {
+                return saved
+            }
+            return UIDevice.current.identifierForVendor?.uuidString
+        }
+        set { userDefaults.set(newValue, forKey: "\(prefsKey)_app_user_id") }
+    }
+
+    private init() {}
+
+    // MARK: - Public Methods
+    public static var version: String {
+        return sdkVersion
+    }
+
+    public static var apiVersionString: String {
+        return apiVersion
+    }
+
+    public func setDebugMode(_ enabled: Bool) {
+        isDebugMode = enabled
+    }
+
+    public func initialize(apiKey: String, debugMode: Bool = false) {
+        self.apiKey = apiKey
+        self.isDebugMode = debugMode
+        self.isInitialized = true
+        
+        let networkManager = NetworkManager(apiKey: apiKey, debugMode: debugMode)
+        self.networkManager = networkManager
+        
+        // Initialize BatchEventManager
+        BatchEventManager.shared.initialize(networkManager: networkManager, debugMode: debugMode)
+
+        // Check if this is first launch and handle install referrer
+        if isFirstLaunch() {
+            handleFirstLaunch()
+        } else {
+            // Mark app launch as complete for non-first launches
+            isAppLaunchComplete = true
+
+            // Handle any pending universal link that came before initialization
+            if let pendingLink = pendingUniversalLink {
+                pendingUniversalLink = nil
+                handleUniversalLink(pendingLink, isFromBackground: false)
+            }
+        }
+        
+        // Try to send any previously cached events
+//        BatchEventManager.shared.trySendCachedEvents() // Not needed, it auto-starts monitoring
+
+        if isDebugMode {
+            print("Linklytics: SDK initialized with version \(Self.sdkVersion), API version \(Self.apiVersion)")
+        }
+    }
+
+    public func getAppUserId() -> String? {
+        return appUserId
+    }
+
+    public func sendEvent(_ eventName: String, parameters: [String: Any?] = [:]) {
+        guard isInitialized else {
+            if isDebugMode {
+                print("Linklytics: SDK not initialized. Call initialize() first.")
+            }
+            return
+        }
+
+        let stringParams = parameters.compactMapValues { value -> Any? in
+             // We can now support AnyCodable, so basically keep as Any but sanitize types that AnyCodable supports
+             // actually BatchEventManager takes [String: Any], which converts to OfflineEvent -> AnyCodable.
+             // So we just need to unwrap optionals.
+             return value
+        } as? [String: Any] ?? [:]
+        
+        // Sanitize for AnyCodable compatibility (String, Int, Double, Bool)
+        // The previous implementation converted EVERYTHING to String. 
+        // We want to PRESERVE types if possible.
+        
+        var validParams: [String: Any] = [:]
+        
+        for (key, value) in stringParams {
+            if let v = value as? String { validParams[key] = v }
+            else if let v = value as? Int { validParams[key] = v }
+            else if let v = value as? Double { validParams[key] = v }
+            else if let v = value as? Bool { validParams[key] = v }
+            else if let v = value as? NSNumber { validParams[key] = v } // Covers Int/Double/Bool
+            else { validParams[key] = String(describing: value) } // Fallback to string
+        }
+
+        let deviceInfo = DeviceInfo.fromCurrentDevice(
+            sdkVersion: Self.sdkVersion,
+            apiVersion: Self.apiVersion,
+            networkType: BatchEventManager.shared.getNetworkType()
+        )
+
+        // Use BatchEventManager which handles Offline/Online
+        BatchEventManager.shared.sendEvent(eventName, parameters: validParams, deviceInfo: deviceInfo.toMap(), appUserId: self.appUserId)
+
+        if isDebugMode {
+            print("Linklytics: Event passed to BatchEventManager: \(eventName)")
+        }
+    }
+
+
+
+    // MARK: - Deep Link Handling
+    public func handleURL(_ url: URL) {
+        guard isInitialized else {
+            if isDebugMode {
+                print("Linklytics: SDK not initialized. Cannot handle deep link.")
+            }
+            return
+        }
+
+        let urlString = url.absoluteString
+        var parameters: [String: String] = [:]
+
+        if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+           let queryItems = components.queryItems {
+            for item in queryItems {
+                parameters[item.name] = item.value ?? ""
+            }
+        }
+
+        let deepLinkRoute = DeepLinkRoute(
+            route: urlString,
+            parameters: parameters,
+            link: urlString,
+            appSlug: getAppSlug(),
+            isFirstLaunch: false
+        )
+
+        addDeepLinkToQueue(deepLinkRoute)
+
+        sendEvent("deep_link_opened", parameters: [
+            "route": urlString,
+            "parameters": parameters.description
+        ])
+
+        if isDebugMode {
+            print("Linklytics: Deep link handled: \(urlString) with parameters: \(parameters)")
+        }
+    }
+
+    public func handleUniversalLink(_ url: URL, isFromBackground: Bool = false) {
+        // If SDK is not initialized yet, store the link for later processing
+        guard isInitialized else {
+            pendingUniversalLink = url
+            if isDebugMode {
+                print("Linklytics: Universal link received before initialization, storing for later: \(url)")
+            }
+            return
+        }
+
+        // If this is first launch and we haven't completed the launch process yet,
+        // store the link for later processing after deferred link check
+        if isFirstLaunch() && !isAppLaunchComplete {
+            pendingUniversalLink = url
+            if isDebugMode {
+                print("Linklytics: Universal link received during first launch, storing for after deferred link check: \(url)")
+            }
+            return
+        }
+
+        let urlString = url.absoluteString
+        var parameters: [String: String] = [:]
+
+        if let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+           let queryItems = components.queryItems {
+            for item in queryItems {
+                parameters[item.name] = item.value ?? ""
+            }
+        }
+
+        // Add context about how the link was received
+        parameters["link_source"] = isFromBackground ? "background" : "terminated"
+
+        let deepLinkRoute = DeepLinkRoute(
+            route: urlString,
+            parameters: parameters,
+            link: urlString,
+            appSlug: getAppSlug(),
+            isFirstLaunch: false
+        )
+
+        addDeepLinkToQueue(deepLinkRoute)
+        // Send appropriate event based on app state
+        let eventName = isFromBackground ? "universal_link_background" : "universal_link_terminated"
+        sendEvent(eventName, parameters: [
+            "url": urlString,
+            "parameters": parameters.description,
+            "app_state": isFromBackground ? "background" : "terminated"
+        ])
+
+        if isDebugMode {
+            print("Linklytics: Universal link handled (\(isFromBackground ? "background" : "terminated")): \(urlString) with parameters: \(parameters)")
+        }
+    }
+
+    // MARK: - Private Methods
+    private func isFirstLaunch() -> Bool {
+        let key = "\(prefsKey)_has_launched_before"
+        return !userDefaults.bool(forKey: key)
+    }
+
+    private func markAsLaunched() {
+        let key = "\(prefsKey)_has_launched_before"
+        userDefaults.set(true, forKey: key)
+    }
+
+    private func handleFirstLaunch() {
+        if isDebugMode {
+            print("Linklytics: Handling first launch - getting app info and checking for deferred deep links")
+        }
+
+        // First, get app info to save the app slug
+        guard let networkManager = networkManager else {
+            if isDebugMode {
+                print("Linklytics: NetworkManager not available")
+            }
+            return
+        }
+
+        networkManager.getApp { [weak self] result in
+            switch result {
+            case .success(let appResponse):
+                let appSlug = appResponse.appSlug
+                self?.saveAppSlug(appSlug)
+                if self?.isDebugMode == true {
+                    print("Linklytics: App slug saved: \(appSlug)")
+                }
+            case .failure(let error):
+                if self?.isDebugMode == true {
+                    print("Linklytics: Failed to get app info: \(error)")
+                }
+            }
+            
+            // Continue with deferred link check regardless of app info result
+            self?.checkDeferredLinks()
+        }
+    }
+    
+    private func checkDeferredLinks() {
+        // iOS doesn't have install referrer, so we call the deferred-links API
+        // to check if there's a pending deep link for this device
+        fetchDeferredDeepLink { [weak self] result in
+            switch result {
+            case .success(let deferredLink):
+                self?.handleDeferredDeepLink(deferredLink)
+            case .failure(let error):
+                if self?.isDebugMode == true {
+                    print("Linklytics: No deferred deep link found or error: \(error)")
+                }
+                self?.handleOrganicInstall()
+            }
+            self?.markAsLaunched()
+            self?.isAppLaunchComplete = true
+
+            // Handle any pending universal link that came during first launch
+            if let pendingLink = self?.pendingUniversalLink {
+                self?.pendingUniversalLink = nil
+                self?.handleUniversalLink(pendingLink, isFromBackground: false)
+            }
+        }
+    }
+    
+    private func saveAppSlug(_ appSlug: String) {
+        let key = "\(prefsKey)_app_slug"
+        userDefaults.set(appSlug, forKey: key)
+    }
+    
+    private func getAppSlug() -> String? {
+        let key = "\(prefsKey)_app_slug"
+        return userDefaults.string(forKey: key)
+    }
+
+    // MARK: - Deferred Deep Links
+
+    private enum DeferredLinkError: Error {
+        case noApiKey
+        case invalidURL
+        case noData
+        case decodingError
+        case networkError(Error)
+    }
+
+    private func fetchDeferredDeepLink(completion: @escaping (Result<DeferredLinkResponse, DeferredLinkError>) -> Void) {
+        guard let networkManager = networkManager else {
+            completion(.failure(.noApiKey))
+            return
+        }
+
+        let deviceInfo = DeviceInfo.fromCurrentDevice(
+            sdkVersion: Self.sdkVersion,
+            apiVersion: Self.apiVersion,
+            networkType: BatchEventManager.shared.getNetworkType()
+        )
+
+        // ✅ Generate fingerprint asynchronously
+        deviceInfo.generateFingerprint { [weak self] fingerprint in
+            guard let fingerprint = fingerprint else {
+                completion(.failure(.decodingError))
+                return
+            }
+            
+            if self?.isDebugMode == true {
+                print("Linklytics: Generated fingerprint: \(fingerprint)")
+            }
+
+            // Pass deviceInfo map to network manager
+            networkManager.fetchDeferredLink(fingerprint: fingerprint, appUserId: self?.appUserId ?? "", deviceInfo: deviceInfo.toMap()) { result in
+                switch result {
+                case .success(let data):
+                    guard let data = data else {
+                        completion(.failure(.noData))
+                        return
+                    }
+                    
+                    do {
+                        let deferredLink = try JSONDecoder().decode(DeferredLinkResponse.self, from: data)
+                        completion(.success(deferredLink))
+                    } catch {
+                        if self?.isDebugMode == true {
+                            print("Linklytics: Failed to decode deferred link response: \(error)")
+                        }
+                        completion(.failure(.decodingError))
+                    }
+                case .failure(let error):
+                    if self?.isDebugMode == true {
+                        print("Linklytics: Failed to fetch deferred link: \(error)")
+                    }
+                    completion(.failure(.networkError(error)))
+                }
+            }
+        }
+    }
+
+
+    private func handleDeferredDeepLink(_ deferredLink: DeferredLinkResponse) {
+        if isDebugMode {
+            print("Linklytics: Handling deferred deep link: \(deferredLink.url ?? "no URL")")
+        }
+
+        let route = deferredLink.url ?? "organic"
+        var parameters = deferredLink.parameters ?? [:]
+
+        // Add campaign data if available
+        if let campaign = deferredLink.campaignInfo {
+            parameters.merge(campaign) { (_, new) in new }
+        }
+        if let utmParams = deferredLink.utmParams {
+            parameters.merge(utmParams) { (_, new) in new }
+        }
+
+        let deepLinkRoute = DeepLinkRoute(
+            route: route,
+            parameters: parameters,
+            link: deferredLink.url,
+            appSlug: getAppSlug(),
+            isFirstLaunch: true
+        )
+    
+
+        // Add to queue for getLink() to return
+        addDeepLinkToQueue(deepLinkRoute)
+
+        sendEvent("app_installed", parameters: [
+            "referrer": route,
+            "deferred_link": deferredLink.hasDeferredLink ? "true" : "false",
+            "parameters": parameters.description
+        ])
+    }
+
+    private func handleOrganicInstall() {
+        if isDebugMode {
+            print("Linklytics: Handling organic install")
+        }
+
+        let deepLinkRoute = DeepLinkRoute(
+            route: "organic",
+            parameters: ["referrer": "organic"],
+            link: nil,
+            appSlug: getAppSlug(),
+            isFirstLaunch: true
+        )
+
+        // Add to queue for getLink() to return
+        addDeepLinkToQueue(deepLinkRoute)
+
+        sendEvent("app_installed", parameters: [
+            "referrer": "organic",
+            "deferred_link": "false"
+        ])
+    }
+
+
+   private func generateLongDynamicLink(_ route: String, parameters: [String: String]? = nil) -> String{
+       guard let networkManager = networkManager else {
+           if isDebugMode {
+               print("Linklytics: NetworkManager not available")
+           }
+           return ""
+       }
+       
+       let app = getAppSlug() ?? ""
+       if(app == "") {
+           networkManager.getApp { [weak self] result in
+               switch result {
+               case .success(let appResponse):
+                   let appSlug = appResponse.appSlug
+                   self?.saveAppSlug(appSlug)
+               case .failure(let error):
+                   if self?.isDebugMode == true {
+                       print("Linklytics: Failed to get app info: \(error)")
+                   }
+               }
+           }
+           // Return empty string for now since we can't get app slug synchronously
+           return ""
+       }
+       
+       let queryString = parameters?.map { "\($0.key)=\($0.value)" }.joined(separator: "&") ?? ""
+       let fullURL = SdkConstants.baseURL + "/" + app + "/" + route
+       return queryString.isEmpty ? fullURL : fullURL + "?" + queryString
+   }
+
+    private func generateShortDynamicLink(_ url: String, parameters: [String: String]? = nil) -> String{
+        guard isInitialized, let networkManager = networkManager else {
+            if isDebugMode {
+                print("Linklytics: SDK not initialized. Call initialize() first.")
+            }
+            return ""
+        }
+        
+        // This is a synchronous method but we need async network call
+        // We'll use a semaphore to make it synchronous
+        let semaphore = DispatchSemaphore(value: 0)
+        var result = ""
+        
+        if isDebugMode {
+            print("Linklytics: generateShortDynamicLink called with url: \(url), parameters: \(parameters ?? [:])")
+        }
+        
+        networkManager.generateDynamicLink(url: url, parameters: parameters) { response in
+            switch response {
+            case .success(let dynamicLinkResponse):
+                result = dynamicLinkResponse.short_url ?? ""
+                if self.isDebugMode {
+                    print("Linklytics: Short dynamic link generated successfully: \(result)")
+                }
+            case .failure(let error):
+                if self.isDebugMode {
+                    print("Linklytics: Failed to generate short dynamic link: \(error)")
+                }
+                result = ""
+            }
+            semaphore.signal()
+        }
+        
+        // Wait for the async call to complete (with timeout)
+        _ = semaphore.wait(timeout: .now() + 10)
+        
+        if isDebugMode {
+            print("Linklytics: generateShortDynamicLink result: \(result)")
+        }
+        
+        return result
+    }
+
+    // MARK: - Dynamic Link Generation
+    public func generateDynamicLink(_ url: String, parameters: [String: String]? = nil, isShort: Bool = false) -> String? {
+        guard isInitialized, let networkManager = networkManager else {
+            if isDebugMode {
+                print("Linklytics: SDK not initialized. Call initialize() first.")
+            }
+            return nil
+        }
+        
+        if isDebugMode {
+            print("Linklytics: generateDynamicLink called with url: \(url), parameters: \(parameters ?? [:]), isShort: \(isShort)")
+        }
+        
+        if !isShort {
+            return generateLongDynamicLink(url, parameters: parameters)
+        } else {
+            return generateShortDynamicLink(url, parameters: parameters)
+        }
+    }
+    
+    public func getLink() -> DeepLinkRoute? {
+        guard isInitialized else {
+            if isDebugMode {
+                print("Linklytics: SDK not initialized. Call initialize() first.")
+            }
+            return nil
+        }
+        
+        // Return the first deep link from the queue, if any
+        if !deepLinkQueue.isEmpty {
+            let link = deepLinkQueue.removeFirst()
+            if isDebugMode {
+                print("Linklytics: getLink returning: \(link.route)")
+            }
+            return link
+        }
+        
+        if isDebugMode {
+            print("Linklytics: getLink called but no deep links in queue")
+        }
+        
+        return nil
+    }
+
+    public func setOnLinkReceivedListener(_ listener: @escaping (DeepLinkRoute) -> Void) {
+        self.linkReceivedListener = listener
+        
+        // Drain existing queue to the new listener
+        while !deepLinkQueue.isEmpty {
+            let link = deepLinkQueue.removeFirst()
+            if isDebugMode {
+                print("Linklytics: Draining queued link to listener: \(link.route)")
+            }
+            listener(link)
+        }
+    }
+    
+ 
+
+    // MARK: - Internal Deep Link Management
+    private func addDeepLinkToQueue(_ deepLinkRoute: DeepLinkRoute) {
+        if let listener = linkReceivedListener {
+            if isDebugMode {
+                print("Linklytics: Notifying listener of new deep link: \(deepLinkRoute.route)")
+            }
+            listener(deepLinkRoute)
+        } else {
+            deepLinkQueue.append(deepLinkRoute)
+            if isDebugMode {
+                print("Linklytics: Added deep link to queue: \(deepLinkRoute.route)")
+            }
+        }
+    }
+
+    // MARK: - Testing Helper
+    public func clearUserData() {
+        let launchKey = "\(prefsKey)_has_launched_before"
+        let appSlugKey = "\(prefsKey)_app_slug"
+        userDefaults.removeObject(forKey: launchKey)
+        userDefaults.removeObject(forKey: appSlugKey)
+        if isDebugMode {
+            print("Linklytics: User data cleared for testing")
+        }
+    }
+}

package/ios/Linklytics/LinklyticsInterface.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+// MARK: - Public Interface
+public protocol LinklyticsInterface {
+    func initialize(apiKey: String, debugMode: Bool)
+    func sendEvent(_ eventName: String, parameters: [String: Any?])
+    func generateDynamicLink(_ url: String, parameters: [String: String]?, isShort: Bool) -> String?
+    func getLink() -> DeepLinkRoute?
+    func setOnLinkReceivedListener(_ listener: @escaping (DeepLinkRoute) -> Void)
+}