C# — jednolite renderowanie strumieniowe z WebRTC do dwukierunkowego przesyłania wiadomości tekstowych od klienta Unity do serwera JavaScript

Umożliwianie komunikacji w czasie rzeczywistym pomiędzy Unity i JavaScript przy użyciu WebRTC

Wraz z rosnącym zapotrzebowaniem na komunikację w czasie rzeczywistym w aplikacjach programiści wykorzystują WebRTC do płynnego przesyłania obrazu, dźwięku i danych. W tym kontekście Unity Render Streaming oferuje potężną platformę do strumieniowego przesyłania wideo z serwera JavaScript do klienta Unity. Jednak ustanowienie komunikacji dwukierunkowej — takiej jak wysyłanie wiadomości tekstowych z powrotem z Unity do serwera JavaScript — może być wyzwaniem.

W tym projekcie naszym celem jest zbudowanie aplikacji do przesyłania strumieniowego przy użyciu wtyczki Unity Render Streaming wraz z protokołem WebRTC. Po pomyślnym skonfigurowaniu części do przesyłania strumieniowego wideo następnym krokiem jest umożliwienie wymiany danych za pośrednictwem kanału RTCDataChannel. Umożliwi to wysyłanie wiadomości tekstowych z klienta Unity podczas aktywnych strumieni wideo.

Zbadamy, jak zmodyfikować istniejące próbki kodu, aby spełnić te wymagania. Aplikacja internetowa oparta na JavaScript będzie zarządzać strumieniowaniem wideo, podczas gdy klient Unity spróbuje wysłać przykładową wiadomość, taką jak „Hello World”, z powrotem na serwer. Omówimy napotkane wyzwania konfiguracyjne i ich potencjalne rozwiązania.

W tym artykule omówiono także problemy, takie jak brakujące przestrzenie nazw i nierozwiązane odniesienia w Unity. Ocenimy, czy obecny kod jest na dobrej drodze i zapewnimy rozwiązania rozwiązujące typowe problemy, takie jak błąd związany z „SingleConnection”. Do końca naszym celem jest ustanowienie płynnego, dwukierunkowego potoku przesyłania wiadomości tekstowych pomiędzy Unity i JavaScript przy użyciu WebRTC.

Budowanie systemu przesyłania wiadomości w formacie Unity-to-JavaScript za pomocą WebRTC

Celem tego projektu jest wykorzystanie Transmisja strumieniowa renderowania Unity wtyczka z WebRTC do przesyłania wideo z serwera JavaScript do klienta Unity, jednocześnie wysyłając wiadomości danych z powrotem z Unity. Pierwszy krok w skrypcie JavaScript polega na skonfigurowaniu strumienia multimediów. Do strumieniowego przesyłania treści wideo z elementu HTML5 używamy metody „captureStream()”. Połączenie RTCPeer obiekt zarządza połączeniem pomiędzy dwoma urządzeniami równorzędnymi. W ramach tego połączenia tworzony jest kanał DataChannel, który umożliwia przesyłanie danych innych niż media (takich jak tekst) wraz ze strumieniem wideo.

Po stronie Unity inicjujemy połączenie WebRTC w skrypcie `ReceiverSample.cs`, konfigurując Kanał RTCData. Kanał ten odpowiada zarówno za wysyłanie, jak i odbieranie danych tekstowych do serwera JavaScript. Funkcja współprogramu służy do wielokrotnego wysyłania wiadomości „Hello World” co dwie sekundy, tylko jeśli stan kanału to „Otwarty”. Kiedy DataChannel na serwerze JavaScript odbierze komunikat, rejestruje zawartość w konsoli, aby potwierdzić pomyślne połączenie.

Krytycznym problemem podkreślonym podczas tego procesu jest brak odniesienia do przestrzeni nazw „SingleConnection” w kodzie Unity, powodujący błędy kompilacji. Sugeruje to, że albo brakuje wymaganego pakietu, albo występuje nieprawidłowa zależność w konfiguracji projektu. Aby rozwiązać ten problem, zalecamy sprawdzenie, czy wszystkie niezbędne zależności, takie jak pakiet Unity WebRTC, są poprawnie zainstalowane i przywoływane. Jeżeli pakiet jest niedostępny, może zaistnieć potrzeba zastąpienia klasy standardem Połączenie RTCPeer obiekt.

Wreszcie mechanizm obsługi błędów w obu skryptach zapewnia raportowanie w konsoli nieudanych połączeń, co pomaga w debugowaniu. Skrypt Unity zawiera funkcję „StartCoroutine()” do zarządzania asynchronicznym przesyłaniem komunikatów, co jest przydatne w utrzymywaniu wymiany danych w czasie rzeczywistym bez blokowania innych procesów. Używamy również zdarzeń `OnOpen` i `OnClose` do monitorowania stanu DataChannel, zapewniając, że wiadomości są wysyłane tylko wtedy, gdy połączenie jest stabilne. Ta modułowa konfiguracja zapewnia łatwe rozszerzanie i modyfikowanie kodu oraz stanowi solidny punkt wyjścia do tworzenia bardziej zaawansowanych aplikacji do przesyłania strumieniowego przy użyciu Unity i 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);
  }
}

Odkrywanie wyzwań związanych z transmisją danych w Unity i transmisji strumieniowej WebRTC

Oprócz strumieniowego przesyłania wideo, włączenie komunikacja danych pomiędzy klientem Unity a serwerem JavaScript przy użyciu WebRTC otwiera nowe możliwości. Jednak wdrożenie takiej komunikacji nie zawsze jest proste, zwłaszcza gdy zintegrujesz wtyczkę Unity Render Streaming. Częstym problemem jest prawidłowe skonfigurowanie i zarządzanie plikiem Kanał RTCData do płynnej komunikacji tekstowej. W naszym przykładzie klient Unity powinien móc wysłać wiadomość „Hello World” z powrotem do serwera JavaScript. Ten krok wymaga ostrożnej obsługi zarówno środowiska skryptowego Unity, jak i niuansów protokołu WebRTC.

Jednym z ważnych wyzwań jest zarządzanie zależnościami w Unity. Błędy takie jak brakująca przestrzeń nazw `SingleConnection` w naszym kodzie `ReceiverSample.cs` podkreślają potrzebę upewnienia się, że wszystkie niezbędne wtyczki, w tym WebRTC, są poprawnie zainstalowane. Dobrą praktyką jest sprawdzenie zgodności między wersją Unity a używaną wersją wtyczki. Problem może również wynikać z przestarzałych lub brakujących komponentów Unity Render Streaming, które należy skonfigurować przy użyciu odpowiednich ustawień połączenie obiekty.

Poza kwestiami technicznymi dodatkowym aspektem do zbadania jest opóźnienie między Unity i JavaScript w WebRTC. Chociaż WebRTC zapewnia komunikację o niskim opóźnieniu, warunki sieciowe mogą nadal mieć wpływ na dostarczanie wiadomości. Używanie współprogramów w Unity pozwala na nieblokujące dostarczanie wiadomości, zapewniając, że wysyłanie danych tekstowych (np. przez `StartCoroutine`) nie zakłóca strumieniowania wideo. Testowanie stabilności połączenia za pomocą `RTCDataChannelState` to kolejna kluczowa praktyka zapewniająca, że ​​komunikaty są wysyłane tylko wtedy, gdy kanał jest aktywny. Strategie te pomagają zoptymalizować wydajność i zapewnić lepsze doświadczenie użytkownika w aplikacjach czasu rzeczywistego.