C#-Uniform Render Streaming z WebRTC za dvosmerno pošiljanje besedilnih sporočil od odjemalca Unity do strežnika JavaScript

Omogočanje komunikacije v realnem času med Unity in JavaScript z uporabo WebRTC

Z naraščajočim povpraševanjem po komunikaciji v realnem času v aplikacijah razvijalci izkoriščajo WebRTC za nemoten prenos videa, zvoka in podatkov. V tem kontekstu ponuja Unity Render Streaming zmogljivo ogrodje za pretakanje videa iz strežnika JavaScript v odjemalca Unity. Vendar pa je vzpostavitev dvosmerne komunikacije – kot je pošiljanje besedilnih sporočil nazaj iz Unityja na strežnik JavaScript – lahko izziv.

V tem projektu želimo zgraditi aplikacijo za pretakanje z uporabo vtičnika Unity Render Streaming skupaj s protokolom WebRTC. Čeprav je bil del za pretakanje videa uspešno konfiguriran, naslednji korak vključuje omogočanje izmenjave podatkov prek RTCDataChannel. To bo omogočilo pošiljanje besedilnih sporočil iz odjemalca Unity med aktivnimi video tokovi.

Raziskali bomo, kako spremeniti obstoječe vzorce kode, da bodo izpolnili te zahteve. Spletna aplikacija, ki temelji na JavaScriptu, bo upravljala pretakanje videa, medtem ko bo odjemalec Unity poskušal poslati vzorčno sporočilo, kot je "Hello World", nazaj na strežnik. Sprehodili se bomo skozi konfiguracijske izzive, s katerimi smo se srečali, in njihove možne rešitve.

Ta članek obravnava tudi težave, kot so manjkajoči imenski prostori in nerazrešene reference v Unity. Ocenili bomo, ali je trenutna koda na pravi poti, in ponudili rešitve za odpravo pogostih težav, kot je napaka, povezana z »SingleConnection«. Na koncu želimo vzpostaviti nemoten dvosmerni cevovod za besedilna sporočila med Unityjem in JavaScriptom z uporabo WebRTC.

Gradnja sporočilnega sistema Unity-to-JavaScript z WebRTC

Cilj tega projekta je uporaba Unity Render Streaming vtičnik z WebRTC za prenos videa s strežnika JavaScript na odjemalca Unity, hkrati pa pošiljanje podatkovnih sporočil nazaj iz Unityja. Prvi korak v skriptu JavaScript vključuje nastavitev medijskega toka. Uporabljamo metodo `captureStream()` za pretakanje video vsebine iz elementa HTML5 in RTCPeerConnection objekt upravlja povezavo med obema vrstnikoma. Znotraj te povezave se ustvari DataChannel, ki omogoča prenos nemedijskih podatkov (kot je besedilo) skupaj z video tokom.

Na strani Unity inicializiramo povezavo WebRTC v skriptu `ReceiverSample.cs` tako, da nastavimo RTCDataChannel. Ta kanal je odgovoren za pošiljanje in prejemanje besedilnih podatkov strežniku JavaScript. Funkcija sorutine se uporablja za večkratno pošiljanje sporočila »Hello World« vsaki dve sekundi, samo če je stanje kanala »Odprt«. Ko DataChannel na strežniku JavaScript prejme sporočilo, zabeleži vsebino v konzolo, da potrdi uspešno povezavo.

Kritična težava, poudarjena med tem postopkom, je manjkajoča referenca na imenski prostor `SingleConnection` v kodi Unity, kar povzroča napake pri prevajanju. To pomeni, da zahtevani paket manjka ali pa je v konfiguraciji projekta napačna odvisnost. Za rešitev tega problema priporočamo, da preverite, ali so vse potrebne odvisnosti, kot je paket Unity WebRTC, pravilno nameščene in navedene. Če paket ni na voljo, bo razred morda treba zamenjati s standardom RTCPeerConnection predmet.

Nazadnje, mehanizem za obravnavanje napak za oba skripta zagotavlja, da so neuspele povezave sporočene v konzoli, kar pomaga pri odpravljanju napak. Skript Unity vključuje funkcijo `StartCoroutine()` za upravljanje asinhronega sporočanja, ki je uporabno pri vzdrževanju izmenjave podatkov v realnem času brez blokiranja drugih procesov. Za spremljanje stanja podatkovnega kanala uporabljamo tudi dogodka `OnOpen` in `OnClose`, s čimer zagotovimo, da se sporočila pošiljajo le, ko je povezava stabilna. Ta modularna nastavitev zagotavlja, da je kodo mogoče preprosto razširiti ali spremeniti, in zagotavlja trdno izhodišče za izdelavo naprednejših pretočnih aplikacij z uporabo Unity in 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);
  }
}

Raziskovanje izzivov prenosa podatkov pri pretakanju Unity in WebRTC

Poleg pretakanja videa omogočanje podatkovna komunikacija med odjemalcem Unity in strežnikom JavaScript z uporabo WebRTC odpira nove možnosti. Vendar izvajanje takšne komunikacije ni vedno preprosto, zlasti če integrirate vtičnik Unity Render Streaming. Pogosta težava, s katero se srečujete, je pravilna nastavitev in upravljanje RTCDataChannel za brezhibno besedilno komunikacijo. V našem primeru bi moral biti odjemalec Unity sposoben poslati sporočilo »Hello World« nazaj strežniku JavaScript. Ta korak zahteva skrbno ravnanje s skriptnim okoljem Unity in niansami protokola WebRTC.

Eden od pomembnih izzivov vključuje upravljanje odvisnosti v Unity. Napake, kot je manjkajoči imenski prostor `SingleConnection` v naši kodi `ReceiverSample.cs`, poudarjajo potrebo po zagotovitvi, da so vsi potrebni vtičniki, vključno z WebRTC, pravilno nameščeni. Dobra praksa je, da preverite združljivost med različico Unity in različico vtičnika, ki je v uporabi. Težava lahko izvira tudi iz zastarelih ali manjkajočih komponent Unity Render Streaming, ki jih je treba konfigurirati s pravilnimi povezava predmetov.

Poleg tehničnih težav je dodaten vidik, ki ga je treba raziskati, zakasnitev med Unity in JavaScript prek WebRTC. Čeprav WebRTC zagotavlja komunikacijo z nizko zakasnitvijo, lahko omrežne razmere še vedno vplivajo na dostavo sporočil. Uporaba soprogramov znotraj Unityja omogoča dostavo sporočil brez blokiranja, kar zagotavlja, da pošiljanje besedilnih podatkov (npr. prek `StartCoroutine`) ne prekine pretakanja videa. Preizkušanje stabilnosti povezave prek `RTCDataChannelState` je še ena ključna praksa za zagotovitev, da se sporočila pošiljajo le, ko je kanal aktiven. Te strategije pomagajo optimizirati delovanje in zagotavljajo boljšo uporabniško izkušnjo v aplikacijah v realnem času.