[Performance]Timers improvements (#877)

Author: ipavlidakis

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 # Upcoming
 
 ### 🔄 Changed
+- Performance improvements around timers. [#877](https://github.com/GetStream/stream-video-swift/pull/877)
 
 # [1.27.2](https://github.com/GetStream/stream-video-swift/releases/tag/1.27.2)
 _June 25, 2025_

Sources/StreamVideo/CallKit/CallKitService.swift

@@ -612,10 +612,8 @@ open class CallKitService: NSObject, CXProviderDelegate, @unchecked Sendable {
     /// - Parameter callState: The state of the call.
     open func setUpRingingTimer(for callState: GetCallResponse) {
         let timeout = TimeInterval(callState.call.settings.ring.autoCancelTimeoutMs / 1000)
-        ringingTimerCancellable = Foundation
-            .Timer
-            .publish(every: timeout, on: .main, in: .default)
-            .autoconnect()
+        ringingTimerCancellable = DefaultTimer
+            .publish(every: timeout)
             .sink { [weak self] _ in
                 log.debug(
                     "Detected ringing timeout, hanging up...",

Sources/StreamVideo/CallState.swift

@@ -506,10 +506,8 @@ public class CallState: ObservableObject {
 
     private func setupDurationTimer() {
         resetTimer()
-        durationCancellable = Foundation
-            .Timer
-            .publish(every: 1.0, on: .main, in: .default)
-            .autoconnect()
+        durationCancellable = DefaultTimer
+            .publish(every: 1.0)
             .receive(on: DispatchQueue.main)
             .compactMap { [weak self] _ in
                 if let startedAt = self?.startedAt {

Sources/StreamVideo/StreamVideo.swift

@@ -531,10 +531,8 @@ public class StreamVideo: ObservableObject, @unchecked Sendable {
         do {
             var cancellable: AnyCancellable?
             log.debug("Listening for WS connection")
-            _ = try await Foundation
-                .Timer
-                .publish(every: 0.1, on: .main, in: .default)
-                .autoconnect()
+            _ = try await DefaultTimer
+                .publish(every: 0.1)
                 .filter { [weak webSocketClient] _ in webSocketClient?.connectionState.isConnected == true }
                 .nextValue(timeout: 30) { cancellable = $0 }
             cancellable?.cancel()
@@ -586,10 +584,8 @@ public class StreamVideo: ObservableObject, @unchecked Sendable {
 
         var cancellable: AnyCancellable?
         do {
-            let result = try await Foundation
-                .Timer
-                .publish(every: 0.1, on: .main, in: .default)
-                .autoconnect()
+            let result = try await DefaultTimer
+                .publish(every: 0.1)
                 .log(.debug) { _ in "Waiting for connection id" }
                 .compactMap { [weak self] _ in self?.loadConnectionIdFromHealthcheck() }
                 .nextValue(timeout: 5) { cancellable = $0 }

Sources/StreamVideo/Utils/AudioSession/AudioRecorder/StreamCallAudioRecorder.swift

@@ -118,10 +118,8 @@ open class StreamCallAudioRecorder: @unchecked Sendable {
 
             updateMetersTimerCancellable?.cancel()
             disposableBag.remove("update-meters")
-            updateMetersTimerCancellable = Foundation
-                .Timer
-                .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate, on: .main, in: .default)
-                .autoconnect()
+            updateMetersTimerCancellable = DefaultTimer
+                .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate)
                 .sinkTask(storeIn: disposableBag, identifier: "update-meters") { [weak self, audioRecorder] _ in
                     audioRecorder.updateMeters()
                     self?._metersPublisher.send(audioRecorder.averagePower(forChannel: 0))

Sources/StreamVideo/Utils/OrderedCapacityQueue/OrderedCapacityQueue.swift

@@ -49,10 +49,8 @@ final class OrderedCapacityQueue<Element> {
     init(capacity: Int, removalTime: TimeInterval) {
         self.capacity = capacity
         self.removalTime = removalTime
-        removalTimerCancellable = Foundation
-            .Timer
-            .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate, on: .main, in: .default)
-            .autoconnect()
+        removalTimerCancellable = DefaultTimer
+            .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate)
             .receive(on: DispatchQueue.global(qos: .userInteractive))
             .sink { [weak self] _ in self?.removeItemsIfRequired() }
     }
@@ -88,10 +86,8 @@ final class OrderedCapacityQueue<Element> {
     ///   should be enabled.
     private func toggleRemovalObservation(_ isEnabled: Bool) {
         if isEnabled, removalTimerCancellable == nil {
-            removalTimerCancellable = Foundation
-                .Timer
-                .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate, on: .main, in: .default)
-                .autoconnect()
+            removalTimerCancellable = DefaultTimer
+                .publish(every: ScreenPropertiesAdapter.currentValue.refreshRate)
                 .sink { [weak self] _ in self?.removeItemsIfRequired() }
         } else if !isEnabled, removalTimerCancellable != nil {
             removalTimerCancellable?.cancel()

Sources/StreamVideo/Utils/ScreenPropertiesAdapter/ScreenPropertiesAdapter.swift

@@ -11,9 +11,9 @@ import UIKit
 
 public final class ScreenPropertiesAdapter: @unchecked Sendable {
 
-    public private(set) var preferredFramesPerSecond: Int = 0
-    public private(set) var refreshRate: TimeInterval = 0
-    public private(set) var scale: CGFloat = 0
+    public private(set) var preferredFramesPerSecond: Int = 30
+    public private(set) var refreshRate: TimeInterval = 0.16
+    public private(set) var scale: CGFloat = 1
 
     init() {
         Task { @MainActor in

Sources/StreamVideo/Utils/Timers/DefaultTimer.swift

@@ -0,0 +1,87 @@
+//
+// Copyright © 2025 Stream.io Inc. All rights reserved.
+//
+
+import Combine
+import Foundation
+
+/**
+ Default real-world implementations of the ``Timer`` protocol.
+
+ These timers are based on ``DispatchQueue`` and ``DispatchSourceTimer``,
+ allowing precise control of scheduling on custom queues. This ensures that
+ timers are not bound to the main thread and can run in background contexts.
+ */
+public struct DefaultTimer: Timer {
+    /// Schedules a one-shot timer that fires once after the specified interval.
+    ///
+    /// The timer executes the ``onFire`` callback on the specified dispatch queue,
+    /// which can be any background or custom queue. Timers are not tied to the
+    /// main thread and can run on any queue you provide.
+    ///
+    /// - Parameters:
+    ///   - timeInterval: Delay in seconds before the timer fires.
+    ///   - queue: The dispatch queue on which to execute ``onFire``. This can be
+    ///     any queue, including background queues.
+    ///   - onFire: Callback to invoke when the timer fires.
+    /// - Returns: A ``TimerControl`` used to cancel the timer if needed.
+    @discardableResult
+    static func schedule(
+        timeInterval: TimeInterval,
+        queue: DispatchQueue,
+        onFire: @escaping () -> Void
+    ) -> TimerControl {
+        let worker = DispatchWorkItem(block: onFire)
+        queue.asyncAfter(deadline: .now() + timeInterval, execute: worker)
+        return worker
+    }
+
+    /// Schedules a repeating timer on the given queue.
+    ///
+    /// The timer fires repeatedly at the specified interval. Execution happens
+    /// on the provided dispatch queue and is not tied to the main thread. You can
+    /// use any custom or background queue for timer events.
+    ///
+    /// - Parameters:
+    ///   - timeInterval: Interval in seconds between timer firings.
+    ///   - queue: The dispatch queue used to invoke the ``onFire`` callback.
+    ///   - onFire: Callback to invoke on each timer fire.
+    /// - Returns: A ``RepeatingTimerControl`` used to manage the timer.
+    static func scheduleRepeating(
+        timeInterval: TimeInterval,
+        queue: DispatchQueue,
+        onFire: @escaping () -> Void
+    ) -> RepeatingTimerControl {
+        RepeatingTimer(timeInterval: timeInterval, queue: queue, onFire: onFire)
+    }
+
+    /// Returns a Combine publisher that emits `Date` values at a fixed interval.
+    ///
+    /// The timer operates on a background queue and only emits values while
+    /// there are active subscribers. If the interval is less than or equal to
+    /// zero, a warning is logged and a single `Date` value is emitted instead.
+    ///
+    /// - Parameters:
+    ///   - interval: Time between emitted date values.
+    ///   - file: The file from which the method is called. Used for logging.
+    ///   - function: The function from which the method is called.
+    ///   - line: The line number from which the method is called.
+    /// - Returns: A publisher that emits dates while subscribed.
+    public static func publish(
+        every interval: TimeInterval,
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) -> AnyPublisher<Date, Never> {
+        guard interval > 0 else {
+            log.warning(
+                "Interval cannot be 0 or less",
+                functionName: function,
+                fileName: file,
+                lineNumber: line
+            )
+            return Just(Date()).eraseToAnyPublisher()
+        }
+        return TimerPublisher(interval: interval).eraseToAnyPublisher()
+    }
+}

Sources/StreamVideo/Utils/Timers/Extensions/DispatchWorkItem+TimerControl.swift

@@ -0,0 +1,7 @@
+//
+// Copyright © 2025 Stream.io Inc. All rights reserved.
+//
+
+import Foundation
+
+extension DispatchWorkItem: TimerControl {}

Sources/StreamVideo/Utils/Timers/Protocol/Timer.swift

@@ -0,0 +1,77 @@
+//
+// Copyright © 2025 Stream.io Inc. All rights reserved.
+//
+
+import Combine
+import Foundation
+
+/// A protocol describing a timing utility for scheduling one-shot and repeating
+/// timers, as well as retrieving the current time or publishing timer events.
+///
+/// All scheduled timers are executed on the provided dispatch queue, which
+/// allows running timers off the main thread in background contexts.
+protocol Timer {
+
+    /// Schedules a new one-shot timer on the specified queue.
+    ///
+    /// The timer fires once after the given time interval. The `onFire` callback
+    /// is invoked on the provided dispatch queue, which is not restricted to the
+    /// main thread.
+    ///
+    /// - Parameters:
+    ///   - timeInterval: Seconds until the timer fires.
+    ///   - queue: The queue where the `onFire` callback is executed. It can be a
+    ///     background queue.
+    ///   - onFire: Callback triggered when the timer fires.
+    /// - Returns: A `TimerControl` that can cancel the scheduled timer.
+    @discardableResult
+    static func schedule(
+        timeInterval: TimeInterval,
+        queue: DispatchQueue,
+        onFire: @escaping () -> Void
+    ) -> TimerControl
+
+    /// Schedules a new repeating timer on the specified queue.
+    ///
+    /// The timer repeatedly fires after the specified time interval. The `onFire`
+    /// callback is invoked on the provided dispatch queue, which can be a
+    /// background queue and is not tied to the main thread.
+    ///
+    /// - Parameters:
+    ///   - timeInterval: Seconds between repeated timer firings.
+    ///   - queue: The queue on which the `onFire` callback is executed.
+    ///   - onFire: Callback triggered each time the timer fires.
+    /// - Returns: A `RepeatingTimerControl` that allows suspension and resumption.
+    static func scheduleRepeating(
+        timeInterval: TimeInterval,
+        queue: DispatchQueue,
+        onFire: @escaping () -> Void
+    ) -> RepeatingTimerControl
+
+    /// Returns the current system date and time.
+    static func currentTime() -> Date
+
+    /// Returns a publisher that emits timer events at the specified interval.
+    ///
+    /// This publisher is designed to emit values from a background context and
+    /// is not restricted to the main thread.
+    ///
+    /// - Parameters:
+    ///   - interval: Time between emitted `Date` values.
+    ///   - repeating: A Boolean indicating if the timer should repeat.
+    /// - Returns: A publisher that emits the current `Date` on each fire.
+    static func publish(
+        every interval: TimeInterval,
+        file: StaticString,
+        function: StaticString,
+        line: UInt
+    ) -> AnyPublisher<Date, Never>
+}
+
+extension Timer {
+
+    /// Returns the current system date and time.
+    static func currentTime() -> Date {
+        Date()
+    }
+}