Swift's Concurrency makes working with asynchronous tasks through async/await a breeze. Hooking up a loading state for one task is just as easy. But what if you have multiple tasks running? Tracking one single loading state in those cases is a bit harder.
TaskLoadingAggregate makes this a breeze by creating a loading state aggregate for your tasks. Each tracked task will report their status to the aggregate and as long as a task is loading the aggregate will report isLoading as true.
Hooking up a task to a TaskLoadingAggregate is as simple as:
let loadingAggregate = TaskLoadingAggregate()
// First task
Task {
try await doSomething()
}.track(loadingAggregate)
// Second task
Task {
try await doSomethingElse()
}.track(loadingAggregate)
// You can now bind your UI or whatever to loadingAggregate's @Published isLoading property 🚀
ActivityIndicator(isAnimating: loadingAggregate.isLoading, style: .large)
// And as @Published is a `Published<Bool>` you can use Combine to do whatever:
loadingAggregate.$isLoading
.sink { isLoading in
if isLoading {
doSomething()
} else {
doSomethingElse()
}
}
.store(in: &cancellables)No, you can use a TaskLoadingAggregate however you like, but then it is up to you to increment and decrement the aggregates loading counter:
let loadingAggregate = TaskLoadingAggregate()
// In async function
func doSomething() async {
loadingAggregate.increment()
await doSomethingElse()
loadingAggregate.decrement()
}
// In classic closure
loadingAggregate.increment()
self.doSomething(completion: {
loadingAggregate.decrement()
})
TaskLoadingAggregate is generously distributed under the MIT.