Episode #218: How do you persist the data when the debounce gets omitted in the background?

[ylorn]

Just finished watching the latest episode of Modern SwiftUI: Effects, Part 2.

In the last section of this episode, an optimization of the persistence is made to avoid unnecessary accessing to the standups.json file by using a debounce Combine operator:

self.standupsCancellable = self.$standups
  .dropFirst()
+  .debounce(
+    for: .seconds(1), scheduler: DispatchQueue.main
+  )
  .sink { standups in
    …
  }

But from my experience, if the self.$standups publishes an update when the App is in background, then the debounce operator simply omits the update, which means the standups.json never gets updated with that update.

Demo Code:

import Combine
import SwiftUI

class ContentViewModel {
    private var cancellables: Set<AnyCancellable> = []
    
    init() {
        NotificationCenter.default
            .publisher(for: UIApplication.didBecomeActiveNotification)
            .sink { _ in
                print("foregrounded")
            }
            .store(in: &self.cancellables)
        
        NotificationCenter.default
            .publisher(for: UIApplication.didEnterBackgroundNotification)
            .sink { _ in
                print("backgrounded")
            }
            .store(in: &self.cancellables)
    }
}

struct ContentView: View {
    var model: ContentViewModel = .init()
    
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundColor(.accentColor)
            Text("Hello, world!")
        }
        .padding()
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

With code above, when foregrounding the app, the console prints

foregrounded

when backgrounding the app, the console prints

backgrounded

However, if we add the debounce logic to the 2 subscriptions:

    init() {
        NotificationCenter.default
            .publisher(for: UIApplication.didBecomeActiveNotification)
+            .debounce(for: .seconds(1), scheduler: DispatchQueue.main)
            .sink { _ in
                print("foregrounded")
            }
            .store(in: &self.cancellables)
        
        NotificationCenter.default
            .publisher(for: UIApplication.didEnterBackgroundNotification)
+            .debounce(for: .seconds(1), scheduler: DispatchQueue.main)
            .sink { _ in
                print("backgrounded")
            }
            .store(in: &self.cancellables)
    }

With the debounce logic, when foregrounding the app, the console still prints

foregrounded

However, when backgrounding the app, this time, nothing gets printed, where it should print backgrounded just like before the change.

How do you cover this case to keep the persistence?

[jshier]

Most likely you need to combine the debounce with a background assertion to ensure the debounce's underlying timer is allowed to execute in the background. I haven't tested it but it's a pretty typical failure for background execution. This may also just be the case for any async execution, as debounce makes the synchronous notification async.

[ylorn]

combine the debounce with a background assertion to ensure the debounce's underlying timer is allowed to execute in the background

How can this be achieved?

[mbrandonw]

Hi @ylorn, I suppose you could also listen for background notifications and save again there:

NotificationCenter.default
  .publisher(for: UIApplication.didEnterBackgroundNotification)
  .sink { standups in
    do {
      try JSONEncoder().encode(standups).write(to: .standups)
    } catch {
    }
  }
  .store(in: &self.cancellables)

You can also write a test for this by posting the didEnterBackgroundNotification notification while the debounce is in flight.

[ylorn]

I guess I am not looking for a keep-alive-in-background solution, I am perfectly fine if the App gets hung by the system within a short amount of time after it goes background as iOS does nowadays. Just wondering if there is a way to make debounce work within that short amount of time instead being totally non-responsive.
For example, in the episode, we add 0.4 seconds of animation delay before saving the standup once it finishes, within that short period of time, if we put the app into background, though the standups in memory will be updated, the standups.json file won't. And the persistence is broken in that case, isn't it?

[mbrandonw]

Yeah there definitely is a window for incorrect behavior, albeit a very small window.

I'm not familiar enough with scheduling to immediately know a workaround. I wonder if runloops have different background behavior? Or perhaps an adhoc debouncing solution can be made with ContinuousClock?

[ylorn]

I tried Runloop.main but the result is the same

[JackYoustra]

Could you convert the debounce to a swift concurrency debounce? You can do something like (probably not exactly):

import AsyncAlgorithms
...

let handle = Task {
	for event in await NotificationCenter.default
	            .publisher(for: UIApplication.didBecomeActiveNotification)
				.values
	            .debounce(for: .seconds(1), clock: ContinuousClock()) {
					print("foregrounded")
	}
}
// probably want to use structured concurrency but this would be equivalent to current setup
self.taskCancellables.append(handle)

[ylorn]

@JackYoustra I tested code below:

import AsyncAlgorithms

class ContentViewModel {
    private var tasks: [Task<Void, Never>]
    
    init() {
        self.tasks = [
            Task {
                for await _ in await NotificationCenter
                    .default
                    .publisher(for: UIApplication.didBecomeActiveNotification)
                    .values
                    .debounce(for: .seconds(1), clock: ContinuousClock()) {
                    print("foregrounded")
                }
            },
            
            Task {
                for await _ in await NotificationCenter
                    .default
                    .publisher(for: UIApplication.didEnterBackgroundNotification)
                    .values
                    .debounce(for: .seconds(1), clock: ContinuousClock()) {
                    print("backgrounded")
                }
            },
        ]
    }
}

Interesting result:

The backgrounded log does not get printed until the app is foregrounded again from background, but at least the result does not get omitted this time. However, there is still a chance that the persistence gets broken when the App gets killed in the background by system/user.
Anyway, this approach does cover the half use cases for the tiny loophole spotted in the original question. Thanks!

However the ContinuousClock requires latest system, it is a little bummer that we cannot use this in older deployment target.

[ylorn]

I guess we have to live with a cumbersome solution by introduce another publisher to combine with, where we can debounce if the app is in foreground and skip the debouncing if the app is in background:

import Combine
import SwiftUI

class ContentViewModel {
    private var cancellables: Set<AnyCancellable> = []
    
    @Published private var isBackgrounded = false
    @Published var standups: IdentifiedArrayOf<Standup> = []
    
    init() {
        
        NotificationCenter.default
            .publisher(for: UIApplication.didBecomeActiveNotification)
            .map { _ in false }
            .assign(to: &self.$isBackgrounded)
        
        NotificationCenter.default
            .publisher(for: UIApplication.didEnterBackgroundNotification)
            .map { _ in true }
            .assign(to: &self.$isBackgrounded)
        
        
        self.$standups
            .combineLatest(self.$isBackgrounded)
            .filter { $0.1 == false }
            .debounce(for: .seconds(1), scheduler: DispatchQueue.main)
            .map(\.0)
            .sink { standups in
                print("debounced")
                
                do {
                    try JSONEncoder().encode(standups).write(to: .standups)
                } catch {
                }
            }
            .store(in: &self.cancellables)
        
        self.$standups
            .combineLatest(self.$isBackgrounded)
            .filter(\.1)
            .map(\.0)
            .sink { standups in
                print("no debounce")
                
                do {
                    try JSONEncoder().encode(standups).write(to: .standups)
                } catch {
                }
            }
            .store(in: &self.cancellables)
    }
}

With the additional indicator of isBackgrounded, the behavior acts as follows:

• when foregrounding the app, the debounced statement gets printed to console 1 second after app goes foreground
• when backgrounding the app, the no debounce statement gets printed immediately

[iampatbrown]

@ylorn You could also look at incorporating UIApplication beginBackgroundTask(expirationHandler:), though I think the above solution is fine.

You original example could look something like:

class ContentViewModel {
  private var cancellables: Set<AnyCancellable> = []
  private var taskId: UIBackgroundTaskIdentifier?

  init() {
    NotificationCenter.default
      .publisher(for: UIApplication.didBecomeActiveNotification)
      .debounce(for: .seconds(1), scheduler: DispatchQueue.main)
      .sink { _ in
        print("foregrounded")
      }
      .store(in: &self.cancellables)

    NotificationCenter.default
      .publisher(for: UIApplication.didEnterBackgroundNotification)
      .handleEvents(receiveOutput: { [weak self] _ in self?.beginBackgroundTaskIfNeeded() })
      .debounce(for: .seconds(1), scheduler: DispatchQueue.main)
      .sink { [weak self] _ in
        print("backgrounded")
        self?.endBackgroundTaskIfNeeded()
      }
      .store(in: &self.cancellables)
  }

  func beginBackgroundTaskIfNeeded() {
    guard self.taskId == nil else { return }
    self.taskId = UIApplication.shared.beginBackgroundTask(withName: "Blob") { [weak self] in
      self?.endBackgroundTaskIfNeeded()
    }
  }

  func endBackgroundTaskIfNeeded() {
    guard let taskId = self.taskId else { return }
    UIApplication.shared.endBackgroundTask(taskId)
    self.taskId = nil
  }
}

[ylorn]

Cool, thanks @iampatbrown ! It seems this approach debounce the given window in the background as expected, rather than being omitted or getting executed immediately compared to other solutions.