C#-Uniform Render Streaming dengan WebRTC untuk Pemesejan Teks Dwi Arah daripada Unity Client ke Pelayan JavaScript

Mendayakan Komunikasi Masa Nyata Antara Perpaduan dan JavaScript Menggunakan WebRTC

Dengan permintaan yang semakin meningkat untuk komunikasi masa nyata dalam aplikasi, pembangun memanfaatkan WebRTC untuk menghantar video, audio dan data dengan lancar. Dalam konteks ini, Unity Render Streaming menawarkan rangka kerja yang berkuasa untuk menstrim video daripada pelayan JavaScript kepada klien Unity. Walau bagaimanapun, mewujudkan komunikasi dua hala—seperti menghantar semula mesej teks daripada Unity ke pelayan JavaScript—boleh menjadi satu cabaran.

Dalam projek ini, kami menyasarkan untuk membina aplikasi penstriman dengan menggunakan pemalam Unity Render Streaming bersama-sama dengan protokol WebRTC. Walaupun bahagian penstriman video telah berjaya dikonfigurasikan, langkah seterusnya melibatkan mendayakan pertukaran data melalui RTCDataChannel. Ini akan membolehkan mesej teks dihantar daripada klien Unity semasa strim video aktif.

Kami akan meneroka cara mengubah suai sampel kod sedia ada untuk memenuhi keperluan ini. Apl web berasaskan JavaScript akan mengurus penstriman video, manakala klien Unity akan cuba menghantar contoh mesej seperti "Hello World" kembali ke pelayan. Kami akan menelusuri cabaran konfigurasi yang dihadapi dan potensi penyelesaiannya.

Artikel ini juga membincangkan isu seperti ruang nama yang tiada dan rujukan yang tidak dapat diselesaikan dalam Unity. Kami akan menilai sama ada kod semasa berada di landasan yang betul dan menyediakan penyelesaian untuk menyelesaikan masalah biasa, seperti ralat yang berkaitan dengan 'SingleConnection'. Pada akhirnya, kami menyasarkan untuk mewujudkan saluran pemesejan teks dua hala yang lancar antara Unity dan JavaScript menggunakan WebRTC.

Membina Sistem Pemesejan Unity-to-JavaScript dengan WebRTC

Matlamat projek ini adalah untuk menggunakan Penstriman Render Perpaduan pemalam dengan WebRTC untuk menghantar video daripada pelayan JavaScript kepada klien Unity, sambil menghantar semula mesej data daripada Unity. Langkah pertama dalam skrip JavaScript melibatkan penyediaan aliran media. Kami menggunakan kaedah `captureStream()` untuk menstrim kandungan video daripada elemen HTML5 dan a RTCPeerConnection objek menguruskan hubungan antara dua rakan sebaya. Saluran Data dibuat dalam sambungan ini, yang membolehkan data bukan media (seperti teks) dihantar bersama strim video.

Di bahagian Unity, kami memulakan sambungan WebRTC dalam skrip `ReceiverSample.cs` dengan menyediakan RTCDataChannel. Saluran ini bertanggungjawab untuk menghantar dan menerima data teks ke pelayan JavaScript. Fungsi coroutine digunakan untuk menghantar mesej "Hello World" berulang kali setiap dua saat, hanya jika keadaan saluran ialah "Buka". Apabila Saluran Data pada pelayan JavaScript menerima mesej, ia log kandungan ke konsol untuk mengesahkan sambungan yang berjaya.

Isu kritikal yang diserlahkan semasa proses ini ialah rujukan yang tiada kepada ruang nama `SingleConnection` dalam kod Unity, menyebabkan ralat penyusunan. Ini menunjukkan bahawa sama ada pakej yang diperlukan tiada atau terdapat pergantungan yang salah dalam konfigurasi projek. Untuk menyelesaikan masalah ini, kami mengesyorkan agar anda mengesahkan bahawa semua kebergantungan yang diperlukan, seperti pakej Unity WebRTC, dipasang dan dirujuk dengan betul. Jika pakej tidak tersedia, kelas mungkin perlu diganti dengan standard RTCPeerConnection objek.

Akhir sekali, mekanisme pengendalian ralat untuk kedua-dua skrip memastikan sambungan yang gagal dilaporkan dalam konsol, membantu dengan penyahpepijatan. Skrip Unity termasuk fungsi `StartCoroutine()` untuk mengurus pemesejan tak segerak, yang berguna dalam mengekalkan pertukaran data masa nyata tanpa menyekat proses lain. Kami juga menggunakan acara `OnOpen` dan `OnClose` untuk memantau keadaan Saluran Data, memastikan bahawa mesej hanya dihantar apabila sambungan stabil. Persediaan modular ini memastikan bahawa kod boleh dipanjangkan atau diubah suai dengan mudah, dan ia menyediakan titik permulaan yang kukuh untuk membina aplikasi penstriman yang lebih maju menggunakan Unity dan 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);
  }
}

Meneroka Cabaran Penghantaran Data dalam Perpaduan dan Penstriman WebRTC

Selain penstriman video, membolehkan komunikasi data antara klien Unity dan pelayan JavaScript menggunakan WebRTC membuka kemungkinan baharu. Walau bagaimanapun, melaksanakan komunikasi sedemikian tidak selalunya mudah, terutamanya apabila anda menyepadukan pemalam Unity Render Streaming. Isu biasa yang dihadapi ialah menyediakan dan mengurus dengan betul RTCDataChannel untuk komunikasi teks yang lancar. Dalam contoh kami, klien Unity sepatutnya boleh menghantar mesej "Hello World" kembali ke pelayan JavaScript. Langkah ini memerlukan pengendalian yang teliti terhadap kedua-dua persekitaran skrip Unity dan nuansa protokol WebRTC.

Satu cabaran penting melibatkan pengurusan pergantungan dalam Perpaduan. Ralat seperti ruang nama `SingleConnection` yang hilang dalam kod `ReceiverSample.cs` kami menyerlahkan keperluan untuk memastikan semua pemalam yang diperlukan, termasuk WebRTC, dipasang dengan betul. Amalan yang baik di sini ialah menyemak keserasian antara versi Unity dan versi pemalam yang sedang digunakan. Isu ini juga boleh berpunca daripada komponen Unity Render Streaming yang sudah lapuk atau tiada, yang perlu dikonfigurasikan dengan yang betul sambungan objek.

Di sebalik isu teknikal, aspek tambahan untuk diterokai ialah kependaman antara Unity dan JavaScript melalui WebRTC. Walaupun WebRTC menyediakan komunikasi kependaman rendah, keadaan rangkaian masih boleh menjejaskan penghantaran mesej. Menggunakan coroutine dalam Unity membolehkan penghantaran mesej tidak menyekat, memastikan penghantaran data teks (mis., melalui `StartCoroutine`) tidak mengganggu penstriman video. Menguji kestabilan sambungan melalui `RTCDataChannelState` ialah satu lagi amalan utama untuk memastikan bahawa mesej hanya dihantar apabila saluran aktif. Strategi ini membantu mengoptimumkan prestasi dan memastikan pengalaman pengguna yang lebih baik dalam aplikasi masa nyata.