C#-Uniform Render Streaming met WebRTC voor bidirectionele tekstberichten van Unity Client naar JavaScript Server

Realtime communicatie tussen Unity en JavaScript mogelijk maken met behulp van WebRTC

Met de groeiende vraag naar realtime communicatie in applicaties maken ontwikkelaars gebruik van WebRTC om video, audio en gegevens naadloos te verzenden. In deze context biedt Unity Render Streaming een krachtig raamwerk om video van een JavaScript-server naar een Unity-client te streamen. Het tot stand brengen van bidirectionele communicatie, zoals het terugsturen van sms-berichten van Unity naar de JavaScript-server, kan echter een uitdaging zijn.

In dit project willen we een streaming-app bouwen met behulp van de Unity Render Streaming-plug-in samen met het WebRTC-protocol. Terwijl het videostreaminggedeelte succesvol is geconfigureerd, bestaat de volgende stap uit het mogelijk maken van gegevensuitwisseling via een RTCDataChannel. Hierdoor kunnen sms-berichten worden verzonden vanaf de Unity-client tijdens actieve videostreams.

We zullen onderzoeken hoe we bestaande codevoorbeelden kunnen aanpassen om aan deze vereisten te voldoen. De op JavaScript gebaseerde webapp beheert de videostreaming, terwijl de Unity-client zal proberen een voorbeeldbericht zoals "Hallo wereld" terug naar de server te sturen. We bespreken de configuratie-uitdagingen die we tegenkomen en hun mogelijke oplossingen.

In dit artikel worden ook problemen besproken zoals ontbrekende naamruimten en onopgeloste verwijzingen in Unity. We beoordelen of de huidige code op de goede weg is en bieden oplossingen om veelvoorkomende problemen op te lossen, zoals de fout met betrekking tot 'SingleConnection'. Uiteindelijk willen we een soepele, bidirectionele sms-pijplijn tussen Unity en JavaScript tot stand brengen met behulp van WebRTC.

Een Unity-naar-JavaScript-berichtensysteem bouwen met WebRTC

Het doel van dit project is om gebruik te maken van de Unity Render-streaming plug-in met WebRTC om video van een JavaScript-server naar een Unity-client te verzenden, en tegelijkertijd databerichten terug te sturen van Unity. De eerste stap in het JavaScript-script omvat het opzetten van een mediastream. We gebruiken de `captureStream()`-methode om video-inhoud van een HTML5-element te streamen, en een RTCPeerVerbinding object beheert de verbinding tussen de twee peers. Binnen deze verbinding wordt een DataChannel gecreëerd, waardoor niet-mediale gegevens (zoals tekst) naast de videostream kunnen worden verzonden.

Aan de Unity-kant initialiseren we de WebRTC-verbinding in het `ReceiverSample.cs`-script door een RTCDataChannel. Dit kanaal is verantwoordelijk voor het verzenden en ontvangen van tekstgegevens naar de JavaScript-server. Er wordt een coroutine-functie gebruikt om het bericht 'Hallo wereld' elke twee seconden herhaaldelijk te verzenden, alleen als de kanaalstatus 'Open' is. Wanneer het DataChannel op de JavaScript-server een bericht ontvangt, registreert het de inhoud naar de console om de succesvolle verbinding te bevestigen.

Een cruciaal probleem dat tijdens dit proces naar voren komt, is de ontbrekende verwijzing naar de naamruimte 'SingleConnection' in de Unity-code, waardoor compilatiefouten ontstaan. Dit suggereert dat het vereiste pakket ontbreekt of dat er een onjuiste afhankelijkheid is in de projectconfiguratie. Om dit op te lossen, raden we u aan te controleren of alle noodzakelijke afhankelijkheden, zoals het Unity WebRTC-pakket, correct zijn geïnstalleerd en waarnaar wordt verwezen. Als het pakket niet beschikbaar is, moet de klasse mogelijk worden vervangen door een standaard RTCPeerVerbinding voorwerp.

Ten slotte zorgt het foutafhandelingsmechanisme voor beide scripts ervoor dat mislukte verbindingen in de console worden gerapporteerd, wat helpt bij het opsporen van fouten. Het Unity-script bevat een `StartCoroutine()`-functie om asynchrone berichtenuitwisseling te beheren, wat handig is bij het onderhouden van realtime gegevensuitwisseling zonder andere processen te blokkeren. We gebruiken ook 'OnOpen'- en 'OnClose'-gebeurtenissen om de status van het DataChannel te controleren, zodat we ervoor zorgen dat berichten alleen worden verzonden als de verbinding stabiel is. Deze modulaire opzet zorgt ervoor dat de code eenvoudig kan worden uitgebreid of aangepast, en biedt een solide startpunt voor het bouwen van meer geavanceerde streaming-applicaties met behulp van Unity en 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);
  }
}

Onderzoek naar uitdagingen op het gebied van datatransmissie bij Unity en WebRTC-streaming

Naast videostreaming, inschakelen datacommunicatie tussen een Unity-client en een JavaScript-server met behulp van WebRTC opent nieuwe mogelijkheden. Het implementeren van dergelijke communicatie is echter niet altijd eenvoudig, vooral als u de Unity Render Streaming-plug-in integreert. Een veelvoorkomend probleem is het correct instellen en beheren van de RTCDataChannel voor naadloze tekstcommunicatie. In ons voorbeeld zou de Unity-client een "Hello World"-bericht terug moeten kunnen sturen naar de JavaScript-server. Deze stap vereist een zorgvuldige omgang met zowel de scriptomgeving van Unity als de protocolnuances van WebRTC.

Een belangrijke uitdaging betreft het afhankelijkheidsbeheer in Unity. Fouten zoals de ontbrekende naamruimte 'SingleConnection' in onze code 'ReceiverSample.cs' benadrukken de noodzaak om ervoor te zorgen dat alle noodzakelijke plug-ins, inclusief WebRTC, correct worden geïnstalleerd. Een goede gewoonte hier is om te controleren op compatibiliteit tussen de Unity-versie en de gebruikte plug-inversie. Het probleem kan ook voortkomen uit verouderde of ontbrekende Unity Render Streaming-componenten, die met de juiste configuratie moeten worden geconfigureerd verbinding voorwerpen.

Naast technische problemen is een extra aspect dat we moeten onderzoeken de latentie tussen Unity en JavaScript via WebRTC. Hoewel WebRTC communicatie met lage latentie biedt, kunnen netwerkomstandigheden nog steeds de bezorging van berichten beïnvloeden. Het gebruik van coroutines binnen Unity maakt een niet-blokkerende berichtbezorging mogelijk, waarbij ervoor wordt gezorgd dat het verzenden van tekstgegevens (bijvoorbeeld via `StartCoroutine`) de videostreaming niet onderbreekt. Het testen van de stabiliteit van de verbinding via `RTCDataChannelState` is een andere belangrijke praktijk om ervoor te zorgen dat berichten alleen worden verzonden als het kanaal actief is. Deze strategieën helpen de prestaties te optimaliseren en zorgen voor een betere gebruikerservaring in realtime applicaties.