Data packets¶

@room.on("data_received")
def on_data_received(data: rtc.DataPacket):
logging.info("received data from %s: %s", data.participant.identity, data.data)

# string payload will be encoded to bytes with UTF-8
await room.local_participant \
.publish_data("my payload",
                reliable=True,
                destination_identities=["identity1", "identity2"],
                topic="topic1")

const strData = JSON.stringify({some: "data"})
const encoder = new TextEncoder()
const decoder = new TextDecoder()

// publishData takes in a Uint8Array, so we need to convert it
const data = encoder.encode(strData);

// Publish lossy data to the entire room
room.localParticipant.publishData(data, {reliable: false})

// Publish reliable data to a set of participants
room.localParticipant.publishData(data, {reliable: true, destinationIdentities: ['my-participant-identity']})

// Receive data from other participants
room.on(RoomEvent.DataReceived, (payload: Uint8Array, participant: Participant, kind: DataPacket_Kind) => {
const strData = decoder.decode(payload)
...
})

import LiveKit

public class DataExample {
    func publishData(localParticipant: LocalParticipant, destinationIdentities: [Participant.Identity]) async throws {
        let someVal = "your value"

        // Publish lossy data to the entire room
        let options1 = DataPublishOptions(reliable: false)
        try await localParticipant.publish(data: someVal.data(using: .utf8), options: options1)

        // Publish reliable data to a set of participants
        let options2 = DataPublishOptions(reliable: true, destinationIdentities: destinationIdentities)
        try await localParticipant.publish(data: someVal.data(using: .utf8), options: options2)
    }
}

extension DataExample: RoomDelegate {
    func room(_ room: Room, participant: RemoteParticipant?, didReceiveData data: Data, forTopic topic: String) {
        // Received data
    }
}

// Publishing data
coroutineScope.launch {
val data: ByteArray = //...

// Publish lossy data to the entire room
room.localParticipant.publishData(data, DataPublishReliability.LOSSY)

// Publish reliable data to a set of participants
val identities = listOf(
    Participant.Identity("alice"),
    Participant.Identity("bob"),
)
room.localParticipant.publishData(data, DataPublishReliability.RELIABLE, identities)
}

// Processing received data
coroutineScope.launch {
room.events.collect { event ->
    if(event is RoomEvent.DataReceived) {
        // Process data
    }
}
}

class DataExample {
Room room;
late final _listener = room.createListener();

DataExample() {
    _listener.on<DataReceivedEvent>((e) {
    // Process received data: e.data
    })
}

void publishData() {
    // publish lossy data to the entire room
    room.localParticipant.publishData(data, reliable: false);

    // publish reliable data to a set of participants with a specific topic
    room.localParticipant.publishData(data,
            reliable: true,
            destinationIdentities: ["identity1", "identity2"],
            topic: "topic1");
}

void dispose() {
    _listener.dispose();
}
}

room := lksdk.ConnectToRoom(
    url,
    info,
    &lksdk.RoomCallback{
        OnDataReceived: func(data []byte, rp *lksdk.RemoteParticipant) {
            // Process received data
        },
    },
)

// Publish lossy data to the entire room
room.LocalParticipant.PublishDataPacket(lksdk.UserData(data))

// Publish reliable data to a set of participants
room.LocalParticipant.PublishDataPacket(
    lksdk.UserData(data),
    lksdk.WithDataPublishReliable(true),
    lksdk.WithDataPublishDestination([]string{"alice", "bob"}),
)

yield return room.LocalParticipant.PublishData(data, DataPacketKind.RELIABLE, participant1, participant2);

room.DataReceived += (data, participant, kind) =>
{
    // Process received data
};