Merge pull request #1 from amayers/amayers/xcode_15

Update for Xcode 15

Author: amayers

Package.resolved

@@ -1,28 +1,23 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.9
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
 
 let package = Package(
     name: "AnalyticsKit",
-    platforms: [.iOS(.v13)],
+    platforms: [.iOS(.v16)],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
         .library(
             name: "AnalyticsKit",
             targets: ["AnalyticsKit"]),
     ],
-    dependencies: [
-        // Dependencies declare other packages that this package depends on.
-        // .package(url: /* package url */, from: "1.0.0"),
-        .package(url: "https://github.com/amayers/ThreadKit.git", from: "1.0.2")
-    ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages this package depends on.
         .target(
             name: "AnalyticsKit",
-            dependencies: ["ThreadKit"]),
+            dependencies: []),
         .testTarget(
             name: "AnalyticsKitTests",
             dependencies: ["AnalyticsKit"]),

Package.swift

@@ -13,8 +13,8 @@ public struct AppLaunchEvent: AnalyticsEvent {
             "device_description": self.device.device.model.rawValue,
             "ram_size_mb": self.device.ramSizeMB,
             "free_disk_space_mb": self.device.freeDiskSpaceMB,
-            "language_code": Locale.current.languageCode ?? "unknown",
-            "region_code": Locale.current.regionCode ?? "unknown",
+            "language_code": Locale.current.language.languageCode?.identifier ?? "unknown",
+            "region_code": Locale.current.region?.identifier ?? "unknown",
             "locale_identifier": Locale.current.identifier
         ]
     }

Sources/AnalyticsKit/Events/AppLaunchEvent.swift

@@ -1,7 +1,7 @@
 import Foundation
 
 /// Wrapper around an `AnalyticsEvent` that records the time that the event was originally fired & the event.
-struct SendingDelayedAnalyticsEvent {
+public struct SendingDelayedAnalyticsEvent {
     let event: AnalyticsEvent
     /// The original time the event happened.
     let timeEventOccurred: Date

Sources/AnalyticsKit/Events/SendingDelayedAnalyticsEvent.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+extension Array where Element == SendingDelayedAnalyticsEvent {
+    func oldestFirst() -> Self {
+        sorted { lhs, rhs in
+            lhs.timeEventOccurred < rhs.timeEventOccurred
+        }
+    }
+    func shouldSendQueuedEvents() -> Bool {
+        return if count >= 10 {
+            true
+        } else {
+            (oldestFirst().first?.timeEventOccurred.timeIntervalSinceNow ?? 0) <= -300
+        }
+    }
+    
+    mutating func popEvents(batchSize: Int) -> ArraySlice<Element> {
+        let range = 0..<Swift.min(count, batchSize)
+        guard !range.isEmpty else {
+            return []
+        }
+        let events = self[range]
+        for index in range.sorted(by: >) {
+            remove(at: index)
+        }
+        return events
+    }
+}

Sources/AnalyticsKit/Internal/Array+SendingDelayedAnalyticsEvent.swift

@@ -1,56 +1,128 @@
-import Foundation
+import UIKit
 
 public final class AnalyticsManager {
     private enum Constants {
         static let hasUserApprovedAnalyticsKey = "AnalyticsManager_hasUserApprovedAnalytics"
     }
-
-    public static var shared: AnalyticsManager = AnalyticsManager()
-
-    private var services: [AnalyticsService] = []
-    private let queue = DispatchQueue(label: "com.AnalyticsManager", qos: .utility, autoreleaseFrequency: .workItem, target: .global(qos: .utility))
-
-    /// The global switch that toggles analytics tracking. Defaults to `true`
+    
+    private let service: Service
+    private let userDefaults: UserDefaults
+    
+    private let queue: EventQueue
+    
     public var hasUserApprovedAnalytics: Bool {
         didSet {
-            dispatchPrecondition(condition: .onQueue(.main))
-            UserDefaults.standard.set(hasUserApprovedAnalytics, forKey: Constants.hasUserApprovedAnalyticsKey)
-            if hasUserApprovedAnalytics {
-                queue.async {
-                    self.services.forEach({ (service) in
-                        service.set(enabled: self.hasUserApprovedAnalytics)
-                        service.configure(userID: UserIdentifier.identifierForVendor())
-                    })
-                }
-            }
+            userDefaults.set(
+                hasUserApprovedAnalytics,
+                forKey: Constants.hasUserApprovedAnalyticsKey
+            )
         }
     }
 
-    private init() {
+    public init(
+        service: Service,
+        queue: EventQueue = .init(),
+        userDefaults: UserDefaults = .standard
+    ) {
+        self.service = service
+        self.queue = queue
+        self.userDefaults = userDefaults
         // This sets the default of `hasUserApprovedAnalytics` to `true`, but once a user toggles the setting manually, this value is overwritten.
-        UserDefaults.standard.register(defaults: [Constants.hasUserApprovedAnalyticsKey: true])
-        self.hasUserApprovedAnalytics = UserDefaults.standard.bool(forKey: Constants.hasUserApprovedAnalyticsKey)
-    }
-
-    /// Adds a new `AnalyticsService` that will be used when logging events. You can add as many services as you like and they will all get used.
-    public func add(service: AnalyticsService) {
-        queue.async {
-            service.set(enabled: self.hasUserApprovedAnalytics)
-            if self.hasUserApprovedAnalytics {
-                service.configure(userID: UserIdentifier.identifierForVendor())
-            }
-            self.services.append(service)
+        userDefaults.register(defaults: [Constants.hasUserApprovedAnalyticsKey: true])
+        hasUserApprovedAnalytics = userDefaults.bool(forKey: Constants.hasUserApprovedAnalyticsKey)
+        
+        Task { @MainActor in
+            // The following app events should all trigger sending any queued events, since after these events our app might stop running,
+            // and we'd loose the events.
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(forceSendingAllEvents),
+                name: UIApplication.didReceiveMemoryWarningNotification,
+                object: nil
+            )
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(forceSendingAllEvents),
+                name: UIApplication.didEnterBackgroundNotification,
+                object: nil
+            )
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(forceSendingAllEvents),
+                name: UIApplication.willResignActiveNotification,
+                object: nil
+            )
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(forceSendingAllEvents),
+                name: UIApplication.willTerminateNotification,
+                object: nil
+            )
         }
     }
-
-    /// Logs an event on all enabled services
+    
+    /// Logs an event on all enabled services. Does not wait for the event to be sent.
     public func logCustomEvent(_ event: AnalyticsEvent) {
-        guard hasUserApprovedAnalytics else { return }
-        queue.async {
-            self.services.forEach { (service) in
-                service.logCustomEvent(event)
+        Task {
+            await logCustomEvent(event)
+        }
+    }
+    
+    /// Logs an event on all enabled services. Waits for the event to be sent (if the event queue is ready to be sent).
+    public func logCustomEvent(_ event: AnalyticsEvent) async {
+        await queue.add(
+            event: SendingDelayedAnalyticsEvent(
+                event: event,
+                timeEventOccurred: Date()
+            )
+        )
+        await sendQueuedEventsWhenNecessary()
+    }
+    
+    // MARK: - Private Methods
+    
+    @objc nonisolated private func forceSendingAllEvents() {
+        Task {
+            while await !queue.events.isEmpty {
+                await sendBatchOfEvents()
             }
-            event.wasSent()
         }
     }
+    
+    private func sendQueuedEventsWhenNecessary() async{
+        while await queue.events.shouldSendQueuedEvents() {
+            await sendBatchOfEvents()
+        }
+    }
+    
+    private func sendBatchOfEvents() async {
+        let events = await queue.pop(batchSize: service.batchSize)
+        do {
+            try await service.send(events: events, for: UserIdentifier.identifierForVendor())
+            events.forEach { $0.event.wasSent() }
+        } catch {
+            print("Error sending analytics batch: \(error)")
+            await queue.reenqueue(events: events)
+        }
+    }
+}
+
+// MARK: - EventQueue
+
+public actor EventQueue {
+    private(set) var events: [SendingDelayedAnalyticsEvent] = []
+    
+    public init() { }
+    
+    func add(event: SendingDelayedAnalyticsEvent) {
+        events.append(event)
+    }
+    
+    func pop(batchSize: Int) -> ArraySlice<SendingDelayedAnalyticsEvent> {
+        events.popEvents(batchSize: batchSize)
+    }
+    
+    func reenqueue(events: any Collection<SendingDelayedAnalyticsEvent>) {
+        self.events.append(contentsOf: events)
+    }
 }