C#-Uniform Render Streaming s WebRTC pro obousměrné zasílání textových zpráv z klienta Unity na server JavaScript

Povolení komunikace v reálném čase mezi Unity a JavaScriptem pomocí WebRTC

S rostoucí poptávkou po komunikaci v reálném čase v aplikacích využívají vývojáři WebRTC k bezproblémovému přenosu videa, zvuku a dat. V této souvislosti nabízí Unity Render Streaming výkonný rámec pro streamování videa ze serveru JavaScript do klienta Unity. Navázání obousměrné komunikace – jako je odesílání textových zpráv zpět z Unity na server JavaScript – však může být problém.

V tomto projektu se snažíme vytvořit streamovací aplikaci pomocí pluginu Unity Render Streaming spolu s protokolem WebRTC. Zatímco část pro streamování videa byla úspěšně nakonfigurována, další krok zahrnuje povolení výměny dat prostřednictvím RTCDataChannel. To umožní odesílání textových zpráv z klienta Unity během aktivního streamování videa.

Prozkoumáme, jak upravit existující ukázky kódu, aby tyto požadavky splnily. Webová aplikace založená na JavaScriptu bude spravovat streamování videa, zatímco klient Unity se pokusí odeslat ukázkovou zprávu, jako je „Hello World“ zpět na server. Projdeme si problémy s konfigurací a jejich možná řešení.

Tento článek také pojednává o problémech, jako jsou chybějící jmenné prostory a nevyřešené odkazy v Unity. Posoudíme, zda je aktuální kód na správné cestě, a poskytneme řešení k vyřešení běžných problémů, jako je chyba související s „SingleConnection“. Nakonec se snažíme vytvořit hladký, obousměrný kanál pro zasílání textových zpráv mezi Unity a JavaScriptem pomocí WebRTC.

Vytváření systému zpráv Unity-to-JavaScript s WebRTC

Cílem tohoto projektu je využít Unity Render Streaming plugin s WebRTC pro přenos videa ze serveru JavaScript do klienta Unity a zároveň odesílání datových zpráv zpět z Unity. První krok skriptu JavaScript zahrnuje nastavení streamu médií. Ke streamování video obsahu z prvku HTML5 používáme metodu `captureStream()` RTCPeerConnection objekt spravuje spojení mezi dvěma partnery. V rámci tohoto připojení je vytvořen DataChannel, který umožňuje přenos nemediálních dat (jako je text) spolu s video streamem.

Na straně Unity inicializujeme připojení WebRTC ve skriptu `ReceiverSample.cs` nastavením RTCDataChannel. Tento kanál je zodpovědný za odesílání a přijímání textových dat na server JavaScript. K opakovanému odesílání zprávy „Hello World“ každé dvě sekundy se používá funkce coroutine, pouze pokud je stav kanálu „Otevřený“. Když DataChannel na serveru JavaScript obdrží zprávu, zaprotokoluje obsah do konzoly, aby potvrdil úspěšné připojení.

Kritickým problémem zdůrazněným během tohoto procesu je chybějící odkaz na jmenný prostor `SingleConnection` v kódu Unity, což způsobuje chyby při kompilaci. To naznačuje, že buď chybí požadovaný balíček, nebo je v konfiguraci projektu nesprávná závislost. Chcete-li tento problém vyřešit, doporučujeme ověřit, zda jsou všechny potřebné závislosti, jako je balíček Unity WebRTC, správně nainstalovány a odkazovány. Pokud balíček není k dispozici, může být nutné třídu nahradit standardní RTCPeerConnection objekt.

Mechanismus zpracování chyb pro oba skripty nakonec zajišťuje, že neúspěšná připojení jsou hlášena v konzole, což pomáhá s laděním. Skript Unity obsahuje funkci `StartCoroutine()` pro správu asynchronního zasílání zpráv, což je užitečné při udržování výměny dat v reálném čase bez blokování jiných procesů. Také používáme události `OnOpen` a `OnClose` ke sledování stavu DataChannelu, což zajišťuje, že zprávy jsou odesílány pouze tehdy, když je připojení stabilní. Toto modulární nastavení zajišťuje, že kód lze snadno rozšířit nebo upravit, a poskytuje pevný výchozí bod pro vytváření pokročilejších streamovacích aplikací pomocí 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);
  }
}

Zkoumání výzev přenosu dat v Unity a WebRTC Streaming

Kromě streamování videa, povolení datová komunikace mezi Unity klientem a JavaScriptovým serverem pomocí WebRTC otevírá nové možnosti. Implementace takové komunikace však není vždy přímočará, zvláště když integrujete plugin Unity Render Streaming. Běžným problémem je správné nastavení a správa RTCDataChannel pro bezproblémovou textovou komunikaci. V našem příkladu by měl být klient Unity schopen odeslat zprávu „Hello World“ zpět na server JavaScript. Tento krok vyžaduje pečlivé zacházení se skriptovacím prostředím Unity a nuancemi protokolu WebRTC.

Jednou z důležitých výzev je správa závislostí v Unity. Chyby, jako je chybějící jmenný prostor `SingleConnection` v našem kódu `ReceiverSample.cs` zdůrazňují potřebu zajistit, aby byly všechny potřebné pluginy, včetně WebRTC, nainstalovány správně. Osvědčeným postupem je zkontrolovat kompatibilitu mezi verzí Unity a používanou verzí pluginu. Problém může také pocházet ze zastaralých nebo chybějících komponent Unity Render Streaming, které je třeba nakonfigurovat se správným spojení objektů.

Kromě technických problémů je dalším aspektem, který je třeba prozkoumat, latence mezi Unity a JavaScriptem přes WebRTC. Přestože WebRTC poskytuje komunikaci s nízkou latencí, podmínky sítě mohou stále ovlivnit doručování zpráv. Používání korutin v rámci Unity umožňuje neblokované doručování zpráv, což zajišťuje, že odesílání textových dat (např. přes „StartCoroutine“) nepřeruší streamování videa. Testování stability připojení prostřednictvím `RTCDataChannelState` je dalším klíčovým postupem, který zajistí, že zprávy budou odesílány pouze tehdy, když je kanál aktivní. Tyto strategie pomáhají optimalizovat výkon a zajistit lepší uživatelskou zkušenost v aplikacích v reálném čase.