C#-Uniform Render Streaming med WebRTC för dubbelriktad textmeddelanden från Unity Client till JavaScript Server

Aktivera realtidskommunikation mellan Unity och JavaScript med hjälp av WebRTC

Med den växande efterfrågan på realtidskommunikation i applikationer, utnyttjar utvecklare WebRTC för att överföra video, ljud och data sömlöst. I detta sammanhang erbjuder Unity Render Streaming ett kraftfullt ramverk för att strömma video från en JavaScript-server till en Unity-klient. Det kan dock vara en utmaning att etablera dubbelriktad kommunikation – som att skicka tillbaka textmeddelanden från Unity till JavaScript-servern.

I det här projektet siktar vi på att bygga en streaming-app genom att använda Unity Render Streaming-plugin tillsammans med WebRTC-protokollet. Medan videoströmningsdelen har konfigurerats framgångsrikt, innebär nästa steg att möjliggöra datautbyte via en RTCDataChannel. Detta gör att textmeddelanden kan skickas från Unity-klienten under aktiva videoströmmar.

Vi kommer att undersöka hur man ändrar befintliga kodexempel för att uppfylla dessa krav. Den JavaScript-baserade webbappen kommer att hantera videoströmningen, medan Unity-klienten kommer att försöka skicka ett exempelmeddelande som "Hello World" tillbaka till servern. Vi går igenom konfigurationsutmaningarna och deras potentiella lösningar.

Den här artikeln diskuterar också frågor som saknade namnutrymmen och olösta referenser i Unity. Vi kommer att bedöma om den aktuella koden är på rätt spår och tillhandahåller lösningar för att åtgärda vanliga problem, som felet relaterat till "SingleConnection". Till slut siktar vi på att skapa en smidig, dubbelriktad textmeddelandepipeline mellan Unity och JavaScript med hjälp av WebRTC.

Bygga ett Unity-to-JavaScript-meddelandesystem med WebRTC

Målet med detta projekt är att använda Unity Render Streaming plugin med WebRTC för att överföra video från en JavaScript-server till en Unity-klient, samtidigt som datameddelanden skickas tillbaka från Unity. Det första steget i JavaScript-skriptet innebär att sätta upp en mediaström. Vi använder metoden `captureStream()` för att strömma videoinnehåll från ett HTML5-element och en RTCPeerConnection objekt hanterar kopplingen mellan de två peers. En datakanal skapas inom denna anslutning, som gör att icke-mediadata (som text) kan överföras tillsammans med videoströmmen.

På Unity-sidan initierar vi WebRTC-anslutningen i `ReceiverSample.cs`-skriptet genom att ställa in en RTCDataChannel. Denna kanal ansvarar för att både skicka och ta emot textdata till JavaScript-servern. En coroutine-funktion används för att upprepade gånger skicka meddelandet "Hello World" varannan sekund, bara om kanaltillståndet är "Öppen". När DataChannel på JavaScript-servern tar emot ett meddelande loggar den innehållet till konsolen för att bekräfta den lyckade anslutningen.

Ett kritiskt problem som lyfts fram under denna process är den saknade referensen till "SingleConnection"-namnområdet i Unity-koden, vilket orsakar kompileringsfel. Detta tyder på att antingen det nödvändiga paketet saknas eller att det finns ett felaktigt beroende i projektkonfigurationen. För att lösa detta rekommenderar vi att du verifierar att alla nödvändiga beroenden, såsom Unity WebRTC-paketet, är korrekt installerade och refererade till. Om paketet inte är tillgängligt kan klassen behöva ersättas med en standard RTCPeerConnection objekt.

Slutligen säkerställer felhanteringsmekanismen för båda skripten att misslyckade anslutningar rapporteras i konsolen, vilket hjälper till med felsökning. Unity-skriptet innehåller en `StartCoroutine()`-funktion för att hantera asynkron meddelandehantering, vilket är användbart för att upprätthålla datautbyte i realtid utan att blockera andra processer. Vi använder också "OnOpen" och "OnClose"-händelser för att övervaka datakanalens tillstånd, vilket säkerställer att meddelanden bara skickas när anslutningen är stabil. Denna modulära uppsättning säkerställer att koden enkelt kan utökas eller modifieras, och den ger en solid utgångspunkt för att bygga mer avancerade streamingapplikationer med Unity och 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);
  }
}

Utforska dataöverföringsutmaningar i Unity och WebRTC Streaming

Förutom videoströmning, aktivera datakommunikation mellan en Unity-klient och en JavaScript-server med WebRTC öppnar nya möjligheter. Att implementera sådan kommunikation är dock inte alltid okomplicerat, särskilt när du integrerar Unity Render Streaming-plugin. Ett vanligt problem som uppstår är att korrekt ställa in och hantera RTCDataChannel för sömlös textkommunikation. I vårt exempel bör Unity-klienten kunna skicka ett "Hello World"-meddelande tillbaka till JavaScript-servern. Detta steg kräver noggrann hantering av både Unitys skriptmiljö och WebRTC:s protokollnyanser.

En viktig utmaning är beroendehantering i Unity. Fel som det saknade namnutrymmet `SingleConnection` i vår `ReceiverSample.cs`-kod framhäver behovet av att säkerställa att alla nödvändiga plugins, inklusive WebRTC, är korrekt installerade. En bra praxis här är att kontrollera kompatibilitet mellan Unity-versionen och plugin-versionen som används. Problemet kan också bero på föråldrade eller saknade Unity Render Streaming-komponenter, som måste konfigureras med rätt förbindelse föremål.

Utöver tekniska problem är en ytterligare aspekt att utforska latensen mellan Unity och JavaScript över WebRTC. Även om WebRTC tillhandahåller kommunikation med låg latens, kan nätverksförhållanden fortfarande påverka meddelandeleveransen. Att använda koroutiner inom Unity möjliggör icke-blockerande meddelandeleverans, vilket säkerställer att sändning av textdata (t.ex. via "StartCoroutine") inte avbryter videoströmning. Att testa stabiliteten för anslutningen genom `RTCDataChannelState` är en annan viktig praxis för att säkerställa att meddelanden bara skickas när kanalen är aktiv. Dessa strategier hjälper till att optimera prestanda och säkerställa en bättre användarupplevelse i realtidsapplikationer.