Golang中Pions客户端连接的实现与应用

以下是使用Pion WebRTC库实现两个客户端之间连接的完整示例。这个示例展示了如何创建两个对等连接(PeerConnection)，并通过信令通道交换SDP信息来建立连接。

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "time"

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

// 模拟信令通道
type signalingChannel struct {
    offerChan  chan webrtc.SessionDescription
    answerChan chan webrtc.SessionDescription
    iceChan1   chan webrtc.ICECandidateInit
    iceChan2   chan webrtc.ICECandidateInit
}

func newSignalingChannel() *signalingChannel {
    return &signalingChannel{
        offerChan:  make(chan webrtc.SessionDescription, 1),
        answerChan: make(chan webrtc.SessionDescription, 1),
        iceChan1:   make(chan webrtc.ICECandidateInit, 100),
        iceChan2:   make(chan webrtc.ICECandidateInit, 100),
    }
}

func main() {
    // 创建信令通道
    signaling := newSignalingChannel()

    // 启动客户端1（发起方）
    go client1(signaling)
    
    // 启动客户端2（接收方）
    go client2(signaling)

    // 等待连接建立
    time.Sleep(5 * time.Second)
    fmt.Println("演示完成")
}

func client1(signaling *signalingChannel) {
    // 创建PeerConnection配置
    config := webrtc.Configuration{
        ICEServers: []webrtc.ICEServer{
            {
                URLs: []string{"stun:stun.l.google.com:19302"},
            },
        },
    }

    // 创建PeerConnection
    peerConnection, err := webrtc.NewPeerConnection(config)
    if err != nil {
        log.Fatal("客户端1创建PeerConnection失败:", err)
    }
    defer peerConnection.Close()

    // 设置ICE候选处理
    peerConnection.OnICECandidate(func(candidate *webrtc.ICECandidate) {
        if candidate != nil {
            signaling.iceChan1 <- candidate.ToJSON()
        }
    })

    // 创建数据通道
    dataChannel, err := peerConnection.CreateDataChannel("chat", nil)
    if err != nil {
        log.Fatal("客户端1创建数据通道失败:", err)
    }

    // 处理数据通道打开事件
    dataChannel.OnOpen(func() {
        fmt.Println("客户端1: 数据通道已打开")
        
        // 发送测试消息
        err := dataChannel.SendText("Hello from Client 1!")
        if err != nil {
            log.Println("客户端1发送消息失败:", err)
        }
    })

    // 处理接收到的消息
    dataChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
        fmt.Printf("客户端1收到消息: %s\n", string(msg.Data))
    })

    // 创建offer
    offer, err := peerConnection.CreateOffer(nil)
    if err != nil {
        log.Fatal("客户端1创建offer失败:", err)
    }

    // 设置本地描述
    err = peerConnection.SetLocalDescription(offer)
    if err != nil {
        log.Fatal("客户端1设置本地描述失败:", err)
    }

    // 发送offer到信令通道
    signaling.offerChan <- offer

    // 等待answer
    answer := <-signaling.answerChan
    err = peerConnection.SetRemoteDescription(answer)
    if err != nil {
        log.Fatal("客户端1设置远程描述失败:", err)
    }

    // 处理从客户端2收到的ICE候选
    go func() {
        for candidate := range signaling.iceChan2 {
            err := peerConnection.AddICECandidate(candidate)
            if err != nil {
                log.Println("客户端1添加ICE候选失败:", err)
            }
        }
    }()

    // 保持连接
    select {}
}

func client2(signaling *signalingChannel) {
    // 创建PeerConnection配置
    config := webrtc.Configuration{
        ICEServers: []webrtc.ICEServer{
            {
                URLs: []string{"stun:stun.l.google.com:19302"},
            },
        },
    }

    // 创建PeerConnection
    peerConnection, err := webrtc.NewPeerConnection(config)
    if err != nil {
        log.Fatal("客户端2创建PeerConnection失败:", err)
    }
    defer peerConnection.Close()

    // 设置ICE候选处理
    peerConnection.OnICECandidate(func(candidate *webrtc.ICECandidate) {
        if candidate != nil {
            signaling.iceChan2 <- candidate.ToJSON()
        }
    })

    // 处理数据通道
    peerConnection.OnDataChannel(func(dataChannel *webrtc.DataChannel) {
        fmt.Println("客户端2: 收到数据通道")

        dataChannel.OnOpen(func() {
            fmt.Println("客户端2: 数据通道已打开")
            
            // 回复消息
            err := dataChannel.SendText("Hello from Client 2!")
            if err != nil {
                log.Println("客户端2发送消息失败:", err)
            }
        })

        dataChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
            fmt.Printf("客户端2收到消息: %s\n", string(msg.Data))
        })
    })

    // 等待offer
    offer := <-signaling.offerChan
    err = peerConnection.SetRemoteDescription(offer)
    if err != nil {
        log.Fatal("客户端2设置远程描述失败:", err)
    }

    // 创建answer
    answer, err := peerConnection.CreateAnswer(nil)
    if err != nil {
        log.Fatal("客户端2创建answer失败:", err)
    }

    // 设置本地描述
    err = peerConnection.SetLocalDescription(answer)
    if err != nil {
        log.Fatal("客户端2设置本地描述失败:", err)
    }

    // 发送answer到信令通道
    signaling.answerChan <- answer

    // 处理从客户端1收到的ICE候选
    go func() {
        for candidate := range signaling.iceChan1 {
            err := peerConnection.AddICECandidate(candidate)
            if err != nil {
                log.Println("客户端2添加ICE候选失败:", err)
            }
        }
    }()

    // 保持连接
    select {}
}

// 辅助函数：打印SDP信息（用于调试）
func printSDP(sdp webrtc.SessionDescription) {
    sdpJSON, _ := json.MarshalIndent(sdp, "", "  ")
    fmt.Printf("SDP Type: %s\n", sdp.Type)
    fmt.Printf("SDP: %s\n", string(sdpJSON))
}

这个示例展示了：

1. 两个独立的Pion客户端：client1作为发起方，client2作为接收方
2. 完整的信令流程：通过模拟的信令通道交换SDP offer/answer
3. ICE候选交换：处理网络连接所需的ICE候选信息
4. 数据通道通信：建立双向的数据通道并交换文本消息

运行此代码前，需要安装Pion WebRTC依赖：

go mod init pion-example
go get github.com/pion/webrtc/v3

在实际应用中，信令通道需要通过WebSocket、HTTP或其他网络协议实现，而不是使用内存通道。这个示例提供了Pion客户端连接的核心实现模式。