WebRTC: Comunicazioni Real Time per il Web

19 marzo 2013

RTCPeerConnection

Queste API sono più complicate delle precedenti, in essenza la loro funzione è di mettere in contatto due device in modalità peer-to-peer. La procedura che ci consente di attuare questo collegamento è la seguente:

  • Abbiamo due device, Alice e Bob. Alice vuole contattare Bob ed aprire un canale peer-to-peer.
  • Alice crea un oggetto RTCPeerConnection e si mette in ascolto dell’evento onicecandidate; che viene lanciato quando l’oggetto è pronto a trasmettere.
  • Appena intercetta l’evento onicecandidate Alice comunica a Bob l’identificatore univoco del proprio canale peer-to-peer (in realtà composto da una serie di oggetti secondo le specifiche del framework ICE, usato alla base delle comunicazioni WebRTC).
  • Bob utilizza il metodo addIceCandidate sul proprio oggetto RTCPeerConnection per aggiungere Alice come destinatario.
  • Alice genera con il metodo createOffer una stringa SDP: Session Description Protocol, che descrive i vincoli al flusso audio/video (codec, etc.) del proprio device. Questa stringa viene inviata a Bob.
  • Bob riceve questa stringa e genera un SDP di risposta con il metodo createAnswer. Questa stringa viene inviata ad Alice.
  • Sia Alice che Bob ricevono l’evento addstream che contiene il flusso dati del partner e possono decidere di caricarlo in un elemento video come abbiamo visto nell’esempio precedente.

Per sperimentare queste API dobbiamo avvalerci di Chrome poiché il supporto su altri browser è, come abbiamo detto, limitato soltanto alla versione Nightly di Firefox. Per gestire lo scambio dei messaggi tra Alice e Bob precedenti all’apertura del canale P2P utilizziamo il protocollo websocket; per prima cosa quindi dotiamoci di un server websocket che sappia mettere in comunicazioni due browser per il tempo necessario all’apertura del canaler peer-to-peer.

Fortunatamente possiamo soddisfare questo prerequisito con uno script di poche righe in Ruby. Se non abbiamo mai installato questo interprete seguiamo le istruzioni. Completata l’installazione lanciamo dal terminale il comando gem install em-websocket e creiamo un file webserver.rb contenente:

require 'rubygems'
require 'em-websocket'

EventMachine.run do
    @channels = {}
    
    EventMachine::WebSocket.start(
      :host => "0.0.0.0", :port => 8080) do |ws|     

      ws.onmessage do |msg|
        command, params = msg.split(":",2)
        if(command == "c")
          @channels[msg[2..-1]] ||= EM::Channel.new 
          @channels[msg[2..-1]].subscribe{ |msg| ws.send msg }
        else
          room, message = params.split(":",2)
          @channels[room].push message
        end
      end  
    end
    
end

Anche se probabilmente stiamo osservando codice in un linguaggio sconosciuto, possiamo comunque cercare di intuirne il comportamento:

  • Il server si mette in ascolto sulla porta 8080; a ogni connessione ws è valorizzata con un riferimento al client;
  • Ogni qualvolta un client invia un messaggio al server il blocco di codice associato a ws.onmessage viene eseguito;
  • Se il messaggio è nella forma c:x, dove x è un numero arbitrario, viene cercato un canale di comunicazione (o creato, se inesistente) associato alla chiave x. Il client viene quindi aggiunto a questo canale di comunicazione;
  • Se il messaggio è nella forma m:x:txt, dove x è un numero arbitrario e txt rappresenta del testo, il messaggio txt viene inviato attraverso il canale di comunicazione associato alla chiave x a tutti i client ad esso connessi.

Eseguiamo il server digitando da linea di comando ruby webserver.rb e, mantenendo il server in esecuzione, prepariamoci alla seconda parte del progetto.

Se vuoi aggiornamenti su WebRTC: Comunicazioni Real Time per il Web inserisci la tua e-mail nel box qui sotto:
 
X
Se vuoi aggiornamenti su WebRTC: Comunicazioni Real Time per il Web

inserisci la tua e-mail nel box qui sotto:

Ho letto e acconsento l'informativa sulla privacy

Acconsento al trattamento di cui al punto 3 dell'informativa sulla privacy