702 lines
22 KiB
Go
702 lines
22 KiB
Go
// kotlin_api.go — Kotlin 友好 API 封装层
|
||
//
|
||
// 本文件补充 bridge.go 中未暴露的 SDK 能力，并提供 Identity 管理接口。
|
||
// 与 bridge.go 保持相同的 gomobile 导出约定：
|
||
// - 返回 string：空字符串=成功，非空=错误信息
|
||
// - 返回 JSON string：查询结果以 JSON 编码
|
||
//
|
||
// 设计文档：docs/implementation/99_Go层Kotlin友好化重构.md
|
||
// 能力清单：docs/implementation/98_Go层能力封装清单.md
|
||
package teamspeak
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"encoding/base64"
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"sort"
|
||
"strings"
|
||
"time"
|
||
|
||
ts "github.com/honeybbq/teamspeak-go"
|
||
"github.com/honeybbq/teamspeak-go/crypto"
|
||
)
|
||
|
||
// ═══════════════════════════════════════════════════════════════
|
||
// 一、Identity 管理
|
||
// ═══════════════════════════════════════════════════════════════
|
||
|
||
// GenerateIdentity 生成一个新的加密身份，返回序列化的字符串。
|
||
// Kotlin 侧应将此字符串持久化（SharedPreferences / DataStore），
|
||
// 后续连接时通过 ConnectWithIdentity 复用，避免每次生成新身份。
|
||
//
|
||
// securityLevel: 推荐值 8（2048-bit RSA）。值越大生成越慢。
|
||
//
|
||
// 返回格式: "base64EncodedPrivateKey:offset"
|
||
// 返回空字符串表示生成失败。
|
||
func GenerateIdentity(securityLevel int) string {
|
||
identity, err := crypto.GenerateIdentity(securityLevel)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] GenerateIdentity error: %v", err)
|
||
return ""
|
||
}
|
||
|
||
return identity.String()
|
||
}
|
||
|
||
// ConnectWithIdentity 使用已有的 identity 连接到 TeamSpeak 服务器。
|
||
// identityStr 由 GenerateIdentity 生成并由 Kotlin 侧持久化。
|
||
// 其余参数和行为与 Connect 相同。
|
||
//
|
||
// 返回：空字符串表示连接成功，非空为错误信息。
|
||
func (c *TSClient) ConnectWithIdentity(identityStr, host, nickname, password, defaultChannel, defaultChannelPassword string, cb EventCallback) string {
|
||
c.Disconnect()
|
||
c.stopEventQueue()
|
||
c.mu.Lock()
|
||
c.callback = cb
|
||
c.connected = false
|
||
c.host = host
|
||
c.mu.Unlock()
|
||
|
||
// 初始化事件队列和 Android decoder，避免旧的对象初始化路径留下 nil factory。
|
||
c.initEventQueue()
|
||
c.ensureReceiveFactory()
|
||
c.StartReceiveAudio()
|
||
|
||
identity, err := crypto.IdentityFromString(identityStr)
|
||
if err != nil {
|
||
return fmt.Sprintf("identity 解析失败: %v", err)
|
||
}
|
||
|
||
// 计算 TeamSpeak UID（base64(SHA1(publicKey))），用于僵尸会话过滤。
|
||
// 不能直接存储 identity 字符串，因为 UID 是公钥的哈希，格式完全不同。
|
||
uid := crypto.GetUidFromPublicKey(identity.PublicKeyBase64())
|
||
c.mu.Lock()
|
||
c.selfUID = uid
|
||
c.mu.Unlock()
|
||
|
||
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)
|
||
}
|
||
|
||
// 延迟执行僵尸清理：连接刚建立时客户端在默认频道，ListClients 可能尚未
|
||
// 收到服务器发来的完整客户端列表。延迟 3 秒确保所有 notifycliententerview
|
||
// 事件已到达，此时 ListClients 能发现不同频道中的僵尸会话。
|
||
go func() {
|
||
time.Sleep(3 * time.Second)
|
||
if c.isCurrentClient(client) {
|
||
c.cleanupDuplicateIdentitySessions(client, identity)
|
||
}
|
||
}()
|
||
return ""
|
||
}
|
||
|
||
// cleanupDuplicateIdentitySessions removes stale sessions using the same persisted
|
||
// identity, while always preserving the newly connected session.
|
||
func (c *TSClient) cleanupDuplicateIdentitySessions(client *ts.Client, identity *crypto.Identity) {
|
||
clients, err := client.ListClients()
|
||
if err != nil {
|
||
log.Printf("[TSBridge] duplicate session scan failed: %v", err)
|
||
return
|
||
}
|
||
uid := crypto.GetUidFromPublicKey(identity.PublicKeyBase64())
|
||
currentID := client.ClientID()
|
||
for _, candidate := range clients {
|
||
if candidate.ID == currentID || candidate.UID != uid {
|
||
continue
|
||
}
|
||
if err := client.KickClient(candidate.ID, 5, "Replaced stale mobile session"); err != nil {
|
||
log.Printf("[TSBridge] stale session kick failed clid=%d: %v", candidate.ID, err)
|
||
} else {
|
||
log.Printf("[TSBridge] stale session kicked clid=%d uid=%s", candidate.ID, uid)
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════
|
||
// 二、查询能力（补充 bridge.go 未暴露的方法）
|
||
// ═══════════════════════════════════════════════════════════════
|
||
|
||
// FindChannelsJSON 按名称模式搜索频道。
|
||
// 返回 JSON 数组：[{"id":"1","name":"匹配的频道"}, ...]
|
||
// 空数组 "[]" 表示无匹配或出错。
|
||
func (c *TSClient) FindChannelsJSON(pattern string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
channels, err := client.FindChannels(pattern)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] FindChannels error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
result := make([]channelJSON, len(channels))
|
||
for i, ch := range channels {
|
||
result[i] = channelJSON{
|
||
ID: fmt.Sprintf("%d", ch.ID),
|
||
Name: ch.Name,
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] FindChannels JSON marshal error: %v", err)
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// FindClientByNameJSON 按昵称搜索数据库客户端。
|
||
// 返回 JSON 对象：{"uid":"xxx","dbid":"123"}
|
||
// 空对象 "{}" 表示无匹配或出错。
|
||
func (c *TSClient) FindClientByNameJSON(nickname string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "{}"
|
||
}
|
||
|
||
uid, dbid, err := client.FindClientByName(nickname)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] FindClientByName error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := map[string]string{
|
||
"uid": uid,
|
||
"dbid": fmt.Sprintf("%d", dbid),
|
||
}
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// FindClientByDBIDJSON 按数据库 ID 查找客户端 UID。
|
||
// 返回 JSON 对象：{"uid":"xxx"}
|
||
// 空对象 "{}" 表示无匹配或出错。
|
||
func (c *TSClient) FindClientByDBIDJSON(dbidStr string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "{}"
|
||
}
|
||
|
||
var dbid uint64
|
||
if _, err := fmt.Sscanf(dbidStr, "%d", &dbid); err != nil {
|
||
return "{}"
|
||
}
|
||
|
||
uid, err := client.FindClientByDBID(dbid)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] FindClientByDBID error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := map[string]string{"uid": uid}
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ListChannelsSortedJSON 获取去重+树形排序的详细频道列表。
|
||
// 使用 channellist -topic -flags -voice -limits -icon 获取完整数据，
|
||
// 按 channel_order 排序，先顶层频道再子频道（树形扁平化）。
|
||
// 自动按 ID 去重（保留最后出现的条目）。
|
||
// 返回：JSON 数组，字段与 GetChannelsDetailedJSON 一致。
|
||
func (c *TSClient) ListChannelsSortedJSON() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "[]"
|
||
}
|
||
|
||
channels, err := client.ListChannelsDetailed()
|
||
if err != nil {
|
||
log.Printf("[KotlinAPI] ListChannelsSorted ListChannelsDetailed error: %v", err)
|
||
return "[]"
|
||
}
|
||
|
||
// 去重：按 ID，保留最后出现的
|
||
seen := make(map[uint64]bool)
|
||
deduped := make([]ts.ChannelInfoDetailed, 0, len(channels))
|
||
for _, ch := range channels {
|
||
if seen[ch.ID] {
|
||
continue
|
||
}
|
||
seen[ch.ID] = true
|
||
deduped = append(deduped, ch)
|
||
}
|
||
|
||
// 按 ParentID 分组
|
||
children := make(map[uint64][]ts.ChannelInfoDetailed)
|
||
var tops []ts.ChannelInfoDetailed
|
||
for _, ch := range deduped {
|
||
if ch.ParentID == 0 {
|
||
tops = append(tops, ch)
|
||
} else {
|
||
children[ch.ParentID] = append(children[ch.ParentID], ch)
|
||
}
|
||
}
|
||
|
||
// 按 Order 排序
|
||
sort.Slice(tops, func(i, j int) bool {
|
||
return tops[i].Order < tops[j].Order
|
||
})
|
||
for _, list := range children {
|
||
sort.Slice(list, func(i, j int) bool {
|
||
return list[i].Order < list[j].Order
|
||
})
|
||
}
|
||
|
||
// 树形扁平化：顶层 → 每个频道的子频道紧跟其后
|
||
var sorted []ts.ChannelInfoDetailed
|
||
var flatten func(ch ts.ChannelInfoDetailed)
|
||
flatten = func(ch ts.ChannelInfoDetailed) {
|
||
sorted = append(sorted, ch)
|
||
for _, child := range children[ch.ID] {
|
||
flatten(child)
|
||
}
|
||
}
|
||
for _, ch := range tops {
|
||
flatten(ch)
|
||
}
|
||
|
||
// 转换为 JSON
|
||
result := make([]channelDetailedJSON, len(sorted))
|
||
for i, ch := range sorted {
|
||
result[i] = channelDetailedJSON{
|
||
ID: fmt.Sprintf("%d", ch.ID),
|
||
ParentID: fmt.Sprintf("%d", ch.ParentID),
|
||
Name: ch.Name,
|
||
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.IsOrdered,
|
||
IconID: fmt.Sprintf("%d", ch.IconID),
|
||
NeededModifyPower: ch.NeededModifyPower,
|
||
}
|
||
}
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
return "[]"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════
|
||
// 三、操作能力（补充 bridge.go 未暴露的方法）
|
||
// ═══════════════════════════════════════════════════════════════
|
||
|
||
// MoveClient 将指定客户端移动到目标频道。
|
||
// clientID: 客户端 ID（clid）
|
||
// channelID: 目标频道 ID
|
||
// password: 频道密码（可选，无密码传空字符串）
|
||
// 返回：空字符串表示成功，非空为错误信息。
|
||
func (c *TSClient) MoveClient(clientID int, 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(uint16(clientID), channelID, password); err != nil {
|
||
return fmt.Sprintf("移动失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// MoveChannel 移动频道到新的父频道或调整排序。
|
||
// channelID: 要移动的频道 ID
|
||
// parentID: 新的父频道 ID（0 = 顶层）
|
||
// order: 排序位置（0 = 最顶部）
|
||
// 返回：空字符串表示成功，非空为错误信息。
|
||
func (c *TSClient) MoveChannel(channelIDStr, parentIDStr, orderStr string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var channelID, parentID, order uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return fmt.Sprintf("无效的频道 ID: %v", err)
|
||
}
|
||
if _, err := fmt.Sscanf(parentIDStr, "%d", &parentID); err != nil {
|
||
return fmt.Sprintf("无效的父频道 ID: %v", err)
|
||
}
|
||
if _, err := fmt.Sscanf(orderStr, "%d", &order); err != nil {
|
||
return fmt.Sprintf("无效的排序值: %v", err)
|
||
}
|
||
|
||
if err := client.MoveChannel(channelID, parentID, order); err != nil {
|
||
return fmt.Sprintf("移动频道失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// DeleteAllBans 清除所有封禁记录。
|
||
// 返回：空字符串表示成功，非空为错误信息。
|
||
func (c *TSClient) DeleteAllBans() string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
if err := client.DeleteAllBans(); err != nil {
|
||
return fmt.Sprintf("清除失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// DeleteComplaint 删除指定投诉。
|
||
// targetDBID: 被投诉者的数据库 ID
|
||
// fromDBID: 投诉者的数据库 ID
|
||
// 返回：空字符串表示成功，非空为错误信息。
|
||
func (c *TSClient) DeleteComplaint(targetDBIDStr, fromDBIDStr string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
c.mu.Unlock()
|
||
|
||
if client == nil {
|
||
return "未连接"
|
||
}
|
||
|
||
var targetDBID, fromDBID uint64
|
||
if _, err := fmt.Sscanf(targetDBIDStr, "%d", &targetDBID); err != nil {
|
||
return fmt.Sprintf("无效的目标 DBID: %v", err)
|
||
}
|
||
if _, err := fmt.Sscanf(fromDBIDStr, "%d", &fromDBID); err != nil {
|
||
return fmt.Sprintf("无效的来源 DBID: %v", err)
|
||
}
|
||
|
||
if err := client.DeleteComplaint(targetDBID, fromDBID); err != nil {
|
||
return fmt.Sprintf("删除投诉失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════
|
||
// 四、文件传输（初始化阶段）
|
||
// ═══════════════════════════════════════════════════════════════
|
||
|
||
// fileTransferInitJSON 文件传输初始化结果的 JSON 结构
|
||
type fileTransferInitJSON struct {
|
||
Host string `json:"host"`
|
||
Port uint16 `json:"port"`
|
||
Key string `json:"key"`
|
||
Size uint64 `json:"size,omitempty"`
|
||
ClientFileTransferID uint16 `json:"clientFileTransferID"`
|
||
ServerFileTransferID uint16 `json:"serverFileTransferID"`
|
||
SeekPosition uint64 `json:"seekPosition,omitempty"`
|
||
}
|
||
|
||
// FileTransferInitUploadJSON 初始化文件上传。
|
||
// channelID: 目标频道 ID
|
||
// path: 频道内虚拟路径（如 "/myfile.txt"）
|
||
// size: 文件大小（字节）
|
||
// overwrite: 是否覆盖已有文件
|
||
//
|
||
// 返回 JSON：{"port":0,"key":"...","clientFileTransferID":0,"serverFileTransferID":0,"seekPosition":0}
|
||
// 空对象 "{}" 表示失败。
|
||
//
|
||
// 注意：TCP 连接的 host 为当前服务器地址，port 从返回的 JSON 中获取。
|
||
func (c *TSClient) FileTransferInitUploadJSON(channelIDStr, path string, size int64, overwrite 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 "{}"
|
||
}
|
||
|
||
info, err := client.FileTransferInitUpload(channelID, path, "", uint64(size), overwrite)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] FileTransferInitUpload error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := fileTransferInitJSON{
|
||
Port: info.Port,
|
||
Key: info.FileTransferKey,
|
||
ClientFileTransferID: info.ClientFileTransferID,
|
||
ServerFileTransferID: info.ServerFileTransferID,
|
||
SeekPosition: info.SeekPosition,
|
||
}
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// FileTransferInitDownloadJSON 初始化文件下载。
|
||
// channelID: 目标频道 ID
|
||
// path: 频道内虚拟路径（如 "/myfile.txt"）
|
||
//
|
||
// 返回 JSON：{"port":0,"key":"...","size":0,"clientFileTransferID":0,"serverFileTransferID":0}
|
||
// 空对象 "{}" 表示失败。
|
||
func (c *TSClient) FileTransferInitDownloadJSON(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 "{}"
|
||
}
|
||
|
||
info, err := client.FileTransferInitDownload(channelID, path, "")
|
||
if err != nil {
|
||
log.Printf("[TSBridge] FileTransferInitDownload error: %v", err)
|
||
return "{}"
|
||
}
|
||
|
||
result := fileTransferInitJSON{
|
||
Port: info.Port,
|
||
Key: info.FileTransferKey,
|
||
Size: info.Size,
|
||
ClientFileTransferID: info.ClientFileTransferID,
|
||
ServerFileTransferID: info.ServerFileTransferID,
|
||
}
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
// DeleteFile 删除频道中的文件。
|
||
// channelID: 频道 ID
|
||
// pathsJSON: 要删除的文件路径 JSON 数组，如 ["/file1.txt","/file2.txt"]
|
||
// 返回：空字符串表示成功，非空为错误信息。
|
||
func (c *TSClient) DeleteFile(channelIDStr, pathsJSON 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 paths []string
|
||
if err := json.Unmarshal([]byte(pathsJSON), &paths); err != nil {
|
||
return fmt.Sprintf("路径解析失败: %v", err)
|
||
}
|
||
|
||
if err := client.FileTransferDeleteFile(channelID, paths); err != nil {
|
||
return fmt.Sprintf("删除失败: %v", err)
|
||
}
|
||
return ""
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════
|
||
// 4.5 文件下载（完整流程）
|
||
// ═══════════════════════════════════════════════════════════════
|
||
|
||
// DownloadFileBytesJSON 下载频道文件并返回 base64 编码的内容。
|
||
//
|
||
// 完整流程：ftinitdownload → TCP 连接 → 读取字节 → base64 编码。
|
||
// channelID: 频道 ID
|
||
// path: 文件虚拟路径（如 "/image.png"）
|
||
//
|
||
// 返回 JSON：{"data":"base64...","size":12345}
|
||
// 空对象 "{}" 表示失败。
|
||
func (c *TSClient) DownloadFileBytesJSON(channelIDStr, path string) string {
|
||
c.mu.Lock()
|
||
client := c.client
|
||
host := c.host
|
||
c.mu.Unlock()
|
||
|
||
if client == nil || host == "" {
|
||
return "{}"
|
||
}
|
||
|
||
var channelID uint64
|
||
if _, err := fmt.Sscanf(channelIDStr, "%d", &channelID); err != nil {
|
||
return "{}"
|
||
}
|
||
|
||
// 尝试多种路径格式（MyTS 文件可能存储在特殊目录）
|
||
paths := []string{path}
|
||
if !strings.HasPrefix(path, "/") {
|
||
paths = append(paths, "/"+path)
|
||
}
|
||
|
||
for _, p := range paths {
|
||
// 1. 初始化下载
|
||
info, err := client.FileTransferInitDownload(channelID, p, "")
|
||
if err != nil {
|
||
log.Printf("[TSBridge] DownloadFileBytes init error (path=%s): %v", p, err)
|
||
continue
|
||
}
|
||
|
||
// 2. TCP 连接 + 下载
|
||
var buf bytes.Buffer
|
||
if err := ts.DownloadFileData(host, info, &buf); err != nil {
|
||
log.Printf("[TSBridge] DownloadFileBytes transfer error (path=%s): %v", p, err)
|
||
continue
|
||
}
|
||
|
||
// 3. base64 编码（gomobile 不支持 []byte 返回）
|
||
encoded := base64.StdEncoding.EncodeToString(buf.Bytes())
|
||
|
||
result := map[string]interface{}{
|
||
"data": encoded,
|
||
"size": buf.Len(),
|
||
}
|
||
data, err := json.Marshal(result)
|
||
if err != nil {
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
return "{}"
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════
|
||
// 五、批量查询（首次同步优化）
|
||
// ═══════════════════════════════════════════════════════════════
|
||
|
||
// initialSyncJSON 首次同步结果的 JSON 结构
|
||
type initialSyncJSON struct {
|
||
Channels []channelDetailedJSON `json:"channels"`
|
||
Clients []clientJSON `json:"clients"`
|
||
SelfID int `json:"selfId"`
|
||
SelfChannelID string `json:"selfChannelId"`
|
||
Server *serverInfoJSON `json:"server"`
|
||
}
|
||
|
||
// GetInitialSyncJSON 执行首次同步，一次性返回所有初始数据。
|
||
// 减少 JNI 调用次数（从 4 次降为 1 次）。
|
||
//
|
||
// 返回 JSON：
|
||
//
|
||
// {
|
||
// "channels": [...], // 详细频道列表
|
||
// "clients": [...], // 在线客户端列表
|
||
// "selfId": 1, // 自身客户端 ID
|
||
// "selfChannelId": "1", // 自身所在频道 ID
|
||
// "server": {...} // 服务器信息
|
||
// }
|
||
//
|
||
// 任一子查询失败时对应字段为 null/空，不影响其他字段。
|
||
func (c *TSClient) GetInitialSyncJSON() string {
|
||
sync := initialSyncJSON{
|
||
SelfID: c.GetClientID(),
|
||
SelfChannelID: c.GetChannelID(),
|
||
}
|
||
|
||
// 频道列表（详细）
|
||
if data := c.GetChannelsDetailedJSON(); data != "[]" {
|
||
var channels []channelDetailedJSON
|
||
if err := json.Unmarshal([]byte(data), &channels); err == nil {
|
||
sync.Channels = channels
|
||
}
|
||
}
|
||
|
||
// 客户端列表
|
||
if data := c.GetClientsJSON(); data != "[]" {
|
||
var clients []clientJSON
|
||
if err := json.Unmarshal([]byte(data), &clients); err == nil {
|
||
sync.Clients = clients
|
||
}
|
||
}
|
||
|
||
// 服务器信息
|
||
if data := c.GetServerInfoJSON(); data != "{}" {
|
||
var server serverInfoJSON
|
||
if err := json.Unmarshal([]byte(data), &server); err == nil {
|
||
sync.Server = &server
|
||
}
|
||
}
|
||
|
||
data, err := json.Marshal(sync)
|
||
if err != nil {
|
||
log.Printf("[TSBridge] GetInitialSyncJSON marshal error: %v", err)
|
||
return "{}"
|
||
}
|
||
return string(data)
|
||
}
|