Extract BackoffCounter to independent module

- Move ReconnectBackoffCounter to Sources/BackoffCounter/BackoffCounter.swift
- Move BackoffCounterTimer to Sources/BackoffCounter/BackoffCounterTimer.swift
- Move tests to Sources/BackoffCounter/Tests/
- Rename ReconnectBackoffCounter -> BackoffCounter
- Replace AtomicInt/Atomic<Bool> with NSLock for module independence
- Replace DispatchQueue.general with DispatchQueue.global()
- Add conditional import for Logging module (#if !COCOAPODS)
- Add README with usage documentation

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: MartinCardozo-SDK

…/Streaming/ReconnectBackoffCounter.swift …rces/BackoffCounter/BackoffCounter.swiftSplit/Network/Streaming/ReconnectBackoffCounter.swift renamed to Sources/BackoffCounter/BackoffCounter.swift Split/Network/Streaming/ReconnectBackoffCounter.swift renamed to Sources/BackoffCounter/BackoffCounter.swift

@@ -1,5 +1,5 @@
 //
-//  ReconnectBackoffCounter.swift
+//  BackoffCounter.swift
 //  Split
 //
 //  Created by Javier L. Avrudsky on 13/08/2020.
@@ -8,29 +8,33 @@
 
 import Foundation
 
-protocol ReconnectBackoffCounter {
+public protocol BackoffCounter {
     func getNextRetryTime() -> Double
     func resetCounter()
 }
 
-class DefaultReconnectBackoffCounter: ReconnectBackoffCounter, @unchecked Sendable {
+public class DefaultBackoffCounter: BackoffCounter, @unchecked Sendable {
     private var maxTimeLimitInSecs: Double = 1800.0 // 30 minutes (30 * 60)
     private static let kRetryExponentialBase = 2
     private let backoffBase: Int
-    private var attemptCount: AtomicInt
+    private var attemptCount: Int = 0
+    private let lock = NSLock()
 
-    init(backoffBase: Int, maxTimeLimit: Int? = nil) {
+    public init(backoffBase: Int, maxTimeLimit: Int? = nil) {
         self.backoffBase = backoffBase
-        self.attemptCount = AtomicInt(0)
         if let max = maxTimeLimit {
             maxTimeLimitInSecs = Double(max)
         }
     }
 
-    func getNextRetryTime() -> Double {
+    public func getNextRetryTime() -> Double {
+        lock.lock()
+        let currentAttempt = attemptCount
+        attemptCount += 1
+        lock.unlock()
 
         let base = Decimal(backoffBase * Self.kRetryExponentialBase)
-        let decimalResult = pow(base, attemptCount.getAndAdd(1))
+        let decimalResult = pow(base, currentAttempt)
 
         var retryTime = maxTimeLimitInSecs
         if !decimalResult.isNaN, decimalResult < Decimal(maxTimeLimitInSecs) {
@@ -39,7 +43,9 @@ class DefaultReconnectBackoffCounter: ReconnectBackoffCounter, @unchecked Sendab
         return retryTime
     }
 
-    func resetCounter() {
-        attemptCount .mutate { $0 = 0 }
+    public func resetCounter() {
+        lock.lock()
+        attemptCount = 0
+        lock.unlock()
     }
 }

Sources/BackoffCounter/BackoffCounterTimer.swift

@@ -0,0 +1,66 @@
+//
+//  BackoffCounterTimer.swift
+//  Split
+//
+//  Created by Javier L. Avrudsky on 20/10/2020.
+//  Copyright © 2020 Split. All rights reserved.
+//
+
+import Foundation
+#if !COCOAPODS
+import Logging
+#endif
+
+public protocol BackoffCounterTimer {
+    func schedule(handler: @escaping @Sendable () -> Void)
+    func cancel()
+}
+
+public class DefaultBackoffCounterTimer: BackoffCounterTimer, @unchecked Sendable {
+    private let backoffCounter: BackoffCounter
+    private let queue = DispatchQueue(label: "split-backoff-timer")
+    private let timersQueue = DispatchQueue.global(qos: .default)
+    private var workItem: DispatchWorkItem?
+    private var isScheduled: Bool = false
+    private let scheduleLock = NSLock()
+
+    public init(backoffCounter: BackoffCounter) {
+        self.backoffCounter = backoffCounter
+    }
+
+    public func schedule(handler: @escaping @Sendable () -> Void) {
+        queue.async {
+            self.schedule(handler)
+        }
+    }
+
+    public func cancel() {
+        queue.async {
+            self.workItem?.cancel()
+            self.workItem = nil
+            self.backoffCounter.resetCounter()
+        }
+    }
+
+    private func schedule(_ handler: @escaping () -> Void) {
+        scheduleLock.lock()
+        let wasScheduled = isScheduled
+        if workItem != nil, wasScheduled {
+            scheduleLock.unlock()
+            return
+        }
+        isScheduled = true
+        scheduleLock.unlock()
+
+        let workItem = DispatchWorkItem(block: {
+            self.scheduleLock.lock()
+            self.isScheduled = false
+            self.scheduleLock.unlock()
+            handler()
+        })
+        let delayInSeconds = backoffCounter.getNextRetryTime()
+        Logger.d("Retrying reconnection in \(delayInSeconds) seconds")
+        timersQueue.asyncAfter(deadline: DispatchTime.now() + Double(delayInSeconds), execute: workItem)
+        self.workItem = workItem
+    }
+}

Sources/BackoffCounter/README.md

@@ -0,0 +1,75 @@
+# BackoffCounter
+
+A thread-safe exponential backoff implementation for retry logic.
+
+## Overview
+
+This module provides two main components:
+
+- **BackoffCounter**: Calculates exponential backoff times for retry operations
+- **BackoffCounterTimer**: Schedules operations with automatic backoff delays
+
+## Usage
+
+### Basic BackoffCounter
+
+```swift
+// Create a counter with base 1 (delays: 1s, 2s, 4s, 8s, 16s... up to 30 min)
+let counter = DefaultBackoffCounter(backoffBase: 1)
+
+// Get next retry time (exponentially increasing)
+let delay1 = counter.getNextRetryTime() // 1.0
+let delay2 = counter.getNextRetryTime() // 2.0
+let delay3 = counter.getNextRetryTime() // 4.0
+
+// Reset after successful operation
+counter.resetCounter()
+```
+
+### Custom Configuration
+
+```swift
+// Higher base = faster growth (delays: 1s, 4s, 16s, 64s...)
+let aggressiveCounter = DefaultBackoffCounter(backoffBase: 2)
+
+// Custom max time limit (default is 1800 seconds / 30 minutes)
+let limitedCounter = DefaultBackoffCounter(backoffBase: 1, maxTimeLimit: 60)
+```
+
+### BackoffCounterTimer
+
+```swift
+let counter = DefaultBackoffCounter(backoffBase: 1)
+let timer = DefaultBackoffCounterTimer(backoffCounter: counter)
+
+// Schedule a retry operation
+timer.schedule {
+    // This will be called after the backoff delay
+    performRetryOperation()
+}
+
+// Cancel pending retry and reset counter
+timer.cancel()
+```
+
+## Backoff Formula
+
+The retry time is calculated as:
+
+```
+retryTime = (backoffBase * 2) ^ attemptCount
+```
+
+Where `attemptCount` starts at 0 and increments with each call to `getNextRetryTime()`.
+
+### Example Sequences
+
+| Base | Attempt 0 | Attempt 1 | Attempt 2 | Attempt 3 | Max (default) |
+|------|-----------|-----------|-----------|-----------|---------------|
+| 1    | 1s        | 2s        | 4s        | 8s        | 1800s         |
+| 2    | 1s        | 4s        | 16s       | 64s       | 1800s         |
+| 3    | 1s        | 6s        | 36s       | 216s      | 1800s         |
+
+## Thread Safety
+
+Both `DefaultBackoffCounter` and `DefaultBackoffCounterTimer` are thread-safe and conform to `Sendable`.

…eaming/ReconnectBackoffCounterTest.swift …ffCounter/Tests/BackoffCounterTest.swiftSplitTests/Streaming/ReconnectBackoffCounterTest.swift renamed to Sources/BackoffCounter/Tests/BackoffCounterTest.swift SplitTests/Streaming/ReconnectBackoffCounterTest.swift renamed to Sources/BackoffCounter/Tests/BackoffCounterTest.swift

@@ -1,5 +1,5 @@
 //
-//  ReconnectBackoffCounterTest.swift
+//  BackoffCounterTest.swift
 //  SplitTests
 //
 //  Created by Javier L. Avrudsky on 13/08/2020.
@@ -11,7 +11,7 @@ import Foundation
 import XCTest
 @testable import Split
 
-class ReconnectBackoffCounterTest: XCTestCase {
+class BackoffCounterTest: XCTestCase {
     override func setUp() {
     }
 
@@ -36,7 +36,7 @@ class ReconnectBackoffCounterTest: XCTestCase {
     }
 
     private func testWithBase(base: Int, results: [Double]) {
-        let counter = DefaultReconnectBackoffCounter(backoffBase: base);
+        let counter = DefaultBackoffCounter(backoffBase: base);
         let v1 = counter.getNextRetryTime()
         let v2 = counter.getNextRetryTime()
         let v3 = counter.getNextRetryTime()