rust sdks

SDK client Rust pour LiveKit

Utilisez ce SDK pour ajouter des fonctionnalités vidéo, audio et données en temps réel à votre application Rust. En vous connectant à LiveKit Cloud ou à un serveur auto-hébergé, vous pouvez rapidement créer des applications telles que l'IA multimodale, la diffusion en direct ou les appels vidéo avec seulement quelques lignes de code.

Caractéristiques

• Réception de pistes

• Publication de pistes

• Canaux de données

• Diffusion simultanée

• Codecs SVC (AV1/VP9)

• Streaming adaptatif

• Dynacast

• Enc/déc vidéo matériel

• VideoToolbox pour MacOS/iOS

• Plateformes prises en charge

• Fenêtres

• MacOS

• Linux

• IOS

• Androïde

Caisses

• livekit-api : API serveur et génération de jetons d'authentification

• livekit : SDK temps réel LiveKit

• livekit-ffi : Caisse interne, utilisée pour générer des liaisons pour d'autres langages

• livekit-protocol : code généré par le protocole LiveKit

Lorsque vous ajoutez le SDK en tant que dépendance à votre projet, assurez-vous d'ajouter les rustflags nécessaires à votre configuration cargo, sinon la liaison pourrait échouer.

Veuillez également vous référer à la liste des kits d'outils de plate-forme pris en charge.

Commencer

Actuellement, Tokio doit utiliser ce SDK, mais nous prévoyons de rendre le runtime de l'exécuteur asynchrone indépendant.

Utilisation de l'API du serveur

Générer un jeton d'accès

 utilisez livekit_api::access_token;utilisez std::env;fn create_token() -> Result<String, access_token::AccessTokenError> {let api_key = env::var("LIVEKIT_API_KEY").expect("LIVEKIT_API_KEY n'est pas défini") ;laissez api_secret = env::var("LIVEKIT_API_SECRET").expect("LIVEKIT_API_SECRET n'est pas défini");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: "ma chambre".to_string(), ..Default::default()}).to_jwt();return token}

Créer une salle avec l'API RoomService

 utilisez 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("ma_chambre", CreateRoomOptions::default()).await.unwrap();println!("Salle créée : {:?}", room);}

Utilisation du SDK en temps réel

Connectez-vous à une salle et écoutez les événements :

 utilisez 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::TrackSubscribe { track, publication, participant } => {// ...}_ => {}}}D'accord(())}

Recevoir des images vidéo d'une piste souscrite

 ...utilisez futures::StreamExt; // ce trait est requis pour itérer sur les images audio et vidéo, utilisez livekit::prelude::*;match event {RoomEvent::TrackSubscribe { track, publication, participant } => {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 {// Recevoir les images audio dans une nouvelle tâche tout en laissant Some(audio_frame) = audio_stream.next().await {log::info!("image audio reçue - {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 {// Recevoir les images vidéo dans une nouvelle tâche pendant que let Some(video_frame) = video_stream.next().await { log::info!("image vidéo reçue - {video_frame:#?}");}});},}},_ => {}}

Exemples

• pièce de base : exemple simple de connexion à une pièce.

• wgpu_room : exemple d'application complet avec rendu vidéo utilisant wgpu et egui.

• mobile : application mobile ciblant iOS et Android

• play_from_disk : publier l'audio à partir d'un fichier wav

• save_to_disk : enregistre l'audio reçu dans un fichier wav

Objectifs de motivation et de conception

LiveKit vise à fournir une pile WebRTC open source de bout en bout qui fonctionne partout. Nous avons deux objectifs en tête avec ce SDK :

1. Créez un SDK client LiveKit autonome et multiplateforme pour les Rustaceans.

2. Créer un noyau commun pour d'autres SDK spécifiques à la plate-forme (par exemple Unity, Unreal, iOS, Android)

Concernant (2), nous avons déjà développé un certain nombre de SDK clients pour plusieurs plates-formes et avons rencontré quelques défis au cours du processus :

• Il existe une quantité importante de logique commerciale/de contrôle dans notre protocole de signalisation et WebRTC. Actuellement, cette logique doit être implémentée dans chaque nouvelle plateforme que nous prenons en charge.

• Les interactions avec les appareils multimédias et l’encodage/décodage sont spécifiques à chaque plateforme et framework.

• Pour les frameworks multiplateformes (par exemple Unity, Flutter, React Native), les tâches susmentionnées se sont avérées extrêmement pénibles.

Ainsi, nous avons proposé un SDK Rust, quelque chose que nous voulions construire de toute façon, encapsulant toute notre logique métier et nos API spécifiques à la plate-forme dans un ensemble propre d'abstractions, qui pourrait également servir de base à nos autres SDK !

Nous l'utiliserons d'abord comme base pour notre SDK Unity (en cours de développement), mais au fil du temps, il alimentera également nos autres SDK.

Écosystème LiveKit
SDK en temps réel	Composants React · Navigateur · Composants Swift · iOS/macOS/visionOS · Android · Flutter · React Native · Rust · Node.js · Python · Unity (web) · Unity (bêta)
API du serveur	Node.js · Golang · Ruby · Java/Kotlin · Python · Rust · PHP (communauté)
Cadres d'agents	Python · Aire de jeux
Services	Serveur LiveKit · Sortie · Entrée · SIP
Ressources	Docs · Exemples d'applications · Cloud · Auto-hébergement · CLI