SwiftUI stops updates during scrolling of List

Question

Given a List in SwiftUI, once panning begins, updating of views in the list seems to pause until the scrolling has been stopped. Is there a way to prevent this?

Consider the following code:

class Model: ObservableObject, Identifiable {
    @Published var offset: CGFloat = 0

    let id = UUID()
    private var timer: Timer!

    init() {
        timer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true, block: { _ in
            self.update()
        })
    }

    func update() {
        offset = CGFloat.random(in: 0...300)
    }
}

struct ContentView: View {
    @ObservedObject var model1 = Model()
    @ObservedObject var model2 = Model()
    @ObservedObject var model3 = Model()
    @ObservedObject var model4 = Model()

    var body: some View {
        List {
            ForEach([model1, model2, model3, model4]) {
                Rectangle()
                    .foregroundColor(.red)
                    .frame(width: $0.offset, height: 30, alignment: .center)
                    .animation(.default)
            }
        }
    }
}

Will result in this behaviour:

i am not sure, but i don't think this is possible with SwiftUI. it might work with UIKit... — Chris, Apr 02 '20 at 09:22
im coming to this, kinda figured while using a custom Activity Indicator.. and it Feels weird as it stops while the user scrolls :/.. to provide a smooth feel... I should keep running while scrolling..... Glad I found this question.... — lorenzo gonzalez, Feb 28 '23 at 06:58

score 14 · Answer 1 · answered Apr 02 '20 at 19:08

You could use GCD as in Asperi's answer, but that doesn't explain why your code didn't work.

The problem is that, while the scroll view is tracking your touch, it runs the run loop in the .tracking mode. But because you created your Timer using scheduledTimer(withTimeInterval:repeats:block:), the Timer is only set to run in the .default mode.

You could add the timer to all the common run loop modes (which include .tracking) like this:

RunLoop.main.add(timer, forMode: .common)

But I would probably use a Combine publisher instead, like this:

class Model: ObservableObject, Identifiable {
    @Published var offset: CGFloat = 0

    let id = UUID()

    private var tickets: [AnyCancellable] = []

    init() {
        Timer.publish(every: 0.5, on: RunLoop.main, in: .common)
            .autoconnect()
            .map { _ in CGFloat.random(in: 0...300) }
            .sink { [weak self] in self?.offset = $0 }
            .store(in: &tickets)
    }
}

score 6 · Accepted Answer · answered Apr 02 '20 at 09:57

6

This due to nature of Timer and RunLoop. Use instead GCD, like in below approach

demo

init() {
    var runner: (() -> ())?
    runner = {
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in
            if let self = self {
                self.update()
                runner?()
            }
        }
    }
    runner?()
}

answered Apr 02 '20 at 09:57

Asperi

228,894
20
464
690

Thanks! Very useful thing to know! – Kevin R Apr 02 '20 at 13:52

SwiftUI stops updates during scrolling of List

2 Answers2