1559 lines
42 KiB
Go
1559 lines
42 KiB
Go
// Package teamspeak 提供 gomobile 友好的 TeamSpeak 客户端 API。
|
||
//
|
||
// gomobile 限制：
|
||
// - 不支持 []string、[]*T 等复杂切片类型导出
|
||
// - 不支持 Go 的 error 类型，改用 string 返回错误
|
||
// - 回调必须通过 interface 定义
|
||
// - 复杂数据通过 JSON 字符串传递
|
||
package teamspeak
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"sync"
|
||
"time"
|
||
|
||
ts "github.com/honeybbq/teamspeak-go"
|
||
"github.com/honeybbq/teamspeak-go/crypto"
|
||
)
|
||
|
||
// queuedEvent 封装待处理的事件，用于 JNI 回调串行化
|
||
type queuedEvent struct {
|
||
evtType string
|
||
data any
|
||
}
|
||
|
||
// eventQueue owns one callback consumer. A new connection receives a fresh
|
||
// instance so a stopped consumer can never resume against a later session.
|
||
const maxQueuedPCMEvents = 12
|
||
|
||
type eventQueue struct {
|
||
mu sync.Mutex
|
||
cond *sync.Cond
|
||
events []queuedEvent
|
||
callback EventCallback
|
||
stopped bool
|
||
pcmCount int
|
||
stopOnce sync.Once
|
||
}
|
||
|
||
func newEventQueue(callback EventCallback) *eventQueue {
|
||
q := &eventQueue{callback: callback}
|
||
q.cond = sync.NewCond(&q.mu)
|
||
return q
|
||
}
|
||
|
||
// ─── 内部数据类型（不导出给 gomobile） ─────────────────────
|
||
|
||
// serverInfoJSON 用于 JSON 序列化的服务器信息
|
||
type serverInfoJSON struct {
|
||
Name string `json:"name"`
|
||
WelcomeMessage string `json:"welcomeMessage"`
|
||
MaxClients int `json:"maxClients"`
|
||
ClientsOnline int `json:"clientsOnline"`
|
||
ChannelsOnline int `json:"channelsOnline"`
|
||
Uptime string `json:"uptime"`
|
||
Version string `json:"version"`
|
||
Platform string `json:"platform"`
|
||
Created string `json:"created"`
|
||
IconID string `json:"iconId"`
|
||
DefaultServerGroup int `json:"defaultServerGroup"`
|
||
DefaultChannelGroup int `json:"defaultChannelGroup"`
|
||
}
|
||
|
||
// channelDetailedInfoJSON 用于 JSON 序列化的单频道详情（来自 channelinfo cid=X）
|
||
type channelDetailedInfoJSON struct {
|
||
ID string `json:"id"`
|
||
ParentID string `json:"parentId"`
|
||
Name string `json:"name"`
|
||
Topic string `json:"topic"`
|
||
Description string `json:"description"`
|
||
Codec int `json:"codec"`
|
||
CodecQuality int `json:"codecQuality"`
|
||
MaxClients int `json:"maxClients"`
|
||
MaxFamilyClients int `json:"maxFamilyClients"`
|
||
NeededTalkPower int `json:"neededTalkPower"`
|
||
IconID string `json:"iconId"`
|
||
IsPermanent bool `json:"isPermanent"`
|
||
IsSemiPermanent bool `json:"isSemiPermanent"`
|
||
IsDefault bool `json:"isDefault"`
|
||
IsPassword bool `json:"isPassword"`
|
||
Order string `json:"order"`
|
||
BannerGfxURL string `json:"bannerGfxUrl"`
|
||
}
|
||
|
||
// clientDetailedInfoJSON 用于 JSON 序列化的单客户端详情（来自 clientinfo clid=X）
|
||
type clientDetailedInfoJSON struct {
|
||
ID string `json:"id"`
|
||
Nickname string `json:"nickname"`
|
||
UID string `json:"uid"`
|
||
ChannelID string `json:"channelId"`
|
||
Type int `json:"type"`
|
||
ServerGroups []string `json:"serverGroups"`
|
||
Away bool `json:"away"`
|
||
AwayMessage string `json:"awayMessage"`
|
||
InputMuted bool `json:"inputMuted"`
|
||
OutputMuted bool `json:"outputMuted"`
|
||
Platform string `json:"platform"`
|
||
Version string `json:"version"`
|
||
IP string `json:"ip"`
|
||
Created string `json:"created"`
|
||
LastConnected string `json:"lastConnected"`
|
||
TotalConnections int `json:"totalConnections"`
|
||
Description string `json:"description"`
|
||
IconID string `json:"iconId"`
|
||
}
|
||
|
||
// dbClientJSON 用于 JSON 序列化的数据库客户端
|
||
type dbClientJSON struct {
|
||
DBID string `json:"dbid"`
|
||
UID string `json:"uid"`
|
||
Nickname string `json:"nickname"`
|
||
Created string `json:"created"`
|
||
LastConnected string `json:"lastConnected"`
|
||
TotalConnections int `json:"totalConnections"`
|
||
Description string `json:"description"`
|
||
}
|
||
|
||
// banEntryJSON 用于 JSON 序列化的 ban 条目
|
||
type banEntryJSON struct {
|
||
BanID string `json:"banId"`
|
||
IP string `json:"ip"`
|
||
Name string `json:"name"`
|
||
UID string `json:"uid"`
|
||
Created string `json:"created"`
|
||
InvokerName string `json:"invokerName"`
|
||
InvokerUID string `json:"invokerUid"`
|
||
Reason string `json:"reason"`
|
||
Enforcement bool `json:"enforcement"`
|
||
}
|
||
|
||
// fileEntryJSON 用于 JSON 序列化的文件条目
|
||
type fileEntryJSON struct {
|
||
Name string `json:"name"`
|
||
Size string `json:"size"`
|
||
DateTime string `json:"dateTime"`
|
||
IsFile bool `json:"isFile"`
|
||
}
|
||
|
||
// tokenEntryJSON 用于 JSON 序列化的 token 条目
|
||
type tokenEntryJSON struct {
|
||
Token string `json:"token"`
|
||
TokenType int `json:"tokenType"`
|
||
TokenID1 string `json:"tokenId1"`
|
||
TokenID2 string `json:"tokenId2"`
|
||
Created string `json:"created"`
|
||
Description string `json:"description"`
|
||
}
|
||
|
||
// complaintEntryJSON 用于 JSON 序列化的投诉条目
|
||
type complaintEntryJSON struct {
|
||
FromDBID string `json:"fromDbid"`
|
||
ToDBID string `json:"toDbid"`
|
||
Message string `json:"message"`
|
||
Timestamp string `json:"timestamp"`
|
||
}
|
||
|
||
// channelJSON 用于 JSON 序列化的频道信息
|
||
type channelJSON struct {
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
ParentID string `json:"parentId"`
|
||
Description string `json:"description"`
|
||
IsPassword bool `json:"isPassword"`
|
||
}
|
||
|
||
// channelDetailedJSON 用于 JSON 序列化的详细频道信息（含 flags、voice、limits、icon）
|
||
type channelDetailedJSON struct {
|
||
ID string `json:"id"`
|
||
Name string `json:"name"`
|
||
ParentID string `json:"parentId"`
|
||
Topic string `json:"topic"`
|
||
Order string `json:"order"`
|
||
Codec int `json:"codec"`
|
||
CodecQuality int `json:"codecQuality"`
|
||
NeededTalkPower int `json:"neededTalkPower"`
|
||
MaxClients int `json:"maxClients"`
|
||
MaxFamilyClients int `json:"maxFamilyClients"`
|
||
IsMaxClientsUnlimited bool `json:"isMaxClientsUnlimited"`
|
||
IsMaxFamilyClientsUnlimited bool `json:"isMaxFamilyClientsUnlimited"`
|
||
IsPermanent bool `json:"isPermanent"`
|
||
IsSemiPermanent bool `json:"isSemiPermanent"`
|
||
IsDefault bool `json:"isDefault"`
|
||
IsPassword bool `json:"isPassword"`
|
||
IsOrdered bool `json:"isOrdered"`
|
||
IconID string `json:"iconId"`
|
||
NeededModifyPower int `json:"neededModifyPower"`
|
||
}
|
||
|
||
// clientJSON 用于 JSON 序列化的客户端信息
|
||
type clientJSON struct {
|
||
ID int `json:"id"`
|
||
Nickname string `json:"nickname"`
|
||
UID string `json:"uid"`
|
||
ChannelID string `json:"channelId"`
|
||
ServerGroups []string `json:"serverGroups"`
|
||
IsSelf bool `json:"isSelf"`
|
||
}
|
||
|
||
// ─── 数据类型（gomobile 可导出） ────────────────────────────
|
||
|
||
// Channel 频道信息（gomobile 导出）
|
||
type Channel struct {
|
||
ID string
|
||
Name string
|
||
ParentID string
|
||
Description string
|
||
}
|
||
|
||
// Client 客户端信息（gomobile 导出）
|
||
type Client struct {
|
||
ID int
|
||
Nickname string
|
||
UID string
|
||
ChannelID string
|
||
IsSelf bool
|
||
}
|
||
|
||
// TextMsg 文字消息（gomobile 导出）
|
||
type TextMsg struct {
|
||
InvokerName string
|
||
InvokerUID string
|
||
Message string
|
||
TargetMode int
|
||
TargetID string
|
||
}
|
||
|
||
// PokeEvent Poke 事件（gomobile 导出）
|
||
type PokeEvent struct {
|
||
InvokerID int
|
||
InvokerName string
|
||
InvokerUID string
|
||
Message string
|
||
}
|
||
|
||
// ─── 事件回调接口 ─────────────────────────────────────────
|
||
|
||
// EventCallback 事件回调接口，Android 端实现此接口接收事件
|
||
type EventCallback interface {
|
||
OnConnected()
|
||
OnDisconnected(message string)
|
||
OnTextMessage(msg *TextMsg)
|
||
OnClientEnter(client *Client)
|
||
OnClientLeave(id int, reasonMsg string)
|
||
OnClientMoved(id int, targetChannelID string)
|
||
OnKicked(reason string)
|
||
OnVoiceData(clientID int, data []byte, codec int, sequence int, isWhisper bool)
|
||
// OnMixedVoicePCM receives a 20 ms, 48 kHz interleaved stereo PCM16 little-endian frame.
|
||
OnMixedVoicePCM(pcm []byte)
|
||
OnClientSpeaking(clientID int, speaking bool)
|
||
OnPoked(event *PokeEvent)
|
||
}
|
||
|
||
// ─── TSClient 主类 ────────────────────────────────────────
|
||
|
||
// TSClient TeamSpeak 客户端封装
|
||
type TSClient struct {
|
||
mu sync.Mutex
|
||
client *ts.Client
|
||
callback EventCallback
|
||
connected bool
|
||
host string // 服务器地址（用于文件传输 TCP 连接）
|
||
|
||
// 事件队列：保证所有 JNI 回调在同一个协程中顺序执行
|
||
evtQueueMu sync.Mutex // protects eventQueue replacement
|
||
evtQueue *eventQueue
|
||
|
||
// receiveFactory is platform-owned and intentionally private so gomobile
|
||
// never exposes the native decoder implementation. Android supplies a
|
||
// libopus-backed factory; unsupported host builds leave it nil.
|
||
receiveFactory voiceDecoderFactory
|
||
receive *receiveAudio
|
||
}
|
||
|
||
// NewClient 创建新的 TeamSpeak 客户端
|
||
func NewClient() *TSClient {
|
||
factory := newPlatformVoiceDecoderFactory()
|
||
log.Printf("[TSVoice] platform decoder factory=%T available=%t", factory, factory != nil)
|
||
return &TSClient{receiveFactory: factory}
|
||
}
|
||
|
||
// Connect 连接到 TeamSpeak 服务器
|
||
// 返回空字符串表示成功，非空为错误信息
|
||
func (c *TSClient) Connect(host, nickname, password, defaultChannel, defaultChannelPassword string, cb EventCallback) string {
|
||
// Ensure repeated attempts on this wrapper cannot leave a prior transport alive.
|
||
c.Disconnect()
|
||
// A prior failed or disconnected session may have left its consumer waiting.
|
||
// Stop it before replacing the callback and starting this session's queue.
|
||
c.stopEventQueue()
|
||
|
||
c.mu.Lock()
|
||
c.callback = cb
|
||
c.connected = false
|
||
c.host = host
|
||
c.mu.Unlock()
|
||
c.initEventQueue()
|
||
c.ensureReceiveFactory()
|
||
c.StartReceiveAudio()
|
||
|
||
identity, err := crypto.GenerateIdentity(8)
|
||
if err != nil {
|
||
return fmt.Sprintf("生成身份失败: %v", err)
|
||
}
|
||
|
||
opts := []ts.ClientOption{}
|
||
if password != "" {
|
||
opts = append(opts, ts.WithServerPassword(password))
|
||
}
|
||
if defaultChannel != "" {
|
||
opts = append(opts, ts.WithDefaultChannel(defaultChannel))
|
||
}
|
||
if defaultChannelPassword != "" {
|
||
opts = append(opts, ts.WithDefaultChannelPassword(defaultChannelPassword))
|
||
}
|
||
|
||
client := ts.NewClient(identity, host, nickname, opts...)
|
||
|
||
c.mu.Lock()
|
||
c.client = client
|
||
c.mu.Unlock()
|
||
|
||
// 注册事件
|
||
c.registerEvents(client)
|
||
|
||
if err := client.Connect(); err != nil {
|
||
c.Disconnect()
|
||
return fmt.Sprintf("连接失败: %v", err)
|
||
}
|
||
|
||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||
defer cancel()
|
||
if err := client.WaitConnected(ctx); err != nil {
|
||
c.Disconnect()
|
||
return fmt.Sprintf("连接失败: %v", err)
|
||
}
|
||
|
||
return ""
|
||
}
|
||
|
||
// Disconnect 断开连接
|
||
func (c *TSClient) Disconnect() {
|
||
c.StopReceiveAudio()
|
||
// 停止事件消费协程
|
||
c.stopEventQueue()
|
||
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.client = nil
|
||
c.connected = false
|
||
c.mu.Unlock()
|
||
|
||
if client != nil {
|
||
if err := client.Disconnect(); err != nil {
|
||
log.Printf("[TSBridge] disconnect error: %v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// IsConnected 是否已连接
|
||
func (c *TSClient) IsConnected() bool {
|
||
c.mu.Lock()
|
||
defer c.mu.Unlock()
|
||
return c.connected && c.client != nil
|
||
}
|
||
|
||
// GetChannelsJSON 获取频道列表（JSON 格式）
|
||
// gomobile 不支持返回 []*Channel，所以用 JSON 字符串传递
|
||
func (c *TSClient) GetChannelsJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
log.Printf("[TSBridge] GetChannelsJSON: client is nil")
|
||
return "[]"
|
||
}
|
||
|
||
log.Printf("[TSBridge] GetChannelsJSON: calling ListChannelsDetailed...")
|
||
channels, err := client.ListChannelsDetailed()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListChannelsDetailed error: %v", err)
|
||
return "[]"
|
||
}
|
||
log.Printf("[TSBridge] ListChannelsDetailed returned %d channels", len(channels))
|
||
|
||
result := make([]channelJSON, len(channels))
|
||
for i, ch := range channels {
|
||
parentID := "0"
|
||
if ch.ParentID != 0 {
|
||
parentID = fmt.Sprintf("%d", ch.ParentID)
|
||
}
|
||
result[i] = channelJSON{
|
||
ID: fmt.Sprintf("%d", ch.ID),
|
||
Name: ch.Name,
|
||
ParentID: parentID,
|
||
IsPassword: ch.IsPassword,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// GetChannelsDetailedJSON 获取详细频道列表（JSON 格式）
|
||
// 通过 channellist -topic -flags -voice -limits -icon 获取更丰富的频道属性，
|
||
// 包括：密码标志、编解码器、人数限制、永久/半永久标志、图标 ID 等。
|
||
// gomobile 不支持返回 []*ChannelInfoDetailed，所以用 JSON 字符串传递。
|
||
func (c *TSClient) GetChannelsDetailedJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
channels, err := client.ListChannelsDetailed()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListChannelsDetailed error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]channelDetailedJSON, len(channels))
|
||
for i, ch := range channels {
|
||
parentID := "0"
|
||
if ch.ParentID != 0 {
|
||
parentID = fmt.Sprintf("%d", ch.ParentID)
|
||
}
|
||
result[i] = channelDetailedJSON{
|
||
ID: fmt.Sprintf("%d", ch.ID),
|
||
Name: ch.Name,
|
||
ParentID: parentID,
|
||
Topic: ch.Topic,
|
||
Order: fmt.Sprintf("%d", ch.Order),
|
||
Codec: ch.Codec,
|
||
CodecQuality: ch.CodecQuality,
|
||
NeededTalkPower: ch.NeededTalkPower,
|
||
MaxClients: ch.MaxClients,
|
||
MaxFamilyClients: ch.MaxFamilyClients,
|
||
IsMaxClientsUnlimited: ch.IsMaxClientsUnlimited,
|
||
IsMaxFamilyClientsUnlimited: ch.IsMaxFamilyClientsUnlimited,
|
||
IsPermanent: ch.IsPermanent,
|
||
IsSemiPermanent: ch.IsSemiPermanent,
|
||
IsDefault: ch.IsDefault,
|
||
IsPassword: ch.IsPassword,
|
||
IsOrdered: ch.Order > 0,
|
||
IconID: fmt.Sprintf("%d", ch.IconID),
|
||
NeededModifyPower: ch.NeededModifyPower,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// GetClientsJSON 获取在线客户端列表（JSON 格式）
|
||
// gomobile 不支持返回 []*Client，所以用 JSON 字符串传递
|
||
func (c *TSClient) GetClientsJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
clients, err := client.ListClients()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListClients error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
myID := client.ClientID()
|
||
result := make([]clientJSON, len(clients))
|
||
for i, cl := range clients {
|
||
result[i] = clientJSON{
|
||
ID: int(cl.ID),
|
||
Nickname: cl.Nickname,
|
||
UID: cl.UID,
|
||
ChannelID: fmt.Sprintf("%d", cl.ChannelID),
|
||
ServerGroups: cl.ServerGroups,
|
||
IsSelf: cl.ID == myID,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ─── 服务器信息 ────────────────────────────────────────────
|
||
|
||
// GetServerInfoJSON 获取服务器信息（JSON 格式）
|
||
// gomobile 不支持返回 *ServerInfo，所以用 JSON 字符串传递
|
||
func (c *TSClient) GetServerInfoJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "{}"
|
||
}
|
||
|
||
info, err := client.GetServerInfo()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] GetServerInfo error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := serverInfoJSON{
|
||
Name: info.Name,
|
||
WelcomeMessage: info.WelcomeMessage,
|
||
MaxClients: info.MaxClients,
|
||
ClientsOnline: info.ClientsOnline,
|
||
ChannelsOnline: info.ChannelsOnline,
|
||
Uptime: fmt.Sprintf("%d", info.Uptime),
|
||
Version: info.Version,
|
||
Platform: info.Platform,
|
||
Created: fmt.Sprintf("%d", info.Created),
|
||
IconID: fmt.Sprintf("%d", info.IconID),
|
||
DefaultServerGroup: info.DefaultServerGroup,
|
||
DefaultChannelGroup: info.DefaultChannelGroup,
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ─── 频道详情 ──────────────────────────────────────────────
|
||
|
||
// GetChannelDetailInfoJSON 获取单个频道的详细信息（JSON 格式）
|
||
// 通过 channelinfo cid=X 获取完整的频道属性（含 description）。
|
||
// 返回空字符串表示错误。
|
||
func (c *TSClient) GetChannelDetailInfoJSON(channelIDStr string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "{}"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return "{}"
|
||
}
|
||
|
||
info, err := client.GetChannelInfo(channelID)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] GetChannelInfo error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := channelDetailedInfoJSON{
|
||
ID: fmt.Sprintf("%d", info.ID),
|
||
ParentID: fmt.Sprintf("%d", info.ParentID),
|
||
Name: info.Name,
|
||
Topic: info.Topic,
|
||
Description: info.Description,
|
||
Codec: info.Codec,
|
||
CodecQuality: info.CodecQuality,
|
||
MaxClients: info.MaxClients,
|
||
MaxFamilyClients: info.MaxFamilyClients,
|
||
NeededTalkPower: info.NeededTalkPower,
|
||
IconID: fmt.Sprintf("%d", info.IconID),
|
||
IsPermanent: info.IsPermanent,
|
||
IsSemiPermanent: info.IsSemiPermanent,
|
||
IsDefault: info.IsDefault,
|
||
IsPassword: info.IsPassword,
|
||
Order: fmt.Sprintf("%d", info.Order),
|
||
BannerGfxURL: info.BannerGfxURL,
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ─── 客户端详情 ────────────────────────────────────────────
|
||
|
||
// GetClientDetailInfoJSON 获取单个客户端的详细信息（JSON 格式）
|
||
// 通过 clientinfo clid=X 获取完整的客户端属性。
|
||
func (c *TSClient) GetClientDetailInfoJSON(clid int) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "{}"
|
||
}
|
||
|
||
info, err := client.GetClientDetailInfo(uint16(clid))
|
||
if err != nil {
|
||
log.Printf("[TSBridge] GetClientDetailInfo error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := clientDetailedInfoJSON{
|
||
ID: fmt.Sprintf("%d", info.ID),
|
||
Nickname: info.Nickname,
|
||
UID: info.UID,
|
||
ChannelID: fmt.Sprintf("%d", info.ChannelID),
|
||
Type: info.Type,
|
||
ServerGroups: info.ServerGroups,
|
||
Away: info.Away,
|
||
AwayMessage: info.AwayMessage,
|
||
InputMuted: info.InputMuted,
|
||
OutputMuted: info.OutputMuted,
|
||
Platform: info.Platform,
|
||
Version: info.Version,
|
||
IP: info.IP,
|
||
Created: fmt.Sprintf("%d", info.Created),
|
||
LastConnected: fmt.Sprintf("%d", info.LastConnected),
|
||
TotalConnections: info.TotalConnections,
|
||
Description: info.Description,
|
||
IconID: fmt.Sprintf("%d", info.IconID),
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ─── 数据库客户端列表 ──────────────────────────────────────
|
||
|
||
// ListDBClientsJSON 获取服务器数据库中的客户端列表（JSON 格式）
|
||
// start: 起始位置, duration: 返回数量（0=全部）
|
||
func (c *TSClient) ListDBClientsJSON(start, duration int) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
clients, err := client.ListDBClients(start, duration)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListDBClients error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]dbClientJSON, len(clients))
|
||
for i, cl := range clients {
|
||
result[i] = dbClientJSON{
|
||
DBID: fmt.Sprintf("%d", cl.DBID),
|
||
UID: cl.UID,
|
||
Nickname: cl.Nickname,
|
||
Created: fmt.Sprintf("%d", cl.Created),
|
||
LastConnected: fmt.Sprintf("%d", cl.LastConnected),
|
||
TotalConnections: cl.TotalConnections,
|
||
Description: cl.Description,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ─── Ban 管理 ─────────────────────────────────────────────
|
||
|
||
// ListBansJSON 获取 ban 列表（JSON 格式）
|
||
func (c *TSClient) ListBansJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
bans, err := client.ListBans()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListBans error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]banEntryJSON, len(bans))
|
||
for i, b := range bans {
|
||
result[i] = banEntryJSON{
|
||
BanID: fmt.Sprintf("%d", b.BanID),
|
||
IP: b.IP,
|
||
Name: b.Name,
|
||
UID: b.UID,
|
||
Created: fmt.Sprintf("%d", b.Created),
|
||
InvokerName: b.InvokerName,
|
||
InvokerUID: b.InvokerUID,
|
||
Reason: b.Reason,
|
||
Enforcement: b.Enforcement,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// AddBan 添加 ban 条目。ip/name/uid 至少指定一个。timeSeconds=0 为永久。
|
||
// 返回空字符串表示成功。
|
||
func (c *TSClient) AddBan(ip, name, uid string, timeSeconds int, reason string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
if err := client.AddBan(ip, name, uid, timeSeconds, reason); err != nil {
|
||
return fmt.Sprintf("添加失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// DeleteBan 删除 ban 条目。返回空字符串表示成功。
|
||
func (c *TSClient) DeleteBan(banIDStr string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var banID int64
|
||
if _, err := fmt.Sscanf(banIDStr, "%d", &banID); err != nil {
|
||
return fmt.Sprintf("无效的 ban ID: %v", err)
|
||
}
|
||
|
||
if err := client.DeleteBan(banID); err != nil {
|
||
return fmt.Sprintf("删除失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// ─── Token 管理 ───────────────────────────────────────────
|
||
|
||
// ListTokensJSON 获取 token 列表（JSON 格式）
|
||
func (c *TSClient) ListTokensJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
tokens, err := client.ListTokens()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListTokens error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]tokenEntryJSON, len(tokens))
|
||
for i, t := range tokens {
|
||
result[i] = tokenEntryJSON{
|
||
Token: t.Token,
|
||
TokenType: t.TokenType,
|
||
TokenID1: fmt.Sprintf("%d", t.TokenID1),
|
||
TokenID2: fmt.Sprintf("%d", t.TokenID2),
|
||
Created: fmt.Sprintf("%d", t.Created),
|
||
Description: t.Description,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// UseToken 使用一个 privilege key。返回空字符串表示成功。
|
||
func (c *TSClient) UseToken(token string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
if err := client.UseToken(token); err != nil {
|
||
return fmt.Sprintf("使用失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// ─── 文件列表 ─────────────────────────────────────────────
|
||
|
||
// ListFilesJSON 获取频道目录下的文件列表（JSON 格式）
|
||
// path: 虚拟路径，根目录为 "/"
|
||
func (c *TSClient) ListFilesJSON(channelIDStr, path string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return "[]"
|
||
}
|
||
|
||
files, err := client.ListFiles(channelID, path)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListFiles error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]fileEntryJSON, len(files))
|
||
for i, f := range files {
|
||
result[i] = fileEntryJSON{
|
||
Name: f.Name,
|
||
Size: fmt.Sprintf("%d", f.Size),
|
||
DateTime: fmt.Sprintf("%d", f.DateTime),
|
||
IsFile: f.IsFile,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ─── 投诉管理 ─────────────────────────────────────────────
|
||
|
||
// ListComplaintsJSON 获取投诉列表（JSON 格式）
|
||
// targetDBIDStr: 目标客户端 DBID，"0" 表示返回全部投诉
|
||
func (c *TSClient) ListComplaintsJSON(targetDBIDStr string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
var targetDBID uint64
|
||
if targetDBIDStr != "" && targetDBIDStr != "0" {
|
||
if _, err := fmt.Sscanf(targetDBIDStr, "%d", &targetDBID); err != nil {
|
||
return "[]"
|
||
}
|
||
}
|
||
|
||
complaints, err := client.ListComplaints(targetDBID)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] ListComplaints error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]complaintEntryJSON, len(complaints))
|
||
for i, c := range complaints {
|
||
result[i] = complaintEntryJSON{
|
||
FromDBID: fmt.Sprintf("%d", c.FromDBID),
|
||
ToDBID: fmt.Sprintf("%d", c.ToDBID),
|
||
Message: c.Message,
|
||
Timestamp: fmt.Sprintf("%d", c.Timestamp),
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// AddComplaint 提交投诉。返回空字符串表示成功。
|
||
func (c *TSClient) AddComplaint(targetDBIDStr, message string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var targetDBID uint64
|
||
if _, err := fmt.Sscanf(targetDBIDStr, "%d", &targetDBID); err != nil {
|
||
return fmt.Sprintf("无效的 DBID: %v", err)
|
||
}
|
||
|
||
if err := client.AddComplaint(targetDBID, message); err != nil {
|
||
return fmt.Sprintf("提交失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// ─── 频道管理（创建/编辑/删除） ───────────────────────────
|
||
|
||
// CreateChannelJSON 创建新频道。propertiesJSON 为 JSON 对象，
|
||
// 包含可选的频道属性，如 channel_topic、channel_flag_permanent 等。
|
||
// 返回新频道的 ID 字符串，空字符串表示失败。
|
||
func (c *TSClient) CreateChannelJSON(name, propertiesJSON string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return ""
|
||
}
|
||
|
||
var props map[string]string
|
||
if propertiesJSON != "" && propertiesJSON != "{}" {
|
||
if err := json.Unmarshal([]byte(propertiesJSON), &props); err != nil {
|
||
log.Printf("[TSBridge] CreateChannel properties parse error: %v", err)
|
||
return ""
|
||
}
|
||
}
|
||
|
||
cid, err := client.CreateChannel(name, props)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] CreateChannel error: %v", err)
|
||
return ""
|
||
}
|
||
return fmt.Sprintf("%d", cid)
|
||
}
|
||
|
||
// EditChannelJSON 编辑频道属性。propertiesJSON 为 JSON 对象。
|
||
// 返回空字符串表示成功，非空为错误。
|
||
func (c *TSClient) EditChannelJSON(channelIDStr, propertiesJSON string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return fmt.Sprintf("无效的频道 ID: %v", err)
|
||
}
|
||
|
||
var props map[string]string
|
||
if err := json.Unmarshal([]byte(propertiesJSON), &props); err != nil {
|
||
return fmt.Sprintf("属性解析失败: %v", err)
|
||
}
|
||
|
||
if err := client.EditChannel(channelID, props); err != nil {
|
||
return fmt.Sprintf("编辑失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// DeleteChannel 删除频道。force=true 强制删除（含子频道）。
|
||
// 返回空字符串表示成功。
|
||
func (c *TSClient) DeleteChannel(channelIDStr string, force bool) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return fmt.Sprintf("无效的频道 ID: %v", err)
|
||
}
|
||
|
||
if err := client.DeleteChannel(channelID, force); err != nil {
|
||
return fmt.Sprintf("删除失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// UpdateSelfJSON 更新当前客户端属性。propertiesJSON 为 JSON 对象，
|
||
// 如 {"client_away": "1", "client_away_message": "AFK"}。
|
||
// 返回空字符串表示成功。
|
||
func (c *TSClient) UpdateSelfJSON(propertiesJSON string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var props map[string]string
|
||
if err := json.Unmarshal([]byte(propertiesJSON), &props); err != nil {
|
||
return fmt.Sprintf("属性解析失败: %v", err)
|
||
}
|
||
|
||
if err := client.UpdateSelf(props); err != nil {
|
||
return fmt.Sprintf("更新失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// KickClient 踢出客户端。reasonID: 4=频道踢出, 5=服务器踢出。
|
||
// 返回空字符串表示成功。
|
||
func (c *TSClient) KickClient(clid int, reasonID int, reasonMsg string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
if err := client.KickClient(uint16(clid), reasonID, reasonMsg); err != nil {
|
||
return fmt.Sprintf("踢出失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// GetClientID 获取当前客户端 ID
|
||
func (c *TSClient) GetClientID() int {
|
||
c.mu.Lock()
|
||
defer c.mu.Unlock()
|
||
if c.client == nil {
|
||
return 0
|
||
}
|
||
return int(c.client.ClientID())
|
||
}
|
||
|
||
// GetChannelID 获取当前频道 ID
|
||
func (c *TSClient) GetChannelID() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "0"
|
||
}
|
||
|
||
// 通过 GetClientInfo 获取当前频道 ID
|
||
info, err := client.GetClientInfo(client.ClientID())
|
||
if err != nil {
|
||
return "0"
|
||
}
|
||
if cid, ok := info["cid"]; ok {
|
||
return cid
|
||
}
|
||
return "0"
|
||
}
|
||
|
||
// SendChannelMessage 发送频道文字消息
|
||
// 返回空字符串表示成功
|
||
func (c *TSClient) SendChannelMessage(channelIDStr, message string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return fmt.Sprintf("无效的频道 ID: %v", err)
|
||
}
|
||
|
||
if err := client.SendTextMessage(2, channelID, message); err != nil {
|
||
return fmt.Sprintf("发送失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// MoveToChannel 移动到指定频道
|
||
// 返回空字符串表示成功
|
||
func (c *TSClient) MoveToChannel(channelIDStr, password string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return fmt.Sprintf("无效的频道 ID: %v", err)
|
||
}
|
||
|
||
if err := client.ClientMove(client.ClientID(), channelID, password); err != nil {
|
||
return fmt.Sprintf("移动失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// SendTextMessage 发送文字消息
|
||
// targetMode: 1=私聊, 2=频道, 3=服务器
|
||
// 返回空字符串表示成功
|
||
func (c *TSClient) SendTextMessage(targetMode int, targetIDStr string, message string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var targetID uint64
|
||
if _, err := fmt.Sscanf(targetIDStr, "%d", &targetID); err != nil {
|
||
return fmt.Sprintf("无效的目标 ID: %v", err)
|
||
}
|
||
|
||
if err := client.SendTextMessage(targetMode, targetID, message); err != nil {
|
||
return fmt.Sprintf("发送失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// Poke 向指定客户端发送 Poke 消息
|
||
// 返回空字符串表示成功
|
||
func (c *TSClient) Poke(clidStr string, message string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var clid uint64
|
||
if _, err := fmt.Sscanf(clidStr, "%d", &clid); err != nil {
|
||
return fmt.Sprintf("无效的客户端 ID: %v", err)
|
||
}
|
||
|
||
if err := client.Poke(uint16(clid), message); err != nil {
|
||
return fmt.Sprintf("Poke 失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// setReceiveDecoderFactory installs the decoder provider used by
|
||
// StartReceiveAudio. It remains internal because VoiceDecoderFactory is a Go
|
||
// implementation detail and must not be exported through gomobile.
|
||
func (c *TSClient) ensureReceiveFactory() {
|
||
c.mu.Lock()
|
||
if c.receiveFactory == nil {
|
||
c.receiveFactory = newPlatformVoiceDecoderFactory()
|
||
log.Printf("[TSVoice] receive factory initialized lazily type=%T available=%t", c.receiveFactory, c.receiveFactory != nil)
|
||
}
|
||
c.mu.Unlock()
|
||
}
|
||
|
||
func (c *TSClient) setReceiveDecoderFactory(factory voiceDecoderFactory) {
|
||
c.mu.Lock()
|
||
c.receiveFactory = factory
|
||
if c.receive == nil && factory != nil {
|
||
c.receive = newReceiveAudio(factory, c.queueMixedPCM, c.queueSpeaking)
|
||
}
|
||
c.mu.Unlock()
|
||
}
|
||
|
||
// StartReceiveAudio starts the Go-owned receive pipeline when this platform
|
||
// provides a decoder factory. A fresh worker is created after a prior stop, so
|
||
// speaker toggles and reconnects can safely restart receiving.
|
||
func (c *TSClient) StartReceiveAudio() {
|
||
c.ensureReceiveFactory()
|
||
c.mu.Lock()
|
||
if c.receive == nil && c.receiveFactory != nil {
|
||
c.receive = newReceiveAudio(c.receiveFactory, c.queueMixedPCM, c.queueSpeaking)
|
||
}
|
||
r := c.receive
|
||
factoryAvailable := c.receiveFactory != nil
|
||
c.mu.Unlock()
|
||
log.Printf("[TSVoice] StartReceiveAudio worker=%t factory=%t", r != nil, factoryAvailable)
|
||
if r != nil {
|
||
r.start()
|
||
}
|
||
}
|
||
|
||
// StopReceiveAudio stops the receive worker and waits for it to release all
|
||
// decoders. Repeated calls are harmless.
|
||
func (c *TSClient) StopReceiveAudio() {
|
||
c.mu.Lock()
|
||
r := c.receive
|
||
c.receive = nil
|
||
c.mu.Unlock()
|
||
if r != nil {
|
||
r.stopAndWait()
|
||
}
|
||
}
|
||
|
||
// SetRemoteClientMuted excludes a remote client from the final mix while it
|
||
// continues receiving, decoding, and reporting speaking state.
|
||
func (c *TSClient) SetRemoteClientMuted(clientID int, muted bool) {
|
||
c.receiveCommand(audioCommand{kind: "mute", clientID: clientID, muted: muted})
|
||
}
|
||
func (c *TSClient) RemoveRemoteAudioClient(clientID int) {
|
||
c.receiveCommand(audioCommand{kind: "remove", clientID: clientID})
|
||
}
|
||
func (c *TSClient) ClearRemoteAudioClients() { c.receiveCommand(audioCommand{kind: "clear"}) }
|
||
func (c *TSClient) receiveCommand(cmd audioCommand) {
|
||
c.mu.Lock()
|
||
r := c.receive
|
||
c.mu.Unlock()
|
||
if r != nil {
|
||
r.command(cmd)
|
||
}
|
||
}
|
||
|
||
// SendVoice 发送 Opus 语音帧
|
||
// codec: 4=Opus Voice, 5=Opus Music
|
||
// 返回空字符串表示成功
|
||
func (c *TSClient) SendVoice(data []byte, codec int64) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
if err := client.SendVoice(data, byte(codec)); err != nil {
|
||
return fmt.Sprintf("发送失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// initEventQueue initializes a fresh consumer for this connection session.
|
||
func (c *TSClient) initEventQueue() {
|
||
c.mu.Lock()
|
||
callback := c.callback
|
||
c.mu.Unlock()
|
||
q := newEventQueue(callback)
|
||
c.evtQueueMu.Lock()
|
||
c.evtQueue = q
|
||
c.evtQueueMu.Unlock()
|
||
c.startEventLoop(q)
|
||
}
|
||
|
||
// stopEventQueue stops and joins the current consumer. It is safe to call
|
||
// repeatedly and prevents stale sessions from dispatching into a new callback.
|
||
func (c *TSClient) stopEventQueue() {
|
||
c.evtQueueMu.Lock()
|
||
q := c.evtQueue
|
||
c.evtQueue = nil
|
||
c.evtQueueMu.Unlock()
|
||
if q == nil {
|
||
return
|
||
}
|
||
q.stopOnce.Do(func() {
|
||
q.mu.Lock()
|
||
q.stopped = true
|
||
q.cond.Broadcast()
|
||
q.mu.Unlock()
|
||
})
|
||
}
|
||
|
||
// startEventLoop starts the callback consumer for q.
|
||
func (c *TSClient) startEventLoop(q *eventQueue) {
|
||
go func() {
|
||
for {
|
||
q.mu.Lock()
|
||
for len(q.events) == 0 && !q.stopped {
|
||
q.cond.Wait()
|
||
}
|
||
if q.stopped {
|
||
q.mu.Unlock()
|
||
return
|
||
}
|
||
events := q.events
|
||
q.events = nil
|
||
q.pcmCount = 0
|
||
q.mu.Unlock()
|
||
|
||
for _, evt := range events {
|
||
c.processEvent(q.callback, evt)
|
||
}
|
||
}
|
||
}()
|
||
}
|
||
|
||
// queueEvent queues an event only while its session's consumer remains active.
|
||
func (c *TSClient) queueEvent(evt queuedEvent) {
|
||
c.evtQueueMu.Lock()
|
||
q := c.evtQueue
|
||
c.evtQueueMu.Unlock()
|
||
if q == nil {
|
||
return
|
||
}
|
||
q.mu.Lock()
|
||
if !q.stopped {
|
||
q.events = append(q.events, evt)
|
||
q.cond.Signal()
|
||
}
|
||
q.mu.Unlock()
|
||
}
|
||
|
||
// processEvent 处理单个事件（在消费协程中顺序执行）
|
||
func (c *TSClient) processEvent(cb EventCallback, evt queuedEvent) {
|
||
if cb == nil {
|
||
return
|
||
}
|
||
|
||
switch evt.evtType {
|
||
case "connected":
|
||
log.Printf("[TSEvent] connected")
|
||
cb.OnConnected()
|
||
case "disconnected":
|
||
msg := evt.data.(string)
|
||
log.Printf("[TSEvent] disconnected: %q", msg)
|
||
cb.OnDisconnected(msg)
|
||
case "textmessage":
|
||
m := evt.data.(*TextMsg)
|
||
log.Printf("[TSEvent] textmessage from=%q uid=%q mode=%d target=%s msg=%q", m.InvokerName, m.InvokerUID, m.TargetMode, m.TargetID, m.Message)
|
||
cb.OnTextMessage(m)
|
||
case "cliententer":
|
||
cl := evt.data.(*Client)
|
||
log.Printf("[TSEvent] cliententer id=%d nick=%q uid=%q channel=%s", cl.ID, cl.Nickname, cl.UID, cl.ChannelID)
|
||
cb.OnClientEnter(cl)
|
||
case "clientleave":
|
||
d := evt.data.(struct {
|
||
ID int
|
||
ReasonMsg string
|
||
})
|
||
log.Printf("[TSEvent] clientleave id=%d reason=%q", d.ID, d.ReasonMsg)
|
||
cb.OnClientLeave(d.ID, d.ReasonMsg)
|
||
case "clientmoved":
|
||
d := evt.data.(struct {
|
||
ID int
|
||
TargetChannelID string
|
||
})
|
||
log.Printf("[TSEvent] clientmoved id=%d targetChannel=%s", d.ID, d.TargetChannelID)
|
||
cb.OnClientMoved(d.ID, d.TargetChannelID)
|
||
case "kicked":
|
||
reason := evt.data.(string)
|
||
log.Printf("[TSEvent] kicked reason=%q", reason)
|
||
cb.OnKicked(reason)
|
||
case "voicedata":
|
||
d := evt.data.(struct {
|
||
ClientID int
|
||
Data []byte
|
||
Codec int
|
||
Sequence int
|
||
IsWhisper bool
|
||
})
|
||
cb.OnVoiceData(d.ClientID, d.Data, d.Codec, d.Sequence, d.IsWhisper)
|
||
case "mixedvoicepcm":
|
||
cb.OnMixedVoicePCM(evt.data.([]byte))
|
||
case "clientspeaking":
|
||
d := evt.data.(struct {
|
||
ClientID int
|
||
Speaking bool
|
||
})
|
||
cb.OnClientSpeaking(d.ClientID, d.Speaking)
|
||
case "poked":
|
||
p := evt.data.(*PokeEvent)
|
||
log.Printf("[TSEvent] poked from=%q (id=%d uid=%q) msg=%q", p.InvokerName, p.InvokerID, p.InvokerUID, p.Message)
|
||
cb.OnPoked(p)
|
||
}
|
||
}
|
||
|
||
func (c *TSClient) queueMixedPCM(pcm []byte) {
|
||
c.evtQueueMu.Lock()
|
||
q := c.evtQueue
|
||
c.evtQueueMu.Unlock()
|
||
if q == nil {
|
||
return
|
||
}
|
||
q.mu.Lock()
|
||
if !q.stopped {
|
||
if q.pcmCount >= maxQueuedPCMEvents {
|
||
for i, evt := range q.events {
|
||
if evt.evtType == "mixedvoicepcm" {
|
||
copy(q.events[i:], q.events[i+1:])
|
||
q.events = q.events[:len(q.events)-1]
|
||
q.pcmCount--
|
||
break
|
||
}
|
||
}
|
||
}
|
||
q.events = append(q.events, queuedEvent{evtType: "mixedvoicepcm", data: pcm})
|
||
q.pcmCount++
|
||
q.cond.Signal()
|
||
}
|
||
q.mu.Unlock()
|
||
}
|
||
func (c *TSClient) queueSpeaking(clientID int, speaking bool) {
|
||
c.queueEvent(queuedEvent{evtType: "clientspeaking", data: struct {
|
||
ClientID int
|
||
Speaking bool
|
||
}{clientID, speaking}})
|
||
}
|
||
|
||
// registerEvents 注册事件处理
|
||
// 所有事件通过队列传递，在消费协程中顺序调用 JNI 回调
|
||
func (c *TSClient) isCurrentClient(client *ts.Client) bool {
|
||
c.mu.Lock()
|
||
defer c.mu.Unlock()
|
||
return c.client == client
|
||
}
|
||
|
||
func (c *TSClient) queueClientEvent(client *ts.Client, evt queuedEvent) {
|
||
if c.isCurrentClient(client) {
|
||
c.queueEvent(evt)
|
||
}
|
||
}
|
||
|
||
func (c *TSClient) registerEvents(client *ts.Client) {
|
||
client.OnConnected(func() {
|
||
c.mu.Lock()
|
||
if c.client != client {
|
||
c.mu.Unlock()
|
||
return
|
||
}
|
||
c.connected = true
|
||
c.mu.Unlock()
|
||
c.queueEvent(queuedEvent{evtType: "connected"})
|
||
})
|
||
|
||
client.OnDisconnected(func(err error) {
|
||
c.StopReceiveAudio()
|
||
c.mu.Lock()
|
||
c.connected = false
|
||
c.client = nil
|
||
c.mu.Unlock()
|
||
msg := ""
|
||
if err != nil {
|
||
msg = err.Error()
|
||
}
|
||
c.queueEvent(queuedEvent{evtType: "disconnected", data: msg})
|
||
})
|
||
|
||
client.OnTextMessage(func(msg ts.TextMessage) {
|
||
c.queueEvent(queuedEvent{
|
||
evtType: "textmessage",
|
||
data: &TextMsg{
|
||
InvokerName: msg.InvokerName,
|
||
InvokerUID: msg.InvokerUID,
|
||
Message: msg.Message,
|
||
TargetMode: msg.TargetMode,
|
||
TargetID: fmt.Sprintf("%d", msg.TargetID),
|
||
},
|
||
})
|
||
})
|
||
|
||
client.OnClientEnter(func(info ts.ClientInfo) {
|
||
c.queueEvent(queuedEvent{
|
||
evtType: "cliententer",
|
||
data: &Client{
|
||
ID: int(info.ID),
|
||
Nickname: info.Nickname,
|
||
UID: info.UID,
|
||
ChannelID: fmt.Sprintf("%d", info.ChannelID),
|
||
IsSelf: false,
|
||
},
|
||
})
|
||
})
|
||
|
||
client.OnClientLeave(func(data ts.ClientLeftViewEvent) {
|
||
c.RemoveRemoteAudioClient(int(data.ID))
|
||
c.queueEvent(queuedEvent{
|
||
evtType: "clientleave",
|
||
data: struct {
|
||
ID int
|
||
ReasonMsg string
|
||
}{
|
||
ID: int(data.ID),
|
||
ReasonMsg: data.ReasonMsg,
|
||
},
|
||
})
|
||
})
|
||
|
||
client.OnClientMoved(func(data ts.ClientMovedEvent) {
|
||
c.queueEvent(queuedEvent{
|
||
evtType: "clientmoved",
|
||
data: struct {
|
||
ID int
|
||
TargetChannelID string
|
||
}{
|
||
ID: int(data.ID),
|
||
TargetChannelID: fmt.Sprintf("%d", data.TargetChannelID),
|
||
},
|
||
})
|
||
})
|
||
|
||
client.OnKicked(func(reason string) {
|
||
c.StopReceiveAudio()
|
||
c.mu.Lock()
|
||
c.connected = false
|
||
c.client = nil
|
||
c.mu.Unlock()
|
||
c.queueEvent(queuedEvent{evtType: "kicked", data: reason})
|
||
})
|
||
|
||
client.OnVoiceData(func(evt ts.VoiceDataEvent) {
|
||
c.mu.Lock()
|
||
r := c.receive
|
||
c.mu.Unlock()
|
||
if r != nil {
|
||
r.enqueue(int(evt.ClientID), int(evt.Codec), evt.Sequence, evt.Data)
|
||
return
|
||
}
|
||
// Keep the existing raw bridge active until an Android libopus decoder
|
||
// factory has been supplied and the Go receiver explicitly started.
|
||
c.queueEvent(queuedEvent{
|
||
evtType: "voicedata",
|
||
data: struct {
|
||
ClientID int
|
||
Data []byte
|
||
Codec int
|
||
Sequence int
|
||
IsWhisper bool
|
||
}{
|
||
ClientID: int(evt.ClientID),
|
||
Data: evt.Data,
|
||
Codec: int(evt.Codec),
|
||
Sequence: int(evt.Sequence),
|
||
IsWhisper: evt.IsWhisper,
|
||
},
|
||
})
|
||
})
|
||
|
||
client.OnPoked(func(evt ts.PokeEvent) {
|
||
c.queueEvent(queuedEvent{
|
||
evtType: "poked",
|
||
data: &PokeEvent{
|
||
InvokerID: int(evt.InvokerID),
|
||
InvokerName: evt.InvokerName,
|
||
InvokerUID: evt.InvokerUID,
|
||
Message: evt.Message,
|
||
},
|
||
})
|
||
})
|
||
}
|