C#-Uniform Render Streaming avec WebRTC pour la messagerie texte bidirectionnelle du client Unity vers le serveur JavaScript

Activation de la communication en temps réel entre Unity et JavaScript à l'aide de WebRTC

Face à la demande croissante de communication en temps réel dans les applications, les développeurs exploitent WebRTC pour transmettre de manière transparente la vidéo, l'audio et les données. Dans ce contexte, Unity Render Streaming offre un framework puissant pour diffuser de la vidéo depuis un serveur JavaScript vers un client Unity. Cependant, l'établissement d'une communication bidirectionnelle, comme l'envoi de messages texte depuis Unity vers le serveur JavaScript, peut s'avérer difficile.

Dans ce projet, nous visons à créer une application de streaming en utilisant le plugin Unity Render Streaming ainsi que le protocole WebRTC. Bien que la partie streaming vidéo ait été configurée avec succès, l'étape suivante consiste à activer l'échange de données via un RTCDataChannel. Cela permettra d'envoyer des messages texte depuis le client Unity pendant les flux vidéo actifs.

Nous explorerons comment modifier les exemples de code existants pour répondre à ces exigences. L'application Web basée sur JavaScript gérera le streaming vidéo, tandis que le client Unity tentera de renvoyer un exemple de message tel que « Hello World » au serveur. Nous passerons en revue les défis de configuration rencontrés et leurs solutions potentielles.

Cet article aborde également des problèmes tels que les espaces de noms manquants et les références non résolues dans Unity. Nous évaluerons si le code actuel est sur la bonne voie et fournirons des solutions pour résoudre les problèmes courants, comme l'erreur liée à « SingleConnection ». À la fin, notre objectif est d'établir un pipeline de messagerie texte bidirectionnel et fluide entre Unity et JavaScript à l'aide de WebRTC.

Création d'un système de messagerie Unity vers JavaScript avec WebRTC

Le but de ce projet est d'utiliser le Streaming de rendu Unity plugin avec WebRTC pour transmettre la vidéo d'un serveur JavaScript à un client Unity, tout en renvoyant également des messages de données depuis Unity. La première étape du script JavaScript consiste à configurer un flux multimédia. Nous utilisons la méthode `captureStream()` pour diffuser du contenu vidéo à partir d'un élément HTML5, et un Connexion RTCPeer L'objet gère la connexion entre les deux pairs. Un DataChannel est créé au sein de cette connexion, ce qui permet de transmettre des données non multimédias (comme du texte) parallèlement au flux vidéo.

Côté Unity, nous initialisons la connexion WebRTC dans le script `ReceiverSample.cs` en mettant en place un Canal de données RTC. Ce canal est responsable à la fois de l'envoi et de la réception des données texte au serveur JavaScript. Une fonction coroutine est utilisée pour envoyer à plusieurs reprises le message « Hello World » toutes les deux secondes, uniquement si l'état du canal est « Ouvert ». Lorsque le DataChannel sur le serveur JavaScript reçoit un message, il enregistre le contenu sur la console pour confirmer la connexion réussie.

Un problème critique mis en évidence au cours de ce processus est la référence manquante à l'espace de noms « SingleConnection » dans le code Unity, provoquant des erreurs de compilation. Cela suggère que soit le package requis est manquant, soit qu'il existe une dépendance incorrecte dans la configuration du projet. Pour résoudre ce problème, nous vous recommandons de vérifier que toutes les dépendances nécessaires, telles que le package Unity WebRTC, sont correctement installées et référencées. Si le package n'est pas disponible, la classe devra peut-être être remplacée par un package standard. Connexion RTCPeer objet.

Enfin, le mécanisme de gestion des erreurs pour les deux scripts garantit que les échecs de connexion sont signalés dans la console, facilitant ainsi le débogage. Le script Unity inclut une fonction `StartCoroutine()` pour gérer la messagerie asynchrone, ce qui est utile pour maintenir l'échange de données en temps réel sans bloquer d'autres processus. Nous utilisons également les événements « OnOpen » et « OnClose » pour surveiller l'état du DataChannel, garantissant que les messages ne sont envoyés que lorsque la connexion est stable. Cette configuration modulaire garantit que le code peut être étendu ou modifié facilement et constitue un point de départ solide pour créer des applications de streaming plus avancées à l'aide de Unity et WebRTC.

// sendvideo.js - JavaScript Server-Side Code
import * as Logger from "../../module/logger.js";
export class SendVideo {
  constructor(localVideoElement, remoteVideoElement) {
    this.localVideo = localVideoElement;
    this.remoteVideo = remoteVideoElement;
    this.peerConnection = new RTCPeerConnection();
    this.dataChannel = this.peerConnection.createDataChannel("myDataChannel");
  }
  async startLocalVideo() {
    const stream = document.createElement('video').captureStream();
    this.localVideo.srcObject = stream;
    await this.localVideo.play();
    this.peerConnection.createOffer().then(offer => {
      this.peerConnection.setLocalDescription(offer);
    });
  }
}

// ReceiverSample.cs - Unity Client Code
using System.Collections;
using UnityEngine;
using Unity.WebRTC;
public class ReceiverSample : MonoBehaviour {
  private RTCDataChannel dataChannel;
  void Start() { StartCoroutine(InitializeConnection()); }
  IEnumerator InitializeConnection() {
    var connection = new RTCPeerConnection();
    dataChannel = connection.CreateDataChannel("myDataChannel");
    dataChannel.OnOpen += OnChannelOpen;
    yield return null;
  }
  void OnChannelOpen() { StartCoroutine(SendMessageLoop()); }
  IEnumerator SendMessageLoop() {
    while (dataChannel.ReadyState == RTCDataChannelState.Open) {
      dataChannel.Send("Hello World");
      yield return new WaitForSeconds(2);
    }
  }
}

// Adjustments to avoid missing reference issues in ReceiverSample.cs
using Unity.WebRTC;
public class FixedReceiverSample : MonoBehaviour {
  private RTCPeerConnection peerConnection;
  private RTCDataChannel dataChannel;
  void Start() { InitializeWebRTC(); }
  void InitializeWebRTC() {
    peerConnection = new RTCPeerConnection();
    dataChannel = peerConnection.CreateDataChannel("myDataChannel");
    dataChannel.OnOpen += () => Debug.Log("DataChannel open!");
    peerConnection.CreateOffer().ContinueWith(offer => {
      peerConnection.SetLocalDescription(offer.Result);
    });
  }
}

// DataChannelTest.cs - Unity Unit Test
using NUnit.Framework;
using Unity.WebRTC;
public class DataChannelTest {
  [Test]
  public void TestDataChannelCommunication() {
    var connection = new RTCPeerConnection();
    var channel = connection.CreateDataChannel("testChannel");
    bool messageReceived = false;
    channel.OnMessage += message => {
      messageReceived = message == "Hello World";
    };
    channel.Send("Hello World");
    Assert.IsTrue(messageReceived);
  }
}

Explorer les défis de la transmission de données dans Unity et le streaming WebRTC

En plus du streaming vidéo, permettant communication de données entre un client Unity et un serveur JavaScript utilisant WebRTC ouvre de nouvelles possibilités. Cependant, la mise en œuvre d'une telle communication n'est pas toujours simple, surtout lorsque vous intégrez le plugin Unity Render Streaming. Un problème courant rencontré est la configuration et la gestion correctes du Canal de données RTC pour une communication textuelle fluide. Dans notre exemple, le client Unity devrait pouvoir renvoyer un message « Hello World » au serveur JavaScript. Cette étape nécessite une gestion minutieuse à la fois de l’environnement de script d’Unity et des nuances de protocole de WebRTC.

Un défi important concerne la gestion des dépendances dans Unity. Des erreurs telles que l'espace de noms « SingleConnection » manquant dans notre code « ReceiverSample.cs » soulignent la nécessité de garantir que tous les plugins nécessaires, y compris WebRTC, sont installés correctement. Une bonne pratique ici consiste à vérifier la compatibilité entre la version Unity et la version du plugin utilisée. Le problème peut également provenir de composants Unity Render Streaming obsolètes ou manquants, qui doivent être configurés avec le bon connexion objets.

Au-delà des problèmes techniques, un aspect supplémentaire à explorer est la latence entre Unity et JavaScript sur WebRTC. Bien que WebRTC fournisse une communication à faible latence, les conditions du réseau peuvent toujours affecter la livraison des messages. L'utilisation de coroutines dans Unity permet une livraison de messages non bloquante, garantissant que l'envoi de données texte (par exemple via « StartCoroutine ») n'interrompt pas le streaming vidéo. Tester la stabilité de la connexion via `RTCDataChannelState` est une autre pratique clé pour garantir que les messages ne sont envoyés que lorsque le canal est actif. Ces stratégies permettent d'optimiser les performances et de garantir une meilleure expérience utilisateur dans les applications en temps réel.