Colete Flows a partir do Swift

A Kotlin Flow emits many values over time. Swift has no built-in way to collect it, so you need a small bridge.

Await fits a single result, but a Flow is a stream. You must keep listening, which means collecting inside a coroutine.

A common pattern is a shared helper that takes a callback and collects the Flow, calling Swift each time a value arrives.

On the Swift side, an ObservableObject holds the latest value as a published property so SwiftUI redraws on each emission.

When the wrapper appears, call the shared watch helper and assign each emitted value to the published property.

The collect helper returns a cancellation handle. Store that job so you can stop the stream when the view goes away.

In onDisappear, call cancel on the saved job so the coroutine stops and you avoid a leaked, forever-running collector.

A StateFlow always holds a current value, so Swift can read its initial state immediately before any new emissions arrive.

Make sure each value reaches Swift on the main thread, since updating SwiftUI state off the main thread causes problems.

The library SKIE turns Flows into Swift AsyncSequence, so you can for-await over them and skip writing manual collectors.

With the bridge in place, your shared Flow drives SwiftUI live: every emission updates the screen, just like on Android.

Let us confirm the safe way to consume a Flow from Swift.

Bridge a Flow to Swift with a collect helper plus an ObservableObject, update on the main thread, and cancel the job to avoid leaks. 🚀