Golang WebRTC Tutorial: Build Real-Time Apps with Pion

1go mod init my-webrtc-app
2

1go get github.com/pion/webrtc/v3@v3.1.51
2

1my-webrtc-app/
2├── main.go
3├── go.mod
4└── go.sum
5

1package main
2
3import (
4    "fmt"
5    "github.com/pion/webrtc/v3"
6    "log"
7)
8
9func main() {
10    // Everything below is the Pion WebRTC API!
11    // We define the configuration for ICE
12    config := webrtc.Configuration{
13        ICEServers: []webrtc.ICEServer{
14            {URLs: []string{"stun:stun.l.google.com:19302"}},
15        },
16    }
17
18    // Create a new RTCPeerConnection
19    peerConnection, err := webrtc.NewPeerConnection(config)
20    if err != nil {
21        log.Fatal(err)
22    }
23
24    fmt.Println("Peer connection created successfully!")
25
26    // Close the peer connection when you're done with it
27    defer func() {
28        if err := peerConnection.Close(); err != nil {
29            fmt.Printf("Error closing peer connection: %s
30", err)
31        }
32    }()
33
34    // Code for handling ICE candidates and sending/receiving media streams will go here
35
36    // Wait for user input to keep the connection alive
37    fmt.Println("Press Ctrl+C to exit")
38    select {}
39}
40

1// Gather ICE candidates
2peerConnection.OnICECandidate(func(candidate *webrtc.ICECandidate) {
3    if candidate == nil {
4        return
5    }
6
7    // Send the candidate to the other peer via the signaling server
8    candidateString, err := candidate.MarshalJSON()
9    if err != nil {
10        fmt.Println(err)
11    }
12    fmt.Println("ICE Candidate: ", string(candidateString))
13    //In a real application, you would send this to the other peer using your signaling method
14})
15

1// Create a new track
2track, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{
3    MimeType: webrtc.MimeTypeVP8,
4}, "video", "pion")
5if err != nil {
6    panic(err)
7}
8
9rtpSender, err := peerConnection.AddTrack(track)
10if err != nil {
11    panic(err)
12}
13
14// Read incoming RTCP packets
15// Before these packets are returned they are processed by the interceptors.
16go func() {
17    rtcpBuf := make([]byte, 1500)
18    for {
19        i, _, rtcpErr := rtpSender.Read(rtcpBuf)
20        if rtcpErr != nil {
21            return
22        }
23
24        fmt.Println("RTCP packet received!")
25        _ = i
26    }
27}()
28
29// Handle incoming media streams
30peerConnection.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
31    // Print incoming stream's info
32    fmt.Printf("Got track: %+v
33", track)
34
35    // Read incoming packets
36    b := make([]byte, 1500)
37    for {
38        i, _, err := track.Read(b)
39        if err != nil {
40            panic(err)
41        }
42
43        fmt.Printf("Got packet with length: %d
44", i)
45        // Process the packet here
46    }
47})
48

1// Server-side (simplified)
2package main
3
4import (
5    "fmt"
6    "log"
7    "net/http"
8
9    "github.com/gorilla/websocket"
10)
11
12var upgrader = websocket.Upgrader{
13    CheckOrigin: func(r *http.Request) bool {
14        return true // Allow all origins for testing
15    },
16}
17
18func handleConnections(w http.ResponseWriter, r *http.Request) {
19    ws, err := upgrader.Upgrade(w, r, nil)
20    if err != nil {
21        log.Fatal(err)
22    }
23    // We read every message in a new go routine
24    go func() {
25        for {
26            messageType, p, err := ws.ReadMessage()
27            if err != nil {
28                log.Println(err)
29                return
30            }
31            fmt.Println(string(p))
32
33            if err := ws.WriteMessage(messageType, p); err != nil {
34                log.Println(err)
35                return
36            }
37        }
38    }()
39}
40
41func main() {
42    http.HandleFunc("/ws", handleConnections)
43
44    fmt.Println("http server started on :8000")
45    err := http.ListenAndServe(":8000", nil)
46    if err != nil {
47        log.Fatal("ListenAndServe: ", err)
48    }
49}
50

1// Create a data channel
2dataChannel, err := peerConnection.CreateDataChannel("my-data-channel", nil)
3if err != nil {
4    panic(err)
5}
6
7// Register channel opening handling
8dataChannel.OnOpen(func() {
9    fmt.Println("Data channel opened!")
10
11    // Send a message to the other peer
12    err := dataChannel.SendText("Hello, world!")
13    if err != nil {
14        panic(err)
15    }
16})
17
18// Register text message handling
19dataChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
20    fmt.Printf("Got message: %s
21", string(msg.Data))
22})
23