From e2ff8489373b03546bfe0a5e1cf9edb77d8d1e99 Mon Sep 17 00:00:00 2001
From: Ilya Laktyushin <ilya@laktyush.in>
Date: Thu, 20 Jun 2019 16:04:16 +0200
Subject: [PATCH] Fixed peers nearby updating

---
 .../TelegramCore/PeersNearby.swift            | 32 ++++++++++++++-----
 .../TelegramUI/PeersNearbyController.swift    | 14 --------
 2 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/submodules/TelegramCore/TelegramCore/PeersNearby.swift b/submodules/TelegramCore/TelegramCore/PeersNearby.swift
index 69c1d83246..d965544582 100644
--- a/submodules/TelegramCore/TelegramCore/PeersNearby.swift
+++ b/submodules/TelegramCore/TelegramCore/PeersNearby.swift
@@ -31,14 +31,15 @@ public final class PeersNearbyContext {
     private var entries: [PeerNearby]?
    
     public init(network: Network, accountStateManager: AccountStateManager, coordinate: (latitude: Double, longitude: Double)) {
-        let expiryThreshold: Double = 10.0
+        let expiryExtension: Double = 10.0
         
         let poll = network.request(Api.functions.contacts.getLocated(geoPoint: .inputGeoPoint(lat: coordinate.latitude, long: coordinate.longitude)))
         |> map(Optional.init)
         |> `catch` { _ -> Signal<Api.Updates?, NoError> in
             return .single(nil)
         }
-        |> mapToSignal { updates -> Signal<[PeerNearby], NoError> in
+        |> introduceError(Void.self)
+        |> mapToSignal { updates -> Signal<[PeerNearby], Void> in
             var peersNearby: [PeerNearby] = []
             if let updates = updates {
                 switch updates {
@@ -56,18 +57,31 @@ public final class PeersNearbyContext {
                 accountStateManager.addUpdates(updates)
             }
             return .single(peersNearby)
-            |> then(accountStateManager.updatedPeersNearby())
+            |> then(
+                accountStateManager.updatedPeersNearby()
+                |> introduceError(Void.self)
+            )
         }
         
-        self.disposable.set((((poll |> then(.complete() |> suspendAwareDelay(25.0, queue: self.queue))) |> restart)
+        let error: Signal<Void, Void> = .single(Void()) |> then(Signal.fail(Void()) |> suspendAwareDelay(25.0, queue: self.queue))
+        let combined = combineLatest(poll, error)
+        |> map { data, _ -> [PeerNearby] in
+            return data
+        }
+        |> restartIfError
+        |> `catch` { _ -> Signal<[PeerNearby], NoError> in
+            return .single([])
+        }
+        
+        self.disposable.set((combined
         |> deliverOn(self.queue)).start(next: { [weak self] updatedEntries in
             guard let strongSelf = self else {
                 return
             }
             
             let timestamp = CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970
-            var entries = strongSelf.entries?.filter { Double($0.expires) + expiryThreshold > timestamp } ?? []
-            let updatedEntries = updatedEntries.filter { Double($0.expires) + expiryThreshold > timestamp }
+            var entries = strongSelf.entries?.filter { Double($0.expires) + expiryExtension > timestamp } ?? []
+            let updatedEntries = updatedEntries.filter { Double($0.expires) + expiryExtension > timestamp }
             
             var existingPeerIds: [PeerId: Int] = [:]
             for i in 0 ..< entries.count {
@@ -83,7 +97,6 @@ public final class PeersNearbyContext {
             }
             
             strongSelf.entries = entries
-            
             for subscriber in strongSelf.subscribers.copyItems() {
                 subscriber(strongSelf.entries)
             }
@@ -95,7 +108,10 @@ public final class PeersNearbyContext {
             }
             
             let timestamp = CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970
-            strongSelf.entries = strongSelf.entries?.filter { Double($0.expires) + expiryThreshold > timestamp }
+            strongSelf.entries = strongSelf.entries?.filter { Double($0.expires) + expiryExtension > timestamp }
+            for subscriber in strongSelf.subscribers.copyItems() {
+                subscriber(strongSelf.entries)
+            }
         }, queue: self.queue)
         self.timer?.start()
     }
diff --git a/submodules/TelegramUI/TelegramUI/PeersNearbyController.swift b/submodules/TelegramUI/TelegramUI/PeersNearbyController.swift
index c89a59f34f..42c2a641fc 100644
--- a/submodules/TelegramUI/TelegramUI/PeersNearbyController.swift
+++ b/submodules/TelegramUI/TelegramUI/PeersNearbyController.swift
@@ -356,23 +356,9 @@ public func peersNearbyController(context: AccountContext) -> ViewController {
             }
         }
     }
-    
-//    let errorSignal: Signal<Void, Void> = .single(Void()) |> then( Signal.fail(Void()) |> suspendAwareDelay(25.0, queue: Queue.concurrentDefaultQueue()) )
-//    let combinedSignal = combineLatest(dataSignal, errorSignal) |> map { data, _ -> PeersNearbyData? in
-//        return data
-//    }
-//    |> restartIfError
-//    |> `catch` { _ -> Signal<PeersNearbyData?, NoError> in
-//        return .single(nil)
-//    } |> filter { value in
-//        return value != nil
-//    }
-//    dataPromise.set(.single(nil) |> then(combinedSignal))
-
     dataPromise.set(dataSignal)
     
     let previousData = Atomic<PeersNearbyData?>(value: nil)
-    
     let displayLoading: Signal<Bool, NoError> = .single(false) |> then(.single(true) |> delay(1.0, queue: Queue.mainQueue()))
     
     let signal = combineLatest(context.sharedContext.presentationData, dataPromise.get(), displayLoading)