C#-Uniform Render Streaming med WebRTC til tovejs tekstbeskeder fra Unity Client til JavaScript Server

Aktivering af realtidskommunikation mellem Unity og JavaScript ved hjælp af WebRTC

Med den stigende efterspørgsel efter realtidskommunikation i applikationer udnytter udviklere WebRTC til at overføre video, lyd og data problemfrit. I denne sammenhæng tilbyder Unity Render Streaming en kraftfuld ramme til at streame video fra en JavaScript-server til en Unity-klient. Det kan dog være en udfordring at etablere tovejskommunikation – såsom at sende tekstbeskeder tilbage fra Unity til JavaScript-serveren.

I dette projekt sigter vi mod at bygge en streaming-app ved at bruge Unity Render Streaming-pluginnet sammen med WebRTC-protokollen. Mens videostreaming-delen er blevet konfigureret med succes, involverer næste trin at aktivere dataudveksling gennem en RTCDataChannel. Dette vil gøre det muligt at sende tekstbeskeder fra Unity-klienten under aktive videostreams.

Vi vil undersøge, hvordan man ændrer eksisterende kodeeksempler for at opfylde disse krav. Den JavaScript-baserede web-app vil administrere videostreamingen, mens Unity-klienten vil forsøge at sende en prøvemeddelelse såsom "Hello World" tilbage til serveren. Vi gennemgår de opståede konfigurationsudfordringer og deres potentielle løsninger.

Denne artikel diskuterer også problemer såsom manglende navnerum og uløste referencer i Unity. Vi vurderer, om den aktuelle kode er på rette vej og giver løsninger til at løse almindelige problemer, såsom fejlen relateret til 'SingleConnection'. Til sidst sigter vi på at etablere en glat, tovejs tekstbeskedpipeline mellem Unity og JavaScript ved hjælp af WebRTC.

Opbygning af et Unity-to-JavaScript-meddelelsessystem med WebRTC

Målet med dette projekt er at bruge Unity Render Streaming plugin med WebRTC til at overføre video fra en JavaScript-server til en Unity-klient, samtidig med at databeskeder sendes tilbage fra Unity. Det første trin i JavaScript-scriptet involverer opsætning af en mediestrøm. Vi bruger `captureStream()`-metoden til at streame videoindhold fra et HTML5-element og en RTCPeerConnection objekt styrer forbindelsen mellem de to peers. Der oprettes en datakanal i denne forbindelse, som gør det muligt at transmittere ikke-mediedata (som tekst) sammen med videostrømmen.

På Unity-siden initialiserer vi WebRTC-forbindelsen i 'ReceiverSample.cs'-scriptet ved at opsætte en RTCDataChannel. Denne kanal er ansvarlig for både at sende og modtage tekstdata til JavaScript-serveren. En coroutine-funktion bruges til gentagne gange at sende beskeden "Hello World" hvert andet sekund, kun hvis kanaltilstanden er "Åben". Når DataChannel på JavaScript-serveren modtager en besked, logger den indholdet til konsollen for at bekræfte den vellykkede forbindelse.

Et kritisk problem fremhævet under denne proces er den manglende reference til 'SingleConnection'-navneområdet i Unity-koden, hvilket forårsager kompileringsfejl. Dette tyder på, at enten mangler den nødvendige pakke, eller der er en forkert afhængighed i projektkonfigurationen. For at løse dette anbefaler vi, at du verificerer, at alle nødvendige afhængigheder, såsom Unity WebRTC-pakken, er korrekt installeret og refereret til. Hvis pakken ikke er tilgængelig, skal klassen muligvis udskiftes med en standard RTCPeerConnection objekt.

Endelig sikrer fejlhåndteringsmekanismen for begge scripts, at mislykkede forbindelser rapporteres i konsollen, hvilket hjælper med fejlfinding. Unity-scriptet indeholder en `StartCoroutine()`-funktion til at styre asynkrone meddelelser, hvilket er nyttigt til at opretholde dataudveksling i realtid uden at blokere andre processer. Vi bruger også 'OnOpen' og 'OnClose' hændelser til at overvåge datakanalens tilstand, hvilket sikrer, at beskeder kun sendes, når forbindelsen er stabil. Denne modulære opsætning sikrer, at koden nemt kan udvides eller ændres, og den giver et solidt udgangspunkt for at bygge mere avancerede streamingapplikationer ved hjælp af Unity og 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);
  }
}

Udforskning af datatransmissionsudfordringer i Unity og WebRTC-streaming

Ud over videostreaming, aktiverer datakommunikation mellem en Unity-klient og en JavaScript-server ved hjælp af WebRTC åbner nye muligheder. Det er dog ikke altid ligetil at implementere sådan kommunikation, især når du integrerer Unity Render Streaming-plugin. Et almindeligt problem er korrekt opsætning og styring af RTCDataChannel til problemfri tekstkommunikation. I vores eksempel burde Unity-klienten være i stand til at sende en "Hello World"-meddelelse tilbage til JavaScript-serveren. Dette trin kræver omhyggelig håndtering af både Unitys scriptmiljø og WebRTCs protokolnuancer.

En vigtig udfordring involverer afhængighedsstyring i Unity. Fejl som det manglende navneområde 'SingleConnection' i vores 'ReceiverSample.cs'-kode fremhæver behovet for at sikre, at alle nødvendige plugins, inklusive WebRTC, er installeret korrekt. En god praksis her er at tjekke for kompatibilitet mellem Unity-versionen og plugin-versionen i brug. Problemet kan også stamme fra forældede eller manglende Unity Render Streaming-komponenter, som skal konfigureres med den korrekte forbindelse genstande.

Ud over tekniske problemer er et yderligere aspekt at udforske latenstiden mellem Unity og JavaScript over WebRTC. Selvom WebRTC giver kommunikation med lav latens, kan netværksforhold stadig påvirke leveringen af ​​meddelelser. Brug af coroutiner i Unity giver mulighed for ikke-blokerende meddelelseslevering, hvilket sikrer, at afsendelse af tekstdata (f.eks. via 'StartCoroutine') ikke afbryder videostreaming. At teste stabiliteten af ​​forbindelsen gennem `RTCDataChannelState` er en anden vigtig praksis for at sikre, at beskeder kun sendes, når kanalen er aktiv. Disse strategier hjælper med at optimere ydeevnen og sikre en bedre brugeroplevelse i realtidsapplikationer.