Repository navigation
Resolve a data stream send once its packets are sent - #1295
Merged
Merged
Conversation
The outgoing pump pulls a batch, sends its packets and then completes the batch, or fails it when the send throws. The core resolves the send from that outcome, so a send error reaches the caller and the pump no longer logs and drops it.
The trailer cannot be sent on a closed room, and the core now reports that. Closing is cleanup, so the failure is not passed on.
Text sent right before a disconnect still depends on the data channel draining before the connection closes, which this change does not cover.
A batch now carries its packets as a field and the outcome as a separate object to report on.
hiroshihorie
added a commit
to livekit/rust-sdks
that referenced
this pull request
Nov 18, 2026
…t them (#1691) The polled outgoing data stream adapter in `core-modules` acknowledged a send as soon as its packets were buffered. A `send_*` or `write` call resolved before anything reached the transport, transport errors were lost, and nothing slowed a producer down. Flutter is the one SDK on this adapter. It shows as unbounded memory growth on a large `sendFile` and as send errors that never reach the caller. Swift and Android pass their own delegate, which already resolves a send once the packets are handed to the data channel, and this brings Flutter to the same point. `OutgoingPacketQueue.next_packets()` is replaced by `next_batch()`, which returns an `OutgoingPacketBatch` record: the `packets`, moved out without a copy, and an `ack` object with `complete()` and `fail(reason)`. The send resolves when the host completes the ack. It fails when the ack fails, is released without an outcome, or the queue is closed. The manager already awaits each delegate call, so at most one batch is pending. The queue is split into two halves. The manager holds the sending half and the host holds `OutgoingPacketQueue`, the receiving half. Releasing the queue then drops a batch nobody pulled, which fails its send and lets the forwarding task finish. The sending half also watches the token its manager cancels on drop, so the task finishes when the manager goes away, whatever the host still holds. `outgoing.rs` gains a constructor that takes that token. Its forwarding task is unchanged, so hosts that pass their own delegate are not affected. This is a breaking change for hosts on the polled adapter, so the changeset is `livekit-ffi: major`. ### Checks - `cargo test -p livekit-ffi --no-default-features --features core-modules` passes, 78 tests. New `polled_*` tests cover the wait, a failed batch, a dropped batch, a closed queue, a queue released with an unpulled batch, a manager dropped while the host keeps the queue or a pulled batch, and 200 repeated sends that check every ack is released. - e2e-flutter on macOS against a local server, client-sdk-flutter with livekit/client-sdk-flutter#1295. Run together with the uniffi-dart pin from #1636. The table is from 37c5951, and the macOS run was repeated on the current API with the same result: | | published 0.13.4 | #1636 only | #1636 and this PR | |---|---|---|---| | 256 MiB `sendFile`, peak RSS growth | +826 MB | +147 MB | +45 MB | | `sendText` then `disconnect()`, localhost | never arrives | never arrives | arrives | | other 10 data stream and core scenarios | pass | pass | pass | The same scenarios pass on an iOS simulator and on an iPhone 17 Pro over Wi-Fi, with one exception on the phone: `sendText` then `disconnect()` is still not reliable there. A send now resolves when its packets are handed to the data channel, and Flutter's `disconnect()` does not wait for the channel to drain. The JS, Swift and Android SDKs send the Leave without that wait too, so it is a gap of its own and not part of this PR.
It has the batch acknowledgement the outgoing pump now uses, and bindings that free the native buffers of byte and string payloads.
hiroshihorie
marked this pull request as ready for review
November 19, 2026 00:51
hiroshihorie
requested review from
changt,
cloudwebrtc and
xianshijing-lk
as code owners
November 19, 2026 00:51
There was a problem hiding this comment.
🔍 Devin Review: 1 flag
Not posted on this PR by your GitHub settings — view it in Devin Review. (Configure)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Data streams (
sendText,sendBytes,sendFile,streamText,streamBytes) on native platforms had three problems since they moved to the shared Rust core:The fix is in the Rust core and shipped in
livekit_ffi0.15.0. This PR moves Flutter to that version and makes the small change needed to use it. That version also fixes a memory leak in the Dart bindings.There is no public API change, and the web is not affected.
One thing this does not fix: a message sent right before
disconnect()can still be lost on a real network. See "Not covered" below.Details
Companion to livekit/rust-sdks#1691. The dependency moves from
^0.13.4to^0.15.0, which also brings livekit/rust-sdks#1636, the bindings that free native buffers.Flutter cannot take callbacks from the Rust core's threads, so it pulls outgoing packets from a queue. That queue used to acknowledge a send the moment its packets were queued. In 0.15.0 the host acknowledges each batch itself.
nextBatch(), sends itspackets, then callsack.complete(), orack.fail()when the send throws. The core resolves the send from that. Because the pump only pulls the next batch after that, a fast producer is now paced by the data channel.Not covered
await sendText()followed at once bydisconnect()is still not reliable on a real network. A send now resolves when its packets are handed to the data channel, anddisconnect()does not wait for the channel to drain. On an iPhone over Wi-Fi a 200 KB text was cut off, and arrived with a one second pause before the disconnect. The other SDKs disconnect the same way, so that is a gap of its own.Checks
Against the published
livekit_ffi0.15.0:flutter analyzeclean, 596 unit tests pass.sendFile, peak RSS growthsendTextthendisconnect()The 826 MB figure is the same file send on macOS with
livekit_ffi0.13.4.