C#-Uniform Render Streaming su WebRTC, skirtas dvikrypčiams tekstiniams pranešimams iš Unity Client į JavaScript serverį

Realiojo laiko ryšio tarp „Unity“ ir „JavaScript“ įgalinimas naudojant WebRTC

Augant programų komunikacijos realiuoju laiku paklausai, kūrėjai naudoja WebRTC, kad sklandžiai perduotų vaizdą, garsą ir duomenis. Šiame kontekste „Unity Render Streaming“ siūlo galingą sistemą, skirtą vaizdo įrašams transliuoti iš „JavaScript“ serverio į „Unity“ klientą. Tačiau dvikrypčio ryšio užmezgimas, pvz., tekstinių pranešimų siuntimas iš Unity į JavaScript serverį, gali būti iššūkis.

Šiame projekte mes siekiame sukurti srautinio perdavimo programą naudodami Unity Render Streaming papildinį kartu su WebRTC protokolu. Nors vaizdo transliacijos dalis buvo sėkmingai sukonfigūruota, kitas veiksmas apima duomenų mainų per RTCDataChannel įgalinimą. Tai leis siųsti tekstinius pranešimus iš Unity kliento aktyvių vaizdo srautų metu.

Išnagrinėsime, kaip pakeisti esamus kodo pavyzdžius, kad jie atitiktų šiuos reikalavimus. „JavaScript“ pagrindu sukurta žiniatinklio programa valdys vaizdo transliaciją, o „Unity“ klientas bandys siųsti pavyzdinį pranešimą, pvz., „Hello World“, atgal į serverį. Apžvelgsime konfigūracijos iššūkius ir galimus jų sprendimus.

Šiame straipsnyje taip pat aptariamos tokios problemos kaip trūkstamos vardų erdvės ir neišspręstos Unity nuorodos. Įvertinsime, ar dabartinis kodas yra teisingas, ir pateiksime sprendimus, kaip išspręsti įprastas problemas, pvz., klaidą, susijusią su „SingleConnection“. Pabaigoje, naudodami WebRTC, siekiame sukurti sklandų, dvikryptį tekstinių pranešimų srautą tarp Unity ir JavaScript.

„Unity-to-JavaScript“ pranešimų sistemos kūrimas naudojant „WebRTC“.

Šio projekto tikslas – panaudoti Unity Render Streaming papildinys su WebRTC, kad būtų galima perduoti vaizdo įrašą iš JavaScript serverio į Unity klientą, o taip pat siųsti duomenų pranešimus atgal iš Unity. Pirmasis JavaScript scenarijaus veiksmas apima medijos srauto nustatymą. Naudojame metodą „captureStream()“, norėdami srautiniu būdu perduoti vaizdo turinį iš HTML5 elemento ir RTCPeerConnection objektas valdo ryšį tarp dviejų bendraamžių. Šiuo ryšiu sukuriamas duomenų kanalas, leidžiantis kartu su vaizdo srautu perduoti ir ne medijos duomenis (pvz., tekstą).

„Unity“ pusėje inicijuojame WebRTC ryšį „ReceiverSample.cs“ scenarijuje, nustatydami RTCDataChannel. Šis kanalas yra atsakingas už tekstinių duomenų siuntimą ir gavimą į JavaScript serverį. Korutinos funkcija naudojama pakartotinai kas dvi sekundes išsiųsti pranešimą „Hello World“, tik jei kanalo būsena yra „Open“. Kai „JavaScript“ serverio „DataChannel“ gauna pranešimą, jis registruoja turinį konsolėje, kad patvirtintų sėkmingą ryšį.

Kritinė šio proceso metu išryškinta problema yra vienybės kode trūkstama nuoroda į „SingleConnection“ vardų sritį, dėl kurios atsiranda kompiliavimo klaidų. Tai rodo, kad trūksta reikiamo paketo arba projekto konfigūracijoje yra neteisinga priklausomybė. Norėdami tai išspręsti, rekomenduojame patikrinti, ar visos būtinos priklausomybės, pvz., Unity WebRTC paketas, yra tinkamai įdiegtos ir nurodytos. Jei paketo nėra, klasę gali tekti pakeisti standartine RTCPeerConnection objektas.

Galiausiai, abiejų scenarijų klaidų apdorojimo mechanizmas užtikrina, kad konsolėje būtų pranešama apie nesėkmingus ryšius, o tai padeda derinti. „Unity“ scenarijus apima „StartCoroutine()“ funkciją, skirtą asinchroniniam susirašinėjimui valdyti, kuri yra naudinga palaikant duomenų mainus realiuoju laiku, neblokuojant kitų procesų. Taip pat naudojame įvykius „OnOpen“ ir „OnClose“, kad stebėtume „DataChannel“ būseną, užtikrindami, kad pranešimai būtų siunčiami tik tada, kai ryšys yra stabilus. Ši modulinė sąranka užtikrina, kad kodą būtų galima lengvai išplėsti arba modifikuoti, ir tai yra tvirtas atskaitos taškas kuriant pažangesnes srautinio perdavimo programas naudojant „Unity“ ir „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);
  }
}

„Unity“ ir „WebRTC Streaming“ duomenų perdavimo iššūkių tyrinėjimas

Be vaizdo transliacijos, įgalinimas duomenų perdavimo tarp Unity kliento ir JavaScript serverio naudojant WebRTC atveria naujas galimybes. Tačiau įdiegti tokį ryšį ne visada paprasta, ypač kai integruojate Unity Render Streaming papildinį. Dažna problema, su kuria susiduriama, yra tinkamas nustatymas ir valdymas RTCDataChannel sklandžiam tekstiniam bendravimui. Mūsų pavyzdyje „Unity“ klientas turėtų galėti siųsti „Hello World“ pranešimą atgal į „JavaScript“ serverį. Šiam veiksmui reikia atidžiai tvarkyti „Unity“ scenarijų aplinką ir „WebRTC“ protokolo niuansus.

Vienas svarbus iššūkis yra priklausomybės valdymas Unity. Klaidos, pvz., trūkstama „SingleConnection“ vardų sritis „ReceiverSample.cs“ kode, pabrėžia būtinybę užtikrinti, kad visi reikalingi papildiniai, įskaitant „WebRTC“, būtų įdiegti tinkamai. Gera praktika yra patikrinti Unity versijos ir naudojamos papildinio versijos suderinamumą. Problema taip pat gali kilti dėl pasenusių arba trūkstamų Unity Render Streaming komponentų, kuriuos reikia sukonfigūruoti naudojant tinkamą ryšį objektų.

Be techninių problemų, papildomas aspektas, kurį reikia ištirti, yra „Unity“ ir „JavaScript“ delsa per WebRTC. Nors WebRTC teikia mažos delsos ryšį, tinklo sąlygos vis tiek gali turėti įtakos pranešimų pristatymui. Naudojant „Unity“ programas, pranešimų siuntimas neblokuojamas, užtikrinant, kad siunčiant tekstinius duomenis (pvz., naudojant „StartCoroutine“) nebūtų pertraukiamas vaizdo srautas. Ryšio stabilumo tikrinimas naudojant „RTCDataChannelState“ yra dar viena svarbi praktika, užtikrinanti, kad pranešimai būtų siunčiami tik tada, kai kanalas yra aktyvus. Šios strategijos padeda optimizuoti našumą ir užtikrinti geresnę vartotojo patirtį naudojant programas realiuoju laiku.