From 6ee7fd329774283f6949e31d4024835cc1e91de7 Mon Sep 17 00:00:00 2001
From: Peter <>
Date: Tue, 16 Oct 2018 20:18:17 +0300
Subject: [PATCH] no message

---
 SwiftSignalKit/Signal_Timing.swift | 52 ++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/SwiftSignalKit/Signal_Timing.swift b/SwiftSignalKit/Signal_Timing.swift
index dc5316be60..a96fbbae6f 100644
--- a/SwiftSignalKit/Signal_Timing.swift
+++ b/SwiftSignalKit/Signal_Timing.swift
@@ -28,6 +28,58 @@ public func delay<T, E>(_ timeout: Double, queue: Queue) -> (_ signal: Signal<T,
     }
 }
 
+public func suspendAwareDelay<T, E>(_ timeout: Double, granularity: Double = 4.0, queue: Queue) -> (_ signal: Signal<T, E>) -> Signal<T, E> {
+    return { signal in
+        return Signal<T, E> { subscriber in
+            let disposable = MetaDisposable()
+            queue.async {
+                let beginTimestamp = CFAbsoluteTimeGetCurrent()
+                
+                let startFinalTimer: () -> Void = {
+                    let finalTimeout = beginTimestamp + timeout - CFAbsoluteTimeGetCurrent()
+                    let timer = Timer(timeout: max(0.0, finalTimeout), repeat: false, completion: {
+                        disposable.set(signal.start(next: { next in
+                            subscriber.putNext(next)
+                        }, error: { error in
+                            subscriber.putError(error)
+                        }, completed: {
+                            subscriber.putCompletion()
+                        }))
+                    }, queue: queue)
+                    disposable.set(ActionDisposable {
+                        queue.async {
+                            timer.invalidate()
+                        }
+                    })
+                    timer.start()
+                }
+                
+                var invalidateImpl: (() -> Void)?
+                let timer = Timer(timeout: granularity, repeat: true, completion: {
+                    let currentTimestamp = CFAbsoluteTimeGetCurrent()
+                    if beginTimestamp + timeout >= currentTimestamp - granularity * 1.1 {
+                        invalidateImpl?()
+                        startFinalTimer()
+                    }
+                }, queue: queue)
+                
+                invalidateImpl = {
+                    queue.async {
+                        timer.invalidate()
+                    }
+                }
+                
+                disposable.set(ActionDisposable {
+                    invalidateImpl?()
+                })
+                
+                timer.start()
+            }
+            return disposable
+        }
+    }
+}
+
 public func timeout<T, E>(_ timeout: Double, queue: Queue, alternate: Signal<T, E>) -> (Signal<T, E>) -> Signal<T, E> {
     return { signal in
         return Signal<T, E> { subscriber in