யூனிட்டி கிளையண்டிலிருந்து ஜாவாஸ்கிரிப்ட் சேவையகத்திற்கு இருதரப்பு உரைச் செய்தி அனுப்புவதற்கு WebRTC உடன் சீரான ரெண்டர் ஸ்ட்ரீமிங்

WebRTC ஐப் பயன்படுத்தி ஒற்றுமை மற்றும் ஜாவாஸ்கிரிப்ட் இடையே நிகழ்நேர தொடர்புகளை இயக்குதல்

பயன்பாடுகளில் நிகழ்நேர தகவல்தொடர்புக்கான தேவை அதிகரித்து வருவதால், டெவலப்பர்கள் வீடியோ, ஆடியோ மற்றும் தரவை தடையின்றி அனுப்ப WebRTC ஐ மேம்படுத்துகின்றனர். இந்த சூழலில், யூனிட்டி ரெண்டர் ஸ்ட்ரீமிங் ஒரு ஜாவாஸ்கிரிப்ட் சர்வரிலிருந்து யூனிட்டி கிளையண்டிற்கு வீடியோவை ஸ்ட்ரீம் செய்வதற்கான சக்திவாய்ந்த கட்டமைப்பை வழங்குகிறது. இருப்பினும், யூனிட்டியிலிருந்து ஜாவாஸ்கிரிப்ட் சேவையகத்திற்கு உரைச் செய்திகளை அனுப்புவது போன்ற இருதரப்புத் தொடர்பை நிறுவுவது சவாலாக இருக்கலாம்.

இந்தத் திட்டத்தில், WebRTC நெறிமுறையுடன் யூனிட்டி ரெண்டர் ஸ்ட்ரீமிங் செருகுநிரலைப் பயன்படுத்தி ஸ்ட்ரீமிங் பயன்பாட்டை உருவாக்குவதை நோக்கமாகக் கொண்டுள்ளோம். வீடியோ ஸ்ட்ரீமிங் பகுதி வெற்றிகரமாக உள்ளமைக்கப்பட்ட நிலையில், RTCDataChannel மூலம் தரவுப் பரிமாற்றத்தை இயக்குவது அடுத்த படியாகும். செயலில் உள்ள வீடியோ ஸ்ட்ரீம்களின் போது யூனிட்டி கிளையண்டிலிருந்து உரைச் செய்திகளை அனுப்ப இது அனுமதிக்கும்.

இந்தத் தேவைகளைப் பூர்த்தி செய்ய ஏற்கனவே உள்ள குறியீடு மாதிரிகளை எவ்வாறு மாற்றுவது என்பதை ஆராய்வோம். ஜாவாஸ்கிரிப்ட்-அடிப்படையிலான வலைப் பயன்பாடு வீடியோ ஸ்ட்ரீமிங்கை நிர்வகிக்கும், அதே நேரத்தில் யூனிட்டி கிளையன்ட் "ஹலோ வேர்ல்ட்" போன்ற மாதிரி செய்தியை சேவையகத்திற்கு அனுப்ப முயற்சிக்கும். நாங்கள் எதிர்கொள்ளும் உள்ளமைவு சவால்கள் மற்றும் அவற்றின் சாத்தியமான தீர்வுகள் மூலம் நடப்போம்.

இந்த கட்டுரையில் காணாமல் போன பெயர்வெளிகள் மற்றும் ஒற்றுமையில் தீர்க்கப்படாத குறிப்புகள் போன்ற சிக்கல்களையும் விவாதிக்கிறது. தற்போதைய குறியீடு சரியான பாதையில் உள்ளதா என்பதை மதிப்பிட்டு, 'SingleConnection' தொடர்பான பிழை போன்ற பொதுவான சிக்கல்களைச் சரிசெய்வதற்கான தீர்வுகளை வழங்குவோம். முடிவில், WebRTC ஐப் பயன்படுத்தி யூனிட்டி மற்றும் ஜாவாஸ்கிரிப்ட் இடையே மென்மையான, இருதரப்பு உரைச் செய்தி அனுப்பும் பைப்லைனை நிறுவுவதை நோக்கமாகக் கொண்டுள்ளோம்.

WebRTC உடன் யூனிட்டி-டு-ஜாவாஸ்கிரிப்ட் மெசேஜிங் சிஸ்டத்தை உருவாக்குதல்

பயன்படுத்துவதே இந்த திட்டத்தின் குறிக்கோள் யூனிட்டி ரெண்டர் ஸ்ட்ரீமிங் ஜாவாஸ்கிரிப்ட் சர்வரிலிருந்து யூனிட்டி கிளையண்டிற்கு வீடியோவை அனுப்ப WebRTC உடன் சொருகி, யூனிட்டியிலிருந்து தரவு செய்திகளை அனுப்பவும். ஜாவாஸ்கிரிப்ட் ஸ்கிரிப்ட்டின் முதல் படி மீடியா ஸ்ட்ரீமை அமைப்பதை உள்ளடக்கியது. HTML5 உறுப்பிலிருந்து வீடியோ உள்ளடக்கத்தை ஸ்ட்ரீம் செய்ய `captureStream()` முறையைப் பயன்படுத்துகிறோம். RTCPeerConnection பொருள் இரண்டு சகாக்களுக்கு இடையிலான தொடர்பை நிர்வகிக்கிறது. இந்த இணைப்பிற்குள் ஒரு DataChannel உருவாக்கப்பட்டது, இது ஊடகம் அல்லாத தரவை (உரை போன்றது) வீடியோ ஸ்ட்ரீமுடன் அனுப்ப உதவுகிறது.

யூனிட்டி பக்கத்தில், WebRTC இணைப்பை அமைப்பதன் மூலம் `ReceiverSample.cs` ஸ்கிரிப்ட்டில் தொடங்குகிறோம் RTCDataChannel. JavaScript சேவையகத்திற்கு உரைத் தரவை அனுப்புதல் மற்றும் பெறுதல் ஆகிய இரண்டிற்கும் இந்த சேனல் பொறுப்பாகும். சேனலின் நிலை "திறந்திருந்தால்" மட்டுமே, ஒவ்வொரு இரண்டு வினாடிகளுக்கும் "ஹலோ வேர்ல்ட்" என்ற செய்தியை மீண்டும் மீண்டும் அனுப்ப ஒரு கரோட்டின் செயல்பாடு பயன்படுத்தப்படுகிறது. ஜாவாஸ்கிரிப்ட் சர்வரில் உள்ள டேட்டா சேனல் ஒரு செய்தியைப் பெறும்போது, ​​வெற்றிகரமான இணைப்பை உறுதிப்படுத்த, உள்ளடக்கத்தை கன்சோலில் பதிவு செய்கிறது.

இந்தச் செயல்பாட்டின் போது முன்னிலைப்படுத்தப்பட்ட ஒரு முக்கியமான சிக்கல், யூனிட்டி குறியீட்டில் உள்ள `SingleConnection` நேம்ஸ்பேஸ் பற்றிய விடுபட்ட குறிப்பு, இது தொகுத்தல் பிழைகளை ஏற்படுத்துகிறது. இது தேவையான தொகுப்பு காணவில்லை அல்லது திட்ட கட்டமைப்பில் தவறான சார்பு உள்ளது என்று தெரிவிக்கிறது. இதைத் தீர்க்க, Unity WebRTC தொகுப்பு போன்ற தேவையான அனைத்து சார்புகளும் சரியாக நிறுவப்பட்டு, குறிப்பிடப்பட்டுள்ளனவா என்பதைச் சரிபார்க்க பரிந்துரைக்கிறோம். தொகுப்பு கிடைக்கவில்லை என்றால், வகுப்பை ஒரு தரநிலையுடன் மாற்ற வேண்டியிருக்கும் RTCPeerConnection பொருள்.

இறுதியாக, இரண்டு ஸ்கிரிப்ட்களுக்கான பிழை-கையாளுதல் பொறிமுறையானது, தோல்வியுற்ற இணைப்புகள் கன்சோலில் புகாரளிக்கப்படுவதை உறுதிசெய்கிறது, இது பிழைத்திருத்தத்திற்கு உதவுகிறது. யூனிட்டி ஸ்கிரிப்ட் ஒத்திசைவற்ற செய்தியிடலை நிர்வகிப்பதற்கான `StartCoroutine()` செயல்பாட்டை உள்ளடக்கியது, இது மற்ற செயல்முறைகளைத் தடுக்காமல் நிகழ்நேர தரவு பரிமாற்றத்தை பராமரிக்க பயனுள்ளதாக இருக்கும். டேட்டாசேனலின் நிலையைக் கண்காணிக்க `OnOpen` மற்றும் `OnClose` நிகழ்வுகளையும் நாங்கள் பயன்படுத்துகிறோம், இணைப்பு நிலையாக இருக்கும்போது மட்டுமே செய்திகள் அனுப்பப்படும் என்பதை உறுதிசெய்கிறோம். இந்த மட்டு அமைப்பு குறியீட்டை நீட்டிக்க அல்லது எளிதாக மாற்றுவதை உறுதி செய்கிறது, மேலும் இது Unity மற்றும் 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);
  }
}

ஒற்றுமை மற்றும் WebRTC ஸ்ட்ரீமிங்கில் தரவு பரிமாற்ற சவால்களை ஆராய்தல்

வீடியோ ஸ்ட்ரீமிங்குடன் கூடுதலாக, செயல்படுத்துகிறது தரவு தொடர்பு WebRTC ஐப் பயன்படுத்தும் யூனிட்டி கிளையண்ட் மற்றும் ஜாவாஸ்கிரிப்ட் சர்வர் இடையே புதிய சாத்தியக்கூறுகளைத் திறக்கிறது. இருப்பினும், அத்தகைய தகவல்தொடர்புகளை செயல்படுத்துவது எப்போதும் நேரடியானதாக இருக்காது, குறிப்பாக யூனிட்டி ரெண்டர் ஸ்ட்ரீமிங் செருகுநிரலை நீங்கள் ஒருங்கிணைக்கும்போது. எதிர்கொள்ளும் பொதுவான சிக்கல் சரியாக அமைப்பது மற்றும் நிர்வகிப்பது RTCDataChannel தடையற்ற உரை தொடர்புக்கு. எங்கள் எடுத்துக்காட்டில், யூனிட்டி கிளையண்ட் ஜாவாஸ்கிரிப்ட் சேவையகத்திற்கு "ஹலோ வேர்ல்ட்" செய்தியை அனுப்ப முடியும். யூனிட்டியின் ஸ்கிரிப்டிங் சூழல் மற்றும் WebRTC இன் நெறிமுறை நுணுக்கங்கள் இரண்டையும் கவனமாகக் கையாள்வது இந்தப் படிக்குத் தேவைப்படுகிறது.

ஒரு முக்கியமான சவால் ஒற்றுமையில் சார்பு மேலாண்மையை உள்ளடக்கியது. WebRTC உட்பட தேவையான அனைத்து செருகுநிரல்களும் சரியாக நிறுவப்பட்டுள்ளதை உறுதிசெய்ய வேண்டியதன் அவசியத்தை எங்கள் `ReceiverSample.cs` குறியீட்டில் விடுபட்ட `SingleConnection` பெயர்வெளி போன்ற பிழைகள் எடுத்துக்காட்டுகின்றன. யூனிட்டி பதிப்பிற்கும் பயன்பாட்டில் உள்ள செருகுநிரல் பதிப்பிற்கும் இடையே உள்ள இணக்கத்தன்மையை சரிபார்ப்பது இங்கு ஒரு நல்ல நடைமுறையாகும். காலாவதியான அல்லது விடுபட்ட யூனிட்டி ரெண்டர் ஸ்ட்ரீமிங் கூறுகளிலிருந்தும் சிக்கல் ஏற்படலாம், அவை சரியானவையுடன் கட்டமைக்கப்பட வேண்டும் இணைப்பு பொருள்கள்.

தொழில்நுட்ப சிக்கல்களுக்கு அப்பால், WebRTC மூலம் Unity மற்றும் JavaScript இடையே உள்ள தாமதத்தை ஆராய வேண்டிய கூடுதல் அம்சம். WebRTC குறைந்த தாமத தகவல்தொடர்புகளை வழங்கும் அதே வேளையில், நெட்வொர்க் நிலைமைகள் செய்தி விநியோகத்தை இன்னும் பாதிக்கலாம். யூனிட்டியில் உள்ள கொரூட்டீன்களைப் பயன்படுத்துவது, குறுஞ்செய்தி தரவை (எ.கா. `StartCoroutine` வழியாக) அனுப்புவது, வீடியோ ஸ்ட்ரீமிங்கில் குறுக்கிடாமல் இருப்பதை உறுதிசெய்து, செய்திகளை அனுப்புவதைத் தடுக்காமல் அனுமதிக்கிறது. `RTCDataChannelState` மூலம் இணைப்பின் நிலைத்தன்மையைச் சோதிப்பது, சேனல் செயலில் இருக்கும்போது மட்டுமே செய்திகள் அனுப்பப்படுவதை உறுதிசெய்வதற்கான மற்றொரு முக்கிய நடைமுறையாகும். இந்த உத்திகள் செயல்திறனை மேம்படுத்தவும், நிகழ்நேர பயன்பாடுகளில் சிறந்த பயனர் அனுபவத்தை உறுதிப்படுத்தவும் உதவுகின்றன.