C#-Uniform Render Streaming amb WebRTC per a missatgeria de text bidireccional del client Unity al servidor JavaScript

Habilitació de la comunicació en temps real entre Unity i JavaScript mitjançant WebRTC

Amb la creixent demanda de comunicació en temps real a les aplicacions, els desenvolupadors estan aprofitant WebRTC per transmetre vídeo, àudio i dades sense problemes. En aquest context, Unity Render Streaming ofereix un marc potent per transmetre vídeo des d'un servidor JavaScript a un client Unity. Tanmateix, establir una comunicació bidireccional, com ara enviar missatges de text des de l'Unity al servidor JavaScript, pot ser un repte.

En aquest projecte, pretenem crear una aplicació de streaming mitjançant el connector Unity Render Streaming juntament amb el protocol WebRTC. Tot i que la part de transmissió de vídeo s'ha configurat correctament, el següent pas consisteix a habilitar l'intercanvi de dades mitjançant un RTCDataChannel. Això permetrà que els missatges de text s'enviïn des del client Unity durant els fluxos de vídeo actius.

Explorarem com modificar mostres de codi existents per complir aquests requisits. L'aplicació web basada en JavaScript gestionarà la transmissió de vídeo, mentre que el client Unity intentarà enviar un missatge de mostra com ara "Hello World" al servidor. Explicarem els reptes de configuració trobats i les seves possibles solucions.

Aquest article també tracta problemes com ara espais de noms que falten i referències no resoltes a Unity. Avaluarem si el codi actual va pel bon camí i oferirem solucions per solucionar problemes habituals, com ara l'error relacionat amb "SingleConnection". Al final, pretenem establir un canal de missatgeria de text bidireccional fluid entre Unity i JavaScript mitjançant WebRTC.

Construir un sistema de missatgeria Unity-to-JavaScript amb WebRTC

L'objectiu d'aquest projecte és utilitzar el Unity Render Streaming connector amb WebRTC per transmetre vídeo des d'un servidor JavaScript a un client Unity, alhora que envia missatges de dades des de l'Unity. El primer pas de l'script de JavaScript consisteix a configurar un flux multimèdia. Utilitzem el mètode `captureStream()` per transmetre contingut de vídeo des d'un element HTML5 i un RTCPeerConnection L'objecte gestiona la connexió entre els dos iguals. Dins d'aquesta connexió es crea un DataChannel, que permet que les dades no multimèdia (com el text) es transmetin al costat del flux de vídeo.

Al costat d'Unity, inicialitzem la connexió WebRTC a l'script "ReceiverSample.cs" configurant un RTCDataChannel. Aquest canal és responsable tant d'enviar com de rebre dades de text al servidor JavaScript. Una funció de rutina s'utilitza per enviar repetidament el missatge "Hola món" cada dos segons, només si l'estat del canal és "Obert". Quan el DataChannel del servidor JavaScript rep un missatge, registra el contingut a la consola per confirmar la connexió correcta.

Un problema crític destacat durant aquest procés és la referència que falta a l'espai de noms "SingleConnection" al codi Unity, que provoca errors de compilació. Això suggereix que falta el paquet necessari o que hi ha una dependència incorrecta a la configuració del projecte. Per resoldre-ho, us recomanem que comproveu que totes les dependències necessàries, com ara el paquet Unity WebRTC, estiguin instal·lades i referenciades correctament. Si el paquet no està disponible, és possible que s'hagi de substituir la classe per un estàndard RTCPeerConnection objecte.

Finalment, el mecanisme de gestió d'errors d'ambdós scripts garanteix que les connexions fallides s'informen a la consola, ajudant a la depuració. L'script d'Unity inclou una funció `StartCoroutine()` per gestionar la missatgeria asíncrona, que és útil per mantenir l'intercanvi de dades en temps real sense bloquejar altres processos. També fem servir els esdeveniments "OnOpen" i "OnClose" per supervisar l'estat del DataChannel, assegurant-nos que els missatges només s'enviïn quan la connexió és estable. Aquesta configuració modular garanteix que el codi es pugui ampliar o modificar fàcilment i proporciona un punt de partida sòlid per crear aplicacions de streaming més avançades mitjançant Unity i 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);
  }
}

Explorant els reptes de la transmissió de dades a Unity i WebRTC Streaming

A més de la transmissió de vídeo, l'habilitació comunicació de dades entre un client Unity i un servidor JavaScript mitjançant WebRTC obre noves possibilitats. Tanmateix, implementar aquesta comunicació no sempre és senzilla, sobretot quan integreu el connector Unity Render Streaming. Un problema comú que es troba és configurar i gestionar correctament RTCDataChannel per a una comunicació de text perfecta. En el nostre exemple, el client Unity hauria de poder enviar un missatge "Hello World" al servidor JavaScript. Aquest pas requereix una gestió acurada tant de l'entorn de script d'Unity com dels matisos del protocol de WebRTC.

Un repte important és la gestió de la dependència a Unity. Errors com l'espai de noms "SingleConnection" que falta al nostre codi "ReceiverSample.cs" posen de manifest la necessitat de garantir que tots els connectors necessaris, inclòs WebRTC, estiguin instal·lats correctament. Una bona pràctica aquí és comprovar la compatibilitat entre la versió d'Unity i la versió del connector en ús. El problema també podria derivar-se de components obsolets o que falten d'Unity Render Streaming, que s'han de configurar amb el correcte connexió objectes.

Més enllà dels problemes tècnics, un aspecte addicional a explorar és la latència entre Unity i JavaScript a través de WebRTC. Tot i que WebRTC proporciona una comunicació de baixa latència, les condicions de la xarxa encara poden afectar el lliurament de missatges. L'ús de corrutines a Unity permet l'entrega de missatges sense bloqueig, assegurant-se que l'enviament de dades de text (p. ex., mitjançant "StartCoroutine") no interrompi la transmissió de vídeo. Provar l'estabilitat de la connexió mitjançant `RTCDataChannelState` és una altra pràctica clau per assegurar-se que els missatges només s'enviïn quan el canal està actiu. Aquestes estratègies ajuden a optimitzar el rendiment i a garantir una millor experiència d'usuari a les aplicacions en temps real.