feat: Data Tracks

.changeset/data-tracks.md

@@ -0,0 +1,19 @@
+---
+"client-sdk-android": minor
+---
+
+Add data tracks, a named channel for streaming structured frames to a room.
+
+Publish with `LocalParticipant.publishDataTrack` (or `withDataTrack` to scope a publication to a
+block), then push frames with `LocalDataTrack.tryPush` or `send`. Subscribers find published tracks
+through `RemoteParticipant.dataTracks` or the new `RoomEvent.DataTrackPublished` /
+`DataTrackUnpublished` events, and call `RemoteDataTrack.subscribe` for a `DataTrackStream` of
+incoming frames.
+
+Frame formats are declared through `DataTrackPublishOptions` using `DataTrackFrameEncoding`
+(protobuf, flatbuffer, CDR, ROS 1, CBOR, msgpack, JSON), and schema definitions can be shared
+with `LocalParticipant.defineSchema` / `getSchema`. Frames are end-to-end encrypted when E2EE
+is enabled on the room.
+
+This adds a dependency on `io.livekit:livekit-uniffi-android`, containing the shared Rust core also
+used by the other native SDKs.

gradle/libs.versions.toml

@@ -32,8 +32,11 @@ noise = "2.0.0"
 lifecycleProcess = "2.8.7"
 agp = "8.7.2"
 kotlin = "1.9.25"
+livekit-uniffi = "0.1.12"
 
 [libraries]
+livekit-uniffi = { module = "io.livekit:livekit-uniffi-android", version.ref = "livekit-uniffi" }
+
 android-jain-sip-ri = { module = "javax.sip:android-jain-sip-ri", version.ref = "androidJainSipRi" }
 androidx-activity-ktx = { module = "androidx.activity:activity-ktx", version.ref = "androidx-activity" }
 androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "androidx-camera" }

livekit-android-sdk/build.gradle

@@ -118,6 +118,7 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation libs.coroutines.lib
     implementation libs.kotlinx.serialization.json
+    implementation libs.livekit.uniffi
     api libs.webrtc
     api libs.okhttp.lib
     implementation libs.okhttp.coroutines

livekit-android-sdk/src/main/AndroidManifest.xml

@@ -31,3 +31,4 @@
             android:stopWithTask="true" />
     </application>
 </manifest>
+

livekit-android-sdk/src/main/java/io/livekit/android/dagger/InternalBindsModule.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 LiveKit, Inc.
+ * Copyright 2025-2026 LiveKit, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,8 @@ import io.livekit.android.room.datastream.incoming.IncomingDataStreamManager
 import io.livekit.android.room.datastream.incoming.IncomingDataStreamManagerImpl
 import io.livekit.android.room.datastream.outgoing.OutgoingDataStreamManager
 import io.livekit.android.room.datastream.outgoing.OutgoingDataStreamManagerImpl
+import io.livekit.android.room.datatrack.IncomingDataTrackManager
+import io.livekit.android.room.datatrack.IncomingDataTrackManagerImpl
 
 /**
  * @suppress
@@ -33,4 +35,7 @@ abstract class InternalBindsModule {
 
     @Binds
     abstract fun outgoingDataStreamManager(manager: OutgoingDataStreamManagerImpl): OutgoingDataStreamManager
+
+    @Binds
+    internal abstract fun incomingDataTrackManager(manager: IncomingDataTrackManagerImpl): IncomingDataTrackManager
 }

livekit-android-sdk/src/main/java/io/livekit/android/dagger/RTCModule.kt

@@ -36,6 +36,8 @@ import io.livekit.android.audio.NoAudioRecordPrewarmer
 import io.livekit.android.e2ee.DataPacketCryptorManager
 import io.livekit.android.e2ee.DataPacketCryptorManagerImpl
 import io.livekit.android.memory.CloseableManager
+import io.livekit.android.room.datatrack.LocalDataTrackManagerFactory
+import io.livekit.android.room.datatrack.RemoteDataTrackManagerFactory
 import io.livekit.android.util.LKLog
 import io.livekit.android.util.LoggingLevel
 import io.livekit.android.webrtc.CustomAudioProcessingFactory
@@ -46,6 +48,8 @@ import io.livekit.android.webrtc.peerconnection.RTCThreadToken
 import io.livekit.android.webrtc.peerconnection.RTCThreadTokenImpl
 import io.livekit.android.webrtc.peerconnection.executeBlockingOnRTCThread
 import io.livekit.android.webrtc.peerconnection.executeOnRTCThread
+import io.livekit.uniffi.LocalDataTrackManager
+import io.livekit.uniffi.RemoteDataTrackManager
 import livekit.org.webrtc.AudioProcessingFactory
 import livekit.org.webrtc.EglBase
 import livekit.org.webrtc.Logging
@@ -384,6 +388,20 @@ internal object RTCModule {
         return DataPacketCryptorManagerImpl.Factory
     }
 
+    @Provides
+    fun localDataTrackManagerFactory(): LocalDataTrackManagerFactory {
+        return LocalDataTrackManagerFactory { delegate, encryptionProvider ->
+            LocalDataTrackManager(delegate, encryptionProvider)
+        }
+    }
+
+    @Provides
+    fun remoteDataTrackManagerFactory(): RemoteDataTrackManagerFactory {
+        return RemoteDataTrackManagerFactory { delegate, decryptionProvider ->
+            RemoteDataTrackManager(delegate, decryptionProvider)
+        }
+    }
+
     @Provides
     @Singleton
     fun peerConnectionFactory(

livekit-android-sdk/src/main/java/io/livekit/android/e2ee/DataTrackCryptor.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2026 LiveKit, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.livekit.android.e2ee
+
+import io.livekit.android.room.participant.Participant
+import uniffi.livekit_datatrack.DecryptionException
+import uniffi.livekit_datatrack.DecryptionProvider
+import uniffi.livekit_datatrack.EncryptedPayload
+import uniffi.livekit_datatrack.EncryptionException
+import uniffi.livekit_datatrack.EncryptionProvider
+
+/**
+ * Bridges UniFFI data-track [EncryptionProvider] / [DecryptionProvider] to [E2EEManager].
+ *
+ * Adds no key handling of its own — encryption rides [E2EEManager]'s existing AES-GCM data path
+ * (the same [DataPacketCryptorManager] used for data-channel payloads). The manager is resolved
+ * per call so one assigned after connecting still applies.
+ */
+internal class DataTrackCryptor(
+    private val e2eeManagerProvider: () -> E2EEManager?,
+) : EncryptionProvider, DecryptionProvider {
+
+    override fun encrypt(payload: ByteArray): EncryptedPayload {
+        val manager = requireManager { message -> EncryptionException.Failed(message) }
+        val packet = manager.encrypt(payload)
+            ?: throw EncryptionException.Failed("Failed to encrypt data track payload")
+        return EncryptedPayload(
+            payload = packet.payload,
+            iv = packet.iv,
+            keyIndex = packet.keyIndex.toUByte(),
+        )
+    }
+
+    override fun decrypt(payload: EncryptedPayload, senderIdentity: String): ByteArray {
+        val manager = requireManager { message -> DecryptionException.Failed(message) }
+        val packet = EncryptedPacket(
+            payload = payload.payload,
+            iv = payload.iv,
+            keyIndex = payload.keyIndex.toInt(),
+        )
+        return manager.decrypt(Participant.Identity(senderIdentity), packet)
+            ?: throw DecryptionException.Failed("Failed to decrypt data track payload")
+    }
+
+    private fun <T : Exception> requireManager(failed: (String) -> T): E2EEManager {
+        return e2eeManagerProvider()
+            ?: throw failed("Room has no E2EE manager")
+    }
+}

livekit-android-sdk/src/main/java/io/livekit/android/e2ee/E2EEManager.kt

@@ -32,6 +32,7 @@ import io.livekit.android.room.track.RemoteVideoTrack
 import io.livekit.android.room.track.Track
 import io.livekit.android.room.track.TrackPublication
 import io.livekit.android.util.LKLog
+import livekit.LivekitModels.Encryption
 import livekit.org.webrtc.FrameCryptor
 import livekit.org.webrtc.FrameCryptor.FrameCryptionState
 import livekit.org.webrtc.FrameCryptorAlgorithm
@@ -73,6 +74,16 @@ constructor(
         return enabled && dataChannelEncryptionEnabled
     }
 
+    /**
+     * Whether data-track frames should be encrypted: the runtime flag plus a configured
+     * encryption type (unlike the data-channel gate, which also requires
+     * [dataChannelEncryptionEnabled]).
+     */
+    internal fun isDataTrackEncryptionEnabled(): Boolean {
+        val type = room?.e2eeOptions?.encryptionType ?: return false
+        return enabled && type != Encryption.Type.NONE
+    }
+
     fun keyProvider(): KeyProvider {
         return this.keyProvider
     }

livekit-android-sdk/src/main/java/io/livekit/android/events/ParticipantEvent.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2025 LiveKit, Inc.
+ * Copyright 2023-2026 LiveKit, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
 
 package io.livekit.android.events
 
+import io.livekit.android.room.datatrack.DataTrackSid
+import io.livekit.android.room.datatrack.RemoteDataTrack
 import io.livekit.android.room.participant.LocalParticipant
 import io.livekit.android.room.participant.Participant
 import io.livekit.android.room.participant.ParticipantPermission
@@ -120,6 +122,22 @@ sealed class ParticipantEvent(open val participant: Participant) : Event() {
     class TrackUnpublished(override val participant: RemoteParticipant, val publication: RemoteTrackPublication) :
         ParticipantEvent(participant)
 
+    /**
+     * A [RemoteParticipant] published a data track.
+     */
+    class DataTrackPublished(
+        override val participant: RemoteParticipant,
+        val track: RemoteDataTrack,
+    ) : ParticipantEvent(participant)
+
+    /**
+     * A [RemoteParticipant] unpublished a data track.
+     */
+    class DataTrackUnpublished(
+        override val participant: RemoteParticipant,
+        val sid: DataTrackSid,
+    ) : ParticipantEvent(participant)
+
     /**
      * Subscribed to a new track
      */

livekit-android-sdk/src/main/java/io/livekit/android/events/RoomEvent.kt

@@ -19,6 +19,8 @@ package io.livekit.android.events
 import io.livekit.android.annotations.Beta
 import io.livekit.android.e2ee.E2EEState
 import io.livekit.android.room.Room
+import io.livekit.android.room.datatrack.DataTrackSid
+import io.livekit.android.room.datatrack.RemoteDataTrack
 import io.livekit.android.room.participant.ConnectionQuality
 import io.livekit.android.room.participant.LocalParticipant
 import io.livekit.android.room.participant.Participant
@@ -156,6 +158,41 @@ sealed class RoomEvent(val room: Room) : Event() {
     class TrackUnpublished(room: Room, val publication: TrackPublication, val participant: Participant) :
         RoomEvent(room)
 
+    /**
+     * A [RemoteParticipant] published a data track.
+     *
+     * Fires for every track, including those already published when this participant was
+     * first seen and those reattached after a full reconnect.
+     *
+     * Collect frames in a separate coroutine so this event collector is not blocked.
+     *
+     * ```
+     * room.events.collect { event ->
+     *     if (event is RoomEvent.DataTrackPublished) {
+     *         scope.launch {
+     *             event.track.subscribe().onSuccess { stream ->
+     *                 stream.flow.collect { frame -> process(frame.payload) }
+     *             }
+     *         }
+     *     }
+     * }
+     * ```
+     */
+    class DataTrackPublished(
+        room: Room,
+        val participant: RemoteParticipant,
+        val track: RemoteDataTrack,
+    ) : RoomEvent(room)
+
+    /**
+     * A [RemoteParticipant] unpublished a data track.
+     */
+    class DataTrackUnpublished(
+        room: Room,
+        val participant: RemoteParticipant,
+        val sid: DataTrackSid,
+    ) : RoomEvent(room)
+
     /**
      * The [LocalParticipant] has subscribed to a new track. This event will always fire as
      * long as new tracks are ready for use.