Download de SDKs de ferrugem - download do código-fonte de SDKs de ferrugem

SDKs de ferrugem

Outro código-fonte

v0.7.0

Baixar

SDK do cliente Rust para LiveKit

Use este SDK para adicionar recursos de vídeo, áudio e dados em tempo real ao seu aplicativo Rust. Ao conectar-se ao LiveKit Cloud ou a um servidor auto-hospedado, você pode criar rapidamente aplicativos como IA multimodal, transmissão ao vivo ou chamadas de vídeo com apenas algumas linhas de código.

Características

Caixas

livekit-api : APIs de servidor e geração de token de autenticação
livekit : SDK em tempo real do LiveKit
livekit-ffi : Caixa interna, usada para gerar ligações para outras linguagens
livekit-protocol : código gerado pelo protocolo LiveKit

Ao adicionar o SDK como uma dependência ao seu projeto, certifique-se de adicionar os rustflags necessários à sua configuração de carga, caso contrário, a vinculação poderá falhar.

Além disso, consulte a lista de kits de ferramentas de plataforma suportados.

Começando

Atualmente, o Tokio é obrigado a usar este SDK, no entanto, planejamos tornar o tempo de execução do executor assíncrono agnóstico.

Usando API do servidor

Gerando um token de acesso

 use livekit_api::access_token;use std::env;fn create_token() -> Result {let api_key = env::var("LIVEKIT_API_KEY").expect("LIVEKIT_API_KEY não está definido") ;let api_secret = env::var("LIVEKIT_API_SECRET").expect("LIVEKIT_API_SECRET não está definido");let token = access_token::AccessToken::with_api_key(&api_key, &api_secret).with_identity("rust-bot").with_name ("Rust Bot").with_grants(access_token::VideoGrants { room_join: true, room: "my-room".to_string(), ..Default::default()}).to_jwt();return token}

Criando uma sala com RoomService API

 use livekit_api::services::room::{CreateRoomOptions, RoomClient};#[tokio::main]async fn main() {let room_service = RoomClient::new("http://localhost:7880").unwrap( );let room = room_service.create_room("my_room", CreateRoomOptions::default()).await.unwrap();println!("Sala criada: {:?}", room);}

Usando SDK em tempo real

Conecte-se a uma sala e ouça eventos:

 use livekit::prelude::*;#[tokio::main]async fn main() -> Result<()> {let (room, mut room_events) = Room::connect(&url, &token).await?; while let Some(event) = room_events.recv().await {match event {RoomEvent::TrackSubscribed { faixa, publicação, participante } => {// ...}_ => {}}}Ok(()) }

Receba frames de vídeo de uma faixa inscrita

 ...use futuros::StreamExt; // esta característica é necessária para iterar em frames de áudio e vídeouse livekit::prelude::*;match event {RoomEvent::TrackSubscribed { track, publicação, participante } => {match track {RemoteTrack::Audio(audio_track) => {let rtc_track = audio_track.rtc_track();let mut audio_stream = NativeAudioStream::new(rtc_track);tokio::spawn(async move {// Receba os quadros de áudio em uma nova tarefa, enquanto let Some(audio_frame) = audio_stream.next( ).await {log::info!("frame de áudio recebido - {audio_frame:#?}");}});},RemoteTrack::Video(video_track) => {let rtc_track = video_track.rtc_track();let mut video_stream = NativeVideoStream::new(rtc_track);tokio::spawn(async move {// Receba os quadros de vídeo em uma nova tarefa, enquanto let Some(video_frame) = video_stream.next().await {log::info!(" quadro de vídeo recebido - {video_frame:#?}");}});},}},_ => {}}

Exemplos

sala básica: exemplo simples de conexão com uma sala.
wgpu_room: aplicativo de exemplo completo com renderização de vídeo usando wgpu e egui.
mobile: aplicativo móvel direcionado a iOS e Android
play_from_disk: publica áudio de um arquivo wav
save_to_disk: salva o áudio recebido em um arquivo wav

Motivação e metas de design

O LiveKit tem como objetivo fornecer uma pilha WebRTC de código aberto de ponta a ponta que funcione em qualquer lugar. Temos dois objetivos em mente com este SDK:

Crie um SDK cliente LiveKit independente e multiplataforma para Rustaceans.
Crie um núcleo comum para outros SDKs específicos de plataforma (por exemplo, Unity, Unreal, iOS, Android)

Em relação a (2), já desenvolvemos vários SDKs clientes para diversas plataformas e encontramos alguns desafios no processo:

Há uma quantidade significativa de lógica de negócios/controle em nosso protocolo de sinalização e WebRTC. Atualmente, essa lógica precisa ser implementada em todas as novas plataformas que apoiamos.
As interações com dispositivos de mídia e codificação/decodificação são específicas para cada plataforma e estrutura.
Para frameworks multiplataforma (por exemplo, Unity, Flutter, React Native), as tarefas acima mencionadas provaram ser extremamente penosas.

Assim, postulamos um Rust SDK, algo que queríamos construir de qualquer maneira, encapsulando toda a nossa lógica de negócios e APIs específicas da plataforma em um conjunto limpo de abstrações, que também poderia servir como base para nossos outros SDKs!

Primeiro, vamos usá-lo como base para nosso SDK do Unity (em desenvolvimento), mas com o tempo, ele também alimentará nossos outros SDKs.

Ecossistema LiveKit
SDKs em tempo real	Componentes React · Navegador · Componentes Swift · iOS/macOS/visionOS · Android · Flutter · React Native · Rust · Node.js · Python · Unity (web) · Unity (beta)

APIs de servidor	Node.js · Golang · Ruby · Java/Kotlin · Python · Rust · PHP (comunidade)

Estruturas de Agentes	Python · Parque infantil

Serviços	Servidor LiveKit · Saída · Entrada · SIP

Recursos	Documentos · Aplicativos de exemplo · Nuvem · Auto-hospedagem · CLI