Data streams v2 uniffi

.changeset/data_streams_v2_uniffi.md

@@ -0,0 +1,13 @@
+---
+livekit: patch
+livekit-data-stream: patch
+livekit-signaling: patch
+livekit-ffi: patch
+livekit-uniffi: patch
+livekit-datatrack: patch
+livekit-net: patch
+livekit-token-source: patch
+livekit-api: patch
+---
+
+Add data streams v2 to exposed uniffi interface - #1286 (@1egoman)

AGENTS.md

@@ -55,6 +55,26 @@
 - Avoid excessive nesting and prefer [`let-else`](https://doc.rust-lang.org/rust-by-example/flow_control/let_else.html)
 - Avoid long parameter lists; group related inputs into a purpose-built struct when it improves readability
 
+## UniFFI integration
+
+Several crates export items to Swift/Kotlin/Node/Python through UniFFI — `livekit-uniffi`, plus `livekit-common`, `livekit-datatrack`, and `livekit-net`, each carrying its own `uniffi.toml`. The Kotlin bindgen has sharp edges that `cargo build`, `cargo test`, and the Swift/Node/Python bindings do **not** catch: they surface only when the generated Kotlin is compiled, and one bad name fails the entire generated file.
+
+- Verify any change to UniFFI-exported API by actually generating and compiling the Kotlin bindings (`cargo make android-package` from `livekit-uniffi/`) — a green `cargo build` proves nothing here
+- **Never export a method named `close`**
+  - UniFFI gives every object a non-`suspend` `close()` to satisfy `AutoCloseable`. An exported Rust method also called `close` differs from it only by `suspend`, which Kotlin rejects as conflicting overloads — see [mozilla/uniffi-rs#2955](https://github.com/mozilla/uniffi-rs/issues/2955)
+  - Work around it with a Kotlin-only rename, so the Rust source and the Swift/Node/Python bindings keep the original name:
+    ```toml
+    [bindings.kotlin.rename]
+    "ByteStreamWriter.close" = "close_stream"
+    ```
+  - The rename must go in the `uniffi.toml` of the crate that **declares** the item, not in `livekit-uniffi/uniffi.toml`: a rename table only reaches items from the crate that owns it. `WsConnection.close` is renamed in `livekit-net/uniffi.toml` for exactly this reason
+- **Never name a field of an exported enum or record `message`**
+  - For an error variant carrying a `message` field, UniFFI emits a constructor property `message` next to an `override val message` inherited from `Throwable` in one class body, which does not compile — and their types differ (`String` vs `String?`), so they cannot be merged into a single override. See [mozilla/uniffi-rs#2938](https://github.com/mozilla/uniffi-rs/issues/2938), closed without a fix
+  - Unlike `close`, this **cannot** be renamed away: UniFFI keys the rename table by crate name but looks up enum and record members by the item's full module path, so a rename for anything declared in a submodule is silently ignored (method renames use the crate name and do work)
+  - Name the field `reason` in Rust instead — see `DataStreamError` in `livekit-uniffi/src/data_stream/common.rs`
+- A new crate that exports UniFFI items needs its own `uniffi.toml`, including `omit_checksums = true` under `[bindings.kotlin]`
+  - The Kotlin checksum test is broken on ARM in every UniFFI release this workspace can use; the full explanation lives in `livekit-uniffi/uniffi.toml` and the root `Cargo.toml`
+
 ## Documenting changes
 
 - Changes are documented using [_knope_](https://knope.tech)

Cargo.toml

@@ -92,6 +92,15 @@ serde_json = "1.0"
 thiserror = "2"
 tokio = { version = "1", default-features = false }
 tokio-stream = "0.1"
+# Test on a 64-bit ARM device before you change this version.
+#
+# The Kotlin bindings from uniffi 0.31.2 and 0.32.0 compare each checksum incorrectly on 64-bit
+# ARM. Every affected method then fails. See https://github.com/mozilla/uniffi-rs/pull/2897, which
+# introduced the defect. Version 0.31.1 has a related defect on 32-bit ARM, and it also does not
+# build here, because uniffi-dart requires 0.31.2 or later. mozilla/uniffi-rs#2935 corrects both
+# defects, but no release (as of mid august 2026) contains that change.
+#
+# For this reason, livekit-uniffi sets `omit_checksums` for Kotlin. See livekit-uniffi/uniffi.toml.
 uniffi = "0.31"
 
 # For examples

livekit-data-stream/src/incoming/events.rs

@@ -17,7 +17,7 @@ use livekit_common::ParticipantIdentity;
 
 use crate::{
     incoming::AnyStreamReader,
-    types::{Chunk, Packet, Trailer},
+    types::{Chunk, Packet, StreamId, Trailer},
 };
 
 pub struct PacketReceived {
@@ -39,6 +39,14 @@ pub enum InputEvent {
     PacketReceived(PacketReceived),
     /// Abort every open stream sent by this participant (they disconnected mid-send).
     AbortStreamsFrom(ParticipantIdentity),
+    /// Abort every open stream (e.g. the local connection is going away). Unlike
+    /// [`InputEvent::Shutdown`], the run loop keeps going so streams opened later are still handled.
+    AbortAllStreams,
+    /// Reply with the number of currently open streams (registered by a header and awaiting more
+    /// packets). Processed in order with the other events, so the answer reflects everything
+    /// enqueued before it.
+    #[from_variants(skip)]
+    QueryOpenStreamCount(tokio::sync::oneshot::Sender<usize>),
     /// Stop the run loop.
     Shutdown,
 }
@@ -50,6 +58,20 @@ pub struct StreamOpened {
     pub participant_identity: ParticipantIdentity,
 }
 
+/// A stream previously announced via [`StreamOpened`] has terminated and will produce no further
+/// data: its trailer arrived, its inline payload completed, it failed with an error, or it was
+/// aborted.
+///
+/// Emitted exactly once per opened stream. Hosts delivering streams on ordered topics use this to
+/// know when a stream's handler can be considered finished on the wire (a trailer alone is not
+/// enough: inline single-packet streams never receive one).
+pub struct StreamClosed {
+    pub stream_id: StreamId,
+    pub participant_identity: ParticipantIdentity,
+    /// Topic the stream was opened on.
+    pub topic: String,
+}
+
 /// A "raw chunk received" notification, which is used to trigger
 /// the deprecated [RoomEvent:::StreamChunkReceived] event.
 pub struct ChunkReceived {
@@ -79,6 +101,7 @@ pub struct TrailerReceived {
 #[derive(FromVariants)]
 pub enum OutputEvent {
     StreamOpened(StreamOpened),
+    StreamClosed(StreamClosed),
     ChunkReceived(ChunkReceived),
     TrailerReceived(TrailerReceived),
 }