C#-Uniform Render Streaming s WebRTC pre obojsmerné posielanie textových správ z klienta Unity na server JavaScript

Povolenie komunikácie v reálnom čase medzi Unity a JavaScriptom pomocou WebRTC

S rastúcim dopytom po komunikácii v reálnom čase v aplikáciách vývojári využívajú WebRTC na bezproblémový prenos videa, zvuku a dát. V tomto kontexte ponúka Unity Render Streaming výkonný rámec na streamovanie videa zo servera JavaScript do klienta Unity. Nadviazanie obojsmernej komunikácie – ako napríklad posielanie textových správ späť z Unity na server JavaScript – však môže byť problém.

V tomto projekte sa snažíme vytvoriť aplikáciu na streamovanie pomocou doplnku Unity Render Streaming spolu s protokolom WebRTC. Zatiaľ čo časť streamovania videa bola úspešne nakonfigurovaná, ďalší krok zahŕňa umožnenie výmeny údajov cez RTCDataChannel. To umožní odosielanie textových správ z klienta Unity počas aktívnych video streamov.

Preskúmame, ako upraviť existujúce vzorky kódu, aby spĺňali tieto požiadavky. Webová aplikácia založená na JavaScripte bude spravovať streamovanie videa, zatiaľ čo klient Unity sa pokúsi odoslať vzorovú správu, ako napríklad „Hello World“ späť na server. Prejdeme si problémy s konfiguráciou a ich možné riešenia.

Tento článok tiež rozoberá problémy, ako sú chýbajúce menné priestory a nevyriešené odkazy v Unity. Posúdime, či je aktuálny kód na správnej ceste, a poskytneme riešenia na odstránenie bežných problémov, ako je chyba súvisiaca s „SingleConnection“. Nakoniec sa snažíme vytvoriť hladký obojsmerný kanál na odosielanie textových správ medzi Unity a JavaScriptom pomocou WebRTC.

Budovanie systému správ Unity-to-JavaScript s WebRTC

Cieľom tohto projektu je využiť Streamovanie Unity Render plugin s WebRTC na prenos videa zo servera JavaScript do klienta Unity a zároveň odosielanie dátových správ späť z Unity. Prvý krok v skripte JavaScript zahŕňa nastavenie streamu médií. Na streamovanie videoobsahu z prvku HTML5 používame metódu `captureStream()` RTCPeerConnection objekt riadi spojenie medzi dvoma rovesníkmi. V rámci tohto spojenia je vytvorený DataChannel, ktorý umožňuje prenos nemediálnych dát (napríklad textu) popri video streame.

Na strane Unity inicializujeme pripojenie WebRTC v skripte `ReceiverSample.cs` nastavením RTCDataChannel. Tento kanál je zodpovedný za odosielanie aj prijímanie textových údajov na server JavaScript. Funkcia korutín sa používa na opakované odosielanie správy „Ahoj svet“ každé dve sekundy, iba ak je stav kanála „Otvorený“. Keď DataChannel na serveri JavaScript prijme správu, prihlási obsah do konzoly, aby potvrdil úspešné pripojenie.

Kritickým problémom zdôrazneným počas tohto procesu je chýbajúci odkaz na priestor názvov „SingleConnection“ v kóde Unity, čo spôsobuje chyby pri kompilácii. To naznačuje, že buď chýba požadovaný balík, alebo je v konfigurácii projektu nesprávna závislosť. Ak to chcete vyriešiť, odporúčame overiť, či sú všetky potrebné závislosti, ako napríklad balík Unity WebRTC, správne nainštalované a odkazované. Ak balík nie je k dispozícii, možno bude potrebné nahradiť triedu štandardnou RTCPeerConnection objekt.

Nakoniec mechanizmus spracovania chýb pre oba skripty zaisťuje, že neúspešné pripojenia sú hlásené v konzole, čo pomáha pri ladení. Skript Unity obsahuje funkciu „StartCoroutine()“ na správu asynchrónneho zasielania správ, čo je užitočné pri udržiavaní výmeny údajov v reálnom čase bez blokovania iných procesov. Na monitorovanie stavu DataChannelu používame aj udalosti `OnOpen` a `OnClose`, čím zaisťujeme, že správy sa odosielajú iba vtedy, keď je pripojenie stabilné. Toto modulárne nastavenie zaisťuje, že kód možno ľahko rozšíriť alebo upraviť, a poskytuje solídny východiskový bod pre vytváranie pokročilejších streamovacích aplikácií pomocou Unity a 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);
  }
}

Skúmanie výziev prenosu dát v Unity a WebRTC Streaming

Okrem streamovania videa, zapnutie dátová komunikácia medzi Unity klientom a JavaScript serverom pomocou WebRTC otvára nové možnosti. Implementácia takejto komunikácie však nie je vždy jednoduchá, najmä ak integrujete doplnok Unity Render Streaming. Bežným problémom je správne nastavenie a správa RTCDataChannel pre bezproblémovú textovú komunikáciu. V našom príklade by mal byť klient Unity schopný poslať správu „Hello World“ späť na server JavaScript. Tento krok vyžaduje starostlivé zaobchádzanie so skriptovacím prostredím Unity a nuansami protokolu WebRTC.

Jednou z dôležitých výziev je riadenie závislostí v Unity. Chyby, ako napríklad chýbajúci priestor názvov „SingleConnection“ v našom kóde „ReceiverSample.cs“, zdôrazňujú potrebu zabezpečiť, aby boli všetky potrebné doplnky vrátane WebRTC nainštalované správne. Osvedčeným postupom je skontrolovať kompatibilitu medzi verziou Unity a používanou verziou doplnku. Problém môže prameniť aj zo zastaraných alebo chýbajúcich komponentov Unity Render Streaming, ktoré je potrebné nakonfigurovať so správnym spojenie predmety.

Okrem technických problémov je ďalším aspektom, ktorý treba preskúmať, latencia medzi Unity a JavaScriptom cez WebRTC. Zatiaľ čo WebRTC poskytuje komunikáciu s nízkou latenciou, podmienky siete môžu stále ovplyvniť doručovanie správ. Používanie korutínov v rámci Unity umožňuje neblokované doručovanie správ, čím sa zabezpečí, že odosielanie textových údajov (napr. cez „StartCoroutine“) nepreruší streamovanie videa. Testovanie stability pripojenia prostredníctvom `RTCDataChannelState` je ďalším kľúčovým postupom, ktorý zabezpečí, že správy sa budú odosielať iba vtedy, keď je kanál aktívny. Tieto stratégie pomáhajú optimalizovať výkon a zabezpečujú lepšiu používateľskú skúsenosť v aplikáciách v reálnom čase.