Golang WebRTC. Como usar Pion 🌐Remote Controller

var offerEncodedWithCandidates string //OfferFromServer
var answerResponse := make(chan string) //AnswerFromClient

// SPDX-FileCopyrightText: 2023 The Pion community <https://pion.ly>
// SPDX-License-Identifier: MIT

// Package signal contains helpers to exchange the SDP session
// description between examples.
package <package>

import (
    "bytes"
    "compress/gzip"
    "encoding/base64"
    "encoding/json"
    "io"
)

// Allows compressing offer/answer to bypass terminal input limits.
const compress = true

// signalEncode encodes the input in base64
// It can optionally zip the input before encoding
func signalEncode(obj interface{}) string {
    b, err := json.Marshal(obj)
    if err != nil {
        panic(err)
    }

    if compress {
        b = signalZip(b)
    }

    return base64.StdEncoding.EncodeToString(b)
}

// signalDecode decodes the input from base64
// It can optionally unzip the input after decoding
func signalDecode(in string, obj interface{}) {
    b, err := base64.StdEncoding.DecodeString(in)
    if err != nil {
        panic(err)
    }

    if compress {
        b = signalUnzip(b)
    }

    err = json.Unmarshal(b, obj)
    if err != nil {
        panic(err)
    }
}

func signalZip(in []byte) []byte {
    var b bytes.Buffer
    gz := gzip.NewWriter(&b)
    _, err := gz.Write(in)
    if err != nil {
        panic(err)
    }
    err = gz.Flush()
    if err != nil {
        panic(err)
    }
    err = gz.Close()
    if err != nil {
        panic(err)
    }
    return b.Bytes()
}

func signalUnzip(in []byte) []byte {
    var b bytes.Buffer
    _, err := b.Write(in)
    if err != nil {
        panic(err)
    }
    r, err := gzip.NewReader(&b)
    if err != nil {
        panic(err)
    }
    res, err := io.ReadAll(r)
    if err != nil {
        panic(err)
    }
    return res
}

import (
    ...
    "github.com/pion/webrtc/v3"
)

// slice de ICECandidates 
candidates := []webrtc.ICECandidateInit{}

// Config struct con los servidores STUN
config := webrtc.Configuration{
        ICEServers: []webrtc.ICEServer{
            {
                URLs: []string{"stun:stun.l.google.com:19305", "stun:stun.l.google.com:19302"},
            },
        },
    }

// Creación de la conexión
peerConnection, err := webrtc.NewAPI().NewPeerConnection(config)
if err != nil {
        panic(err)
}

// Manejo del cerrado de conexión
defer func() {
        if err := peerConnection.Close(); err != nil {
            fmt.Printf("cannot close peerConnection: %v\n", err)
        }
}()

// Registrar los Datachannels y especificar su funcionamiento
peerConnection.OnDataChannel(func(d *webrtc.DataChannel) {

     if d.Label() == "numbers" {

       d.OnOpen(func() {

         // Mandar número 5 por el Datachannel "numbers"
          err := d.SendText("5")

          if err != nil {
              panic(err)
          }

       })
          return
    }

   if d.Label() == "other" {

      gamepadChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
                // Listening for channel called "other"
        fmt.Println(msg.Data)

      })

   }


})

// Escuchar por los ICEcandidates
peerConnection.OnICECandidate(func(c *webrtc.ICECandidate) {

   // When no more candidate available
   if c == nil {
    answerResponse <-signalEncode(*peerConnection.LocalDescription()) + ";" + signalEncode(candidates)
    return
   }

   candidates = append(candidates, (*c).ToJSON())

})

// Esto notificará cuando un extremo se ha conectado/desconectado
peerConnection.OnConnectionStateChange(func(s webrtc.PeerConnectionState) {
    fmt.Printf("Peer Connection State has changed: %s\n", s.String())

    if s == webrtc.PeerConnectionStateFailed {

        peerConnection.Close()

    }
})

// Separamos la oferta y los candidatos codificados

offerEncodedWithCandidatesSplited := strings.Split(offerEncodedWithCandidates, ";")

    offer := webrtc.SessionDescription{}
    signalDecode(offerEncodedWithCandidatesSplited[0], &offer)

    var receivedCandidates []webrtc.ICECandidateInit

    signalDecode(offerEncodedWithCandidatesSplited[1], &receivedCandidates)

// Then we set our remote description
    if err := peerConnection.SetRemoteDescription(offer); err != nil {
        panic(err)
    }
// After setting the remote description we add the candidates
    for _, candidate := range receivedCandidates {
        if err := peerConnection.AddICECandidate(candidate); err != nil {
            panic(err)
        }
    }

    // Crea una respuesta para mandarla al otro extremo
    answer, err := peerConnection.CreateAnswer(nil)
    if err != nil {
        panic(err)
    }

    // Guarda la descripción local, y empieza a escuchar las conexiones UDP
    err = peerConnection.SetLocalDescription(answer)
    if err != nil {
        panic(err)
    }

  // Bucle infinito para bloquear el hilo
  for {}