uniapp学习

uniapp是一个可以将业务逻辑层代码运行到微信小程序、H5、App等多个平台的框架。
最近写了一个uniapp 的 安卓软件 底层用的安卓的代码

Native 不支持鸿蒙

js写法 安卓

plus.android.importClass("java.net.Socket")

苹果

plus.ios.importClass("UIAlertView")

鸿蒙 不清楚能不能用

import socket from '@ohos.net.socket';

---

uts写法

Android

import java.net.Socket;
const socket = new Socket("192.168.1.1", 8080);

kt

import java.net.Socket

fun main() {
    val socket = Socket("192.168.1.100", 8080)
}

IOS

import Foundation

let host = "192.168.1.100"
let port: UInt16 = 8080
var readStream: Unmanaged<CFReadStream>?
var writeStream: Unmanaged<CFWriteStream>?

CFStreamCreatePairWithSocketToHost(
    nil,
    host as CFString,
    port,
    &readStream,
    &writeStream
)

swift

import Foundation

func main() {
    let host = "192.168.1.100"
    let port: UInt16 = 8080
    
    var readStream: Unmanaged<CFReadStream>?
    var writeStream: Unmanaged<CFWriteStream>?
    
    CFStreamCreatePairWithSocketToHost(
        nil,
        host as CFString,
        port,
        &readStream,
        &writeStream
    )
}

鸿蒙

// 鸿蒙对应 Socket TCP
import socket from '@ohos.net.socket';

// 创建Socket（和你JS逻辑等价）
const tcpSocket = socket.constructTCPSocketInstance();

ets

import socket from '@ohos.net.socket';

async function main() {
  const tcpSocket = socket.constructTCPSocketInstance();
  
  await tcpSocket.bind({ address: "0.0.0.0", port: 0, family: 1 });
  await tcpSocket.connect({ address: "192.168.1.100", port: 8080 });
}

---

编写一个三端可用的TCP插件 安卓真实可用 其他不确定

utssdk目录下interface.uts

/**
 * TCP操作结果类型
 */
export type TCPResultType = {
	code : number
	data ?: any
	error ?: string
}

/**
 * 连接配置选项
 */
export type ConnectionOptionsType = {
	serverHost : string
	serverPort : number
	timeout ?: number // 连接超时时间，单位毫秒，默认5000
	enableHeartbeat ?: boolean // 是否启用心跳，默认false
	heartbeatInterval ?: number // 心跳间隔，单位毫秒，默认30000
	heartbeatMessage ?: string // 心跳消息内容，默认"HEARTBEAT"
}

/**
 * 连接状态回调参数
 */
export type ConnectionStatusType = {
	state : string
	error ?: string // 错误信息
}

/**
 * 回调函数类型
 */
export type ConnectedCallbackType = (clientId : string, res : TCPResultType) => void
export type DisconnectedCallbackType = (clientId : string, res : TCPResultType) => void
export type MessageCallbackType = (clientId : string, message : string) => void
export type ErrorCallbackType = (clientId : string, res : TCPResultType) => void


/**
 * 创建TCP客户端实例
 * @returns 客户端ID
 */
export type CreateTCPClientType = () => string

/**
 * 通过客户端ID连接到服务器
 * @param clientId 客户端ID
 * @param options 连接选项
 */
export type ConnectClientType = (clientId : string, options : ConnectionOptionsType) => void

/**
 * 通过客户端ID断开连接
 * @param clientId 客户端ID
 */
export type DisconnectClientType = (clientId : string) => void

/**
 * 通过客户端ID 销毁客户端
 * @param clientId 客户端ID
 */
export type DistoryClientType = (clientId : string) => void


/**
 * 通过客户端ID发送消息
 * @param clientId 客户端ID
 * @param message 消息内容
 */
export type SendMessageType = (clientId : string, message : string) => void

/**
 * 注册连接成功回调
 * @param clientId 客户端ID
 * @param callback 连接成功回调函数
 */
export type OnConnectedType = (clientId : string, callback : ConnectedCallbackType) => void

/**
 * 注册断开连接回调
 * @param clientId 客户端ID
 * @param callback 断开连接回调函数
 */
export type OnDisconnectedType = (clientId : string, callback : DisconnectedCallbackType) => void

/**
 * 注册消息接收回调
 * @param clientId 客户端ID
 * @param callback 消息接收回调函数
 */
export type OnMessageType = (clientId : string, callback : MessageCallbackType) => void

/**
 * 注册错误回调
 * @param clientId 客户端ID
 * @param callback 错误回调函数
 */
export type OnErrorType = (clientId : string, callback : ErrorCallbackType) => void

/**
 * 获取所有活跃的客户端实例
 */
export type GetActiveClientsType = () => string[]

/**
 * 获取客户端连接状态
 * @param clientId 客户端ID
 */
export type GetClientStateType = (clientId : string) => string

/**
 * 检查客户端是否存在
 * @param clientId 客户端ID
 */
export type ClientExistsType = (clientId : string) => boolean

/**
 * 启用心跳
 * @param clientId 客户端ID
 * @param interval 心跳间隔，单位毫秒
 * @param message 心跳消息内容
 */
export type EnableHeartbeatType = (clientId : string, interval ?: number, message ?: string) => void

/**
 * 禁用心跳
 * @param clientId 客户端ID
 */
export type DisableHeartbeatType = (clientId : string) => void



// ==============================
// 下面全部是 追加 的服务端类型
// ==============================
export type StartServerType = (port: number) => void
export type StopServerType = () => void
export type SendToClientType = (clientId: string, msg: string) => void
export type BroadcastType = (msg: string) => void
export type GetClientsType = () => string[]

export type OnServerStartedType = (callback: () => void) => void
export type OnClientConnectedType = (callback: (clientId: string) => void) => void
export type OnClientDisconnectedType = (callback: (clientId: string) => void) => void
export type OnServerMessageType = (callback: (clientId: string, msg: string) => void) => void
export type OnServerErrorType = (callback: (msg: string) => void) => void

app-android目录下index.uts

import {
	CreateTCPClientType,
	ConnectClientType,
	DisconnectClientType,
	DistoryClientType,
	SendMessageType,
	OnConnectedType,
	OnDisconnectedType,
	OnMessageType,
	OnErrorType,
	GetActiveClientsType,
	GetClientStateType,
	ClientExistsType,
	EnableHeartbeatType,
	DisableHeartbeatType,
	ConnectionOptionsType,
	ConnectedCallbackType,
	DisconnectedCallbackType,
	MessageCallbackType,
	ErrorCallbackType,
	TCPResultType,
	StartServerType,
	StopServerType,
	SendToClientType,
	BroadcastType,
	GetClientsType,
	OnServerStartedType,
	OnClientConnectedType,
	OnClientDisconnectedType,
	OnServerMessageType,
	OnServerErrorType,
} from '../interface.uts'

import TCPClientManager from "uts.sdk.modules.redTcp.TCPClientManager";

export const createTCPClient : CreateTCPClientType = () : string => {
	return TCPClientManager.createTCPClient()
}

export const connectClient : ConnectClientType = (clientId : string, options : ConnectionOptionsType) : void => {
	console.log(options)
	TCPClientManager.connectClient(clientId, options)
}

export const disconnectClient : DisconnectClientType = (clientId : string) : void => {
	TCPClientManager.disconnectClient(clientId)
}

export const distoryClient : DistoryClientType = (clientId : string) : void => {
	TCPClientManager.destroyClient(clientId)
}

export const sendMessage : SendMessageType = (clientId : string, message : string) : void => {
	TCPClientManager.sendMessage(clientId, message)
}

@UTSJS.keepAlive
export function onConnected(clientId : string, callback : ConnectedCallbackType) : void {
	TCPClientManager.onConnected(clientId, callback)
}

@UTSJS.keepAlive
export function onDisconnected(clientId : string, callback : DisconnectedCallbackType) : void {
	TCPClientManager.onDisconnected(clientId, callback)
}

@UTSJS.keepAlive
export function onMessage(clientId : string, callback : MessageCallbackType) : void {
	TCPClientManager.onMessage(clientId, callback)
}

@UTSJS.keepAlive
export function onError(clientId : string, callback : ErrorCallbackType) : void {
	TCPClientManager.onError(clientId, callback)
}

export const getActiveClients : GetActiveClientsType = () : string[] => {
	return Array.from<string>(TCPClientManager.getActiveClients())
}

export const getClientState : GetClientStateType = (clientId : string) : string => {
	return TCPClientManager.getClientState(clientId)
}

export const clientExists : ClientExistsType = (clientId : string) : boolean => {
	return TCPClientManager.clientExists(clientId)
}

export const enableHeartbeat : EnableHeartbeatType = (clientId : string, interval ?: number, message ?: string) : void => {
	const heartbeatInterval = interval ?? 30000
	const heartbeatMessage = message ?? "HEARTBEAT"
	TCPClientManager.enableHeartbeat(clientId, heartbeatInterval.toInt(), heartbeatMessage)
}

export const disableHeartbeat : DisableHeartbeatType = (clientId : string) : void => {
	TCPClientManager.disableHeartbeat(clientId)
}



// ==============================
// 下面全部是 追加 的服务端接口
// 不修改、不触碰你上面的任何客户端代码
// ==============================
import TCPServerManager from "uts.sdk.modules.redTcp.TCPServerManager"

export const startServer: StartServerType = (port: number): void => {
	TCPServerManager.instance.startServer(port.toInt())
}

export const stopServer: StopServerType = (): void => {
	TCPServerManager.instance.stopServer()
}

export const sendToClient: SendToClientType = (clientId: string, msg: string): void => {
	TCPServerManager.instance.sendToClient(clientId, msg)
}

export const broadcast: BroadcastType = (msg: string): void => {
	TCPServerManager.instance.broadcast(msg)
}

export const getClients: GetClientsType = (): string[] => {
	return Array.from(TCPServerManager.instance.getClients()) as string[]
}

@UTSJS.keepAlive
export const onServerStarted: OnServerStartedType = (callback: () => void): void => {
	TCPServerManager.instance.onStarted(callback)
}

@UTSJS.keepAlive
export const onClientConnected: OnClientConnectedType = (callback: (String) => void): void => {
	TCPServerManager.instance.onClientConnected(callback)
}

@UTSJS.keepAlive
export const onClientDisconnected: OnClientDisconnectedType = (callback: (String) => void): void => {
	TCPServerManager.instance.onClientDisconnected(callback)
}

@UTSJS.keepAlive
export const onServerMessage: OnServerMessageType = (callback: (String, String) => void): void => {
	TCPServerManager.instance.onMessageReceived(callback)
}

@UTSJS.keepAlive
export const onServerError: OnServerErrorType = (callback: (String) => void): void => {
	TCPServerManager.instance.onError(callback)
}

同目录 TCPClient.kt

package uts.sdk.modules.redTcp

import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.net.Socket
import java.util.concurrent.TimeUnit



/**
 * android平台tcp客户端实现类
 */
class TCPClient(private val clientId: String) {
    
    // 连接状态
    private var connectionState: String = "disconnected"
    
    // socket相关
    private var socket: Socket? = null
    private var reader: BufferedReader? = null
    private var writer: BufferedWriter? = null
        
    // 回调函数
    private var connectedCallback: ConnectedCallbackType? = null
    private var disconnectedCallback: DisconnectedCallbackType? = null
    private var messageCallback: MessageCallbackType? = null
    private var errorCallback: ErrorCallbackType? = null
    
    // 连接配置
    private var connectionOptions: ConnectionOptionsType? = null
    
    // 心跳相关
    private var heartbeatEnabled: Boolean = false
    private var heartbeatInterval: Long = 30000L // 默认30秒
    private var heartbeatMessage: String = "HEARTBEAT"
    private var heartbeatRunnable: Runnable? = null
    private var isHeartbeatActive: Boolean = false

    
    /**
     * 连接到服务器
     */
    fun connect(options: ConnectionOptionsType) {
        if (connectionState != "disconnected") {
            notifyError(TCPResultType(code = 1, error = "Client is not disconnected"))
            return
        }
        
        connectionOptions = options
        connectionState = "connecting"
        
        // 设置心跳配置
        connectionOptions?.enableHeartbeat?.let { enable ->
            if (enable) {
                heartbeatEnabled = true
                connectionOptions?.heartbeatInterval?.let { interval ->
                    heartbeatInterval = interval.toLong()
                }
                connectionOptions?.heartbeatMessage?.let { message ->
                    heartbeatMessage = message
                }
            }
        }
        
        TCPClientManager.executeOnThreadPool(Runnable {
            try {
                val timeout = connectionOptions?.timeout?.toInt()  ?: 5000
                socket = Socket()
                socket?.connect(
                    java.net.InetSocketAddress(connectionOptions?.serverHost, connectionOptions?.serverPort?.toInt() ?: 0),
                    timeout
                )
                
                if (socket?.isConnected == true) {
                    reader = BufferedReader(InputStreamReader(socket?.getInputStream()))
                    writer = BufferedWriter(OutputStreamWriter(socket?.getOutputStream()))
                    
                    connectionState = "connected"
                    
                    // 启动消息接收线程
                    startMessageReceiver()
                    
                    // 启动心跳
                    startHeartbeat()
                    
                    // 通知连接成功
                    notifyConnected(TCPResultType(code = 0, data = "Connected successfully"))
                } else {
                    connectionState = "disconnected"
                    notifyError(TCPResultType(code = 2, error = "Failed to connect to server"))
                }
            } catch (e: Exception) {
                connectionState = "disconnected"
                notifyError(TCPResultType(code = 3, error = e.message ?: "Unknown connection error"))
            }
        })
    }
    
    /**
     * 断开连接
     */
    fun disconnect() {
        if (connectionState == "disconnected" || connectionState == "disconnecting") {
            return
        }
        
        connectionState = "disconnecting"
        
        // 停止心跳
        stopHeartbeat()
        
        TCPClientManager.executeOnThreadPool(Runnable {
            try {
                // 安全地关闭资源，按正确顺序
                writer?.apply {
                    flush()
                    close()
                }
                reader?.close()
                socket?.close()
                
                connectionState = "disconnected"
                notifyDisconnected(TCPResultType(code = 0, data = "Disconnected successfully"))
            } catch (e: Exception) {
                connectionState = "disconnected"
                notifyError(TCPResultType(code = 4, error = e.message ?: "Unknown disconnection error"))
            } finally {
                // 确保资源被清理
                writer = null
                reader = null
                socket = null
            }
        })
    }
    
    /**
     * 发送消息
     */
    fun sendMessage(message: String) {
        if (connectionState != "connected") {
            notifyError(TCPResultType(code = 5, error = "Client is not connected"))
            return
        }

        TCPClientManager.executeOnThreadPool(Runnable {
            try {
                // 🔥 添加换行符，确保服务端能正确识别消息边界
                val messageWithNewline = if (message.endsWith("\n")) message else "$message\n"
                writer?.write(messageWithNewline)
                writer?.flush()
            } catch (e: Exception) {
                notifyError(TCPResultType(code = 6, error = e.message ?: "Failed to send message"))
            }
        })
    }
    
    /**
     * 获取连接状态
     */
    fun getConnectionState(): String {
        return connectionState
    }
    
    /**
     * 销毁客户端实例
     */
    fun destroy() {
        disconnect()
    }
    
    /**
     * 注册连接成功回调
     */
    fun onConnected(callback: ConnectedCallbackType) {
        connectedCallback = callback
    }
    
    /**
     * 注册断开连接回调
     */
    fun onDisconnected(callback: DisconnectedCallbackType) {
        disconnectedCallback = callback
    }
    
    /**
     * 注册消息接收回调
     */
    fun onMessage(callback: MessageCallbackType) {
        messageCallback = callback
    }
    
    /**
     * 注册错误回调
     */
    fun onError(callback: ErrorCallbackType) {
        errorCallback = callback
    }
    
    /**
     * 启用心跳
     */
    fun enableHeartbeat(interval: Int = 30000, message: String = "HEARTBEAT") {
        heartbeatEnabled = true
        heartbeatInterval = interval.toLong()
        heartbeatMessage = message
        
        // 如果已连接，立即启动心跳
        if (connectionState == "connected") {
            startHeartbeat()
        }
    }
    
    /**
     * 禁用心跳
     */
    fun disableHeartbeat() {
        heartbeatEnabled = false
        stopHeartbeat()
    }
    
    /**
     * 启动心跳
     */
    private fun startHeartbeat() {
        if (!heartbeatEnabled || connectionState != "connected") {
            return
        }
        
        // 停止之前的心跳
        stopHeartbeat()
        
        isHeartbeatActive = true
        
        heartbeatRunnable = object : Runnable {
            override fun run() {
                // 检查心跳是否仍然活跃
                if (isHeartbeatActive && heartbeatEnabled && connectionState == "connected") {
                    sendHeartbeat()
                    // 继续调度下一次心跳
                    TCPClientManager.scheduleOnThreadPool(this, heartbeatInterval, TimeUnit.MILLISECONDS)
                }
            }
        }
        
        // 启动心跳
        TCPClientManager.scheduleOnThreadPool(heartbeatRunnable!!, heartbeatInterval, TimeUnit.MILLISECONDS)
    }
    
    /**
     * 停止心跳
     */
    private fun stopHeartbeat() {
        isHeartbeatActive = false
        heartbeatRunnable = null
    }
    
    /**
     * 发送心跳消息
     */
    private fun sendHeartbeat() {
        if (!isHeartbeatActive || !heartbeatEnabled || connectionState != "connected") {
            return
        }
        
        TCPClientManager.executeOnThreadPool(Runnable {
            try {
                writer?.write(heartbeatMessage + "\n")  // 添加换行符确保消息完整
                writer?.flush()
            } catch (e: Exception) {
                // 心跳发送失败不需要特殊处理，让正常的错误处理机制处理
            }
        })
    }
    
    /**
     * 启动消息接收线程
     */
    private fun startMessageReceiver() {
        TCPClientManager.executeOnThreadPool(Runnable {
            try {
                while (connectionState == "connected" && socket?.isConnected == true) {
                    val message = reader?.readLine()
                    if (message != null) {
                        // 验证消息内容
                        if (message.isNotBlank()) {
                            notifyMessage(message)
                        }
                    } else {
                        // 服务器关闭了连接
                        break
                    }
                }
                
                // 如果循环结束，说明连接已断开
                if (connectionState == "connected") {
                    connectionState = "disconnected"
                    notifyDisconnected(TCPResultType(code = 0, data = "Server closed the connection"))
                }
            } catch (e: Exception) {
                if (connectionState == "connected") {
                    connectionState = "disconnected"
                    notifyError(TCPResultType(code = 8, error = e.message ?: "Message receiver error"))
                }
            }
        })
    }
    

    

    
    /**
     * 通知连接成功
     */
    private fun notifyConnected(result: TCPResultType) {
        TCPClientManager.executeOnMainThread(Runnable {
            connectedCallback?.invoke(clientId, result)
        })
    }
    
    /**
     * 通知断开连接
     */
    private fun notifyDisconnected(result: TCPResultType) {
        TCPClientManager.executeOnMainThread(Runnable {
            disconnectedCallback?.invoke(clientId, result)
        })
    }
    
    /**
     * 通知接收到消息
     */
    private fun notifyMessage(message: String) {
        TCPClientManager.executeOnMainThread(Runnable {
            messageCallback?.invoke(clientId, message)
        })
    }
    
    /**
     * 通知错误
     */
    private fun notifyError(result: TCPResultType) {
        TCPClientManager.executeOnMainThread(Runnable {
            errorCallback?.invoke(clientId, result)
        })
    }
}

同目录TCPClientManager.kt

package uts.sdk.modules.redTcp

import android.os.Handler
import android.os.Looper
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledExecutorService
import java.util.concurrent.TimeUnit

/**
 * TCP客户端管理器
 * 负责统一管理所有TCP客户端实例和线程资源
 * 使用object关键字实现单例模式
 */
object TCPClientManager {
    
    // 存储所有活跃的客户端实例
    private val activeClients = mutableMapOf<String, TCPClient>()
    
    // 全局线程池，用于所有TCP客户端的异步操作
    private val executorService = Executors.newCachedThreadPool()
    
    // 全局调度器，用于心跳等定时任务
    private val scheduledExecutor: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor()
    
    // 主线程handler，用于回调
    private val mainHandler = Handler(Looper.getMainLooper())
    
    /**
     * 创建TCP客户端实例
     * @return 客户端ID
     */
    fun createTCPClient(): String {
        val clientId = "client_${System.currentTimeMillis()}_${(Math.random() * 1000000).toInt().toString(36)}"
        val client = TCPClient(clientId)
        activeClients[clientId] = client
        return clientId
    }
    
    /**
     * 通过客户端ID获取TCP客户端实例
     * @param clientId 客户端ID
     * @return TCP客户端实例，如果不存在则返回null
     */
    fun getTCPClient(clientId: String): TCPClient? {
        return activeClients[clientId]
    }
    
    /**
     * 通过客户端ID连接到服务器
     * @param clientId 客户端ID
     * @param options 连接选项
     */
    fun connectClient(clientId: String, options: ConnectionOptionsType) {
        val client = activeClients[clientId]
        if (client != null) {
            client.connect(options)
        }
    }
    
    /**
     * 通过客户端ID断开连接
     * @param clientId 客户端ID
     */
    fun disconnectClient(clientId: String) {
        val client = activeClients[clientId]
        client?.disconnect()
    }
    
    /**
     * 通过客户端ID销毁客户端
     * @param clientId 客户端ID
     */
    fun destroyClient(clientId: String) {
        val client = activeClients[clientId]
        if (client != null) {
            client.destroy()
            activeClients.remove(clientId)
        }
    }
    
    /**
     * 通过客户端ID发送消息
     * @param clientId 客户端ID
     * @param message 消息内容
     */
    fun sendMessage(clientId: String, message: String) {
        val client = activeClients[clientId]
        if (client != null && message.isNotBlank()) {
            client.sendMessage(message)
        }
    }
    
    /**
     * 通过客户端ID注册连接成功回调
     * @param clientId 客户端ID
     * @param callback 连接成功回调函数
     */
    fun onConnected(clientId: String, callback: ConnectedCallbackType) {
        val client = activeClients[clientId]
        client?.onConnected(callback)
    }
    
    /**
     * 通过客户端ID注册断开连接回调
     * @param clientId 客户端ID
     * @param callback 断开连接回调函数
     */
    fun onDisconnected(clientId: String, callback: DisconnectedCallbackType) {
        val client = activeClients[clientId]
        client?.onDisconnected(callback)
    }
    
    /**
     * 通过客户端ID注册消息接收回调
     * @param clientId 客户端ID
     * @param callback 消息接收回调函数
     */
    fun onMessage(clientId: String, callback: MessageCallbackType) {
        val client = activeClients[clientId]
        client?.onMessage(callback)
    }
    
    /**
     * 通过客户端ID注册错误回调
     * @param clientId 客户端ID
     * @param callback 错误回调函数
     */
    fun onError(clientId: String, callback: ErrorCallbackType) {
        val client = activeClients[clientId]
        client?.onError(callback)
    }
    
    /**
     * 获取所有活跃的客户端ID
     * @return 客户端ID列表
     */
    fun getActiveClients(): List<String> {
        return activeClients.keys.toList()
    }
    
    /**
     * 获取客户端连接状态
     * @param clientId 客户端ID
     * @return 连接状态，如果客户端不存在返回"not_found"
     */
    fun getClientState(clientId: String): String {
        val client = activeClients[clientId]
        return client?.getConnectionState() ?: "not_found"
    }
    
    /**
     * 检查客户端是否存在
     * @param clientId 客户端ID
     * @return 是否存在
     */
    fun clientExists(clientId: String): Boolean {
        return activeClients.containsKey(clientId)
    }
    
    /**
     * 启用客户端心跳
     * @param clientId 客户端ID
     * @param interval 心跳间隔，单位毫秒
     * @param message 心跳消息内容
     */
    fun enableHeartbeat(clientId: String, interval: Int = 30000, message: String = "HEARTBEAT") {
        val client = activeClients[clientId]
        client?.enableHeartbeat(interval, message)
    }
    
    /**
     * 禁用客户端心跳
     * @param clientId 客户端ID
     */
    fun disableHeartbeat(clientId: String) {
        val client = activeClients[clientId]
        client?.disableHeartbeat()
    }
    
    /**
     * 销毁所有客户端实例
     */
    fun destroyAllClients() {
        activeClients.values.forEach { client ->
            client.destroy()
        }
        activeClients.clear()
    }
    
    /**
     * 在全局线程池中执行任务
     * @param task 要执行的任务
     */
    fun executeOnThreadPool(task: Runnable) {
        executorService.execute(task)
    }
    
    /**
     * 在全局调度器中执行定时任务
     * @param task 要执行的任务
     * @param delay 延迟时间（毫秒）
     * @param unit 时间单位
     */
    fun scheduleOnThreadPool(task: Runnable, delay: Long, unit: TimeUnit) {
        scheduledExecutor.schedule(task, delay, unit)
    }
    

    
    /**
     * 在主线程中执行任务
     * @param task 要执行的任务
     */
    fun executeOnMainThread(task: Runnable) {
        mainHandler.post(task)
    }
    
    /**
     * 销毁管理器，释放所有资源
     */
    fun destroy() {
        destroyAllClients()
        executorService.shutdown()
        scheduledExecutor.shutdown()
    }
}

同目录TCPServer.kt

package uts.sdk.modules.redTcp

import java.net.ServerSocket
import java.net.Socket
import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.InputStreamReader
import java.io.OutputStreamWriter
import java.util.concurrent.Executors
import java.util.concurrent.ConcurrentHashMap
import android.util.Log
import android.os.Handler
import android.os.Looper


class TCPServer {
    private var serverSocket: ServerSocket? = null
    private var isRunning = false
    private val clientPool = Executors.newCachedThreadPool()
    private val clients = ConcurrentHashMap<String, ClientHandler>()

    // 🔥 最标准、最稳定、官方插件都这么写
    var onStarted: (() -> Unit)? = null
    var onClientConnected: ((String) -> Unit)? = null
    var onClientDisconnected: ((String) -> Unit)? = null
    var onMessageReceived: ((String, String) -> Unit)? = null
    var onError: ((String) -> Unit)? = null

    fun start(port: Int) {
        if (isRunning) return
        isRunning = true

        Thread {
            try {
                serverSocket = ServerSocket(port)
               Handler(Looper.getMainLooper()).post {
                   onStarted?.invoke()
               }

                while (isRunning) {
                    val clientSocket = serverSocket?.accept()
                    clientSocket?.let {
                        val handler = ClientHandler(it, this)
                        val clientId = (it.inetAddress.hostAddress ?: "unknown") + ":" + it.port
                        clients[clientId] = handler
                        clientPool.execute(handler)
                        Handler(Looper.getMainLooper()).post {
                            onClientConnected?.invoke(clientId)
                        }
                    }
                }
            } catch (e: Exception) {
                onError?.invoke("Server error: ${e.message}")
                isRunning = false
            }
        }.start()
    }

    fun stop() {
        isRunning = false
        serverSocket?.close()
        clients.values.forEach { it.close() }
        clients.clear()
    }

    fun sendToClient(clientId: String, msg: String) {
        clients[clientId]?.send(msg)
    }

    fun broadcast(msg: String) {
        clients.values.forEach { it.send(msg) }
    }

    fun getClientList(): List<String> {
        return ArrayList(clients.keys)
    }

    inner class ClientHandler(
        private val socket: Socket,
        private val server: TCPServer
    ) : Runnable {
        private var writer: BufferedWriter? = null
        private var reader: BufferedReader? = null
        private val clientId = (socket.inetAddress.hostAddress ?: "unknown") + ":" + socket.port

        fun close() {
            try {
                reader?.close()
                writer?.close()
                socket.close()
            } catch (e: Exception) {}
        }

        fun send(msg: String) {
            try {
                writer?.write(msg + "\n")
                writer?.flush()
            } catch (e: Exception) {}
        }

        override fun run() {
            try {
                reader = BufferedReader(InputStreamReader(socket.getInputStream()))
                writer = BufferedWriter(OutputStreamWriter(socket.getOutputStream()))

                val buffer = CharArray(1024)
                var len: Int
                while (socket.isConnected && server.isRunning) {
                    len = reader?.read(buffer) ?: -1
                    if (len == -1) break
                    val msg = String(buffer, 0, len).trim()
                    if (msg.isNotEmpty()) {
                        Handler(Looper.getMainLooper()).post {
                            server.onMessageReceived?.invoke(clientId, msg)
                        }
                    }
                }
            } catch (e: Exception) {
            } finally {
                close()
                clients.remove(clientId)
                Handler(Looper.getMainLooper()).post {
                    onClientDisconnected?.invoke(clientId)
                }
            }
        }
    }
}

同目录 TCPServerManager.kt

package uts.sdk.modules.redTcp

class TCPServerManager {
    companion object {
        val instance = TCPServerManager()
    }

    private var server: TCPServer? = null

    // 🔥 保存回调引用，以便在创建新实例时重新绑定
    private var savedOnStarted: (() -> Unit)? = null
    private var savedOnClientConnected: ((String) -> Unit)? = null
    private var savedOnClientDisconnected: ((String) -> Unit)? = null
    private var savedOnMessageReceived: ((String, String) -> Unit)? = null
    private var savedOnError: ((String) -> Unit)? = null

    fun startServer(port: Int) {
        // 🔥 如果已经存在服务端实例，先停止
        if (server != null) {
            server?.stop()
        }

        // 🔥 创建新实例
        server = TCPServer()

        // 🔥 重新绑定之前保存的回调
        server?.onStarted = savedOnStarted
        server?.onClientConnected = savedOnClientConnected
        server?.onClientDisconnected = savedOnClientDisconnected
        server?.onMessageReceived = savedOnMessageReceived
        server?.onError = savedOnError

        server?.start(port)
    }

    fun stopServer() {
        server?.stop()
        server = null
    }

    fun sendToClient(clientId: String, msg: String) {
        server?.sendToClient(clientId, msg)
    }

    fun broadcast(msg: String) {
        server?.broadcast(msg)
    }

    fun getClients(): List<String> {
        return server?.getClientList() ?: emptyList()
    }

    // 🔥 保存回调引用，不自动创建实例
    fun onStarted(callback: () -> Unit) {
        savedOnStarted = callback
        server?.onStarted = callback
    }

    fun onClientConnected(callback: (String) -> Unit) {
        savedOnClientConnected = callback
        server?.onClientConnected = callback
    }

    fun onClientDisconnected(callback: (String) -> Unit) {
        savedOnClientDisconnected = callback
        server?.onClientDisconnected = callback
    }

    fun onMessageReceived(callback: (String, String) -> Unit) {
        savedOnMessageReceived = callback
        server?.onMessageReceived = callback
    }

    fun onError(callback: (String) -> Unit) {
        savedOnError = callback
        server?.onError = callback
    }
}

---

ios

app-ios目录下index.uts

import {
	CreateTCPClientType,
	ConnectClientType,
	DisconnectClientType,
	DistoryClientType,
	SendMessageType,
	OnConnectedType,
	OnDisconnectedType,
	OnMessageType,
	OnErrorType,
	GetActiveClientsType,
	GetClientStateType,
	ClientExistsType,
	EnableHeartbeatType,
	DisableHeartbeatType,
	ConnectionOptionsType,
	ConnectedCallbackType,
	DisconnectedCallbackType,
	MessageCallbackType,
	ErrorCallbackType,
	TCPResultType
} from '../interface.uts'

/**
 * 创建tcp客户端实例
 * @returns 客户端id
 */
export const createTCPClient : CreateTCPClientType = () : string => {
	return TCPClientManager.shared.createTCPClient()
}

/**
 * 通过客户端id连接到服务器
 * @param clientid 客户端id
 * @param options 连接选项
 */
export const connectClient : ConnectClientType = (clientId : string, options : ConnectionOptionsType) : void => {
	TCPClientManager.shared.connectClient(clientId = clientId, options = options)
}

/**
 * 通过客户端id断开连接
 * @param clientid 客户端id
 */
export const disconnectClient : DisconnectClientType = (clientId : string) : void => {
	TCPClientManager.shared.disconnectClient(clientId = clientId)
}

/**
 * 通过客户端id销毁客户端
 * @param clientid 客户端id
 */
export const distoryClient : DistoryClientType = (clientId : string) : void => {
	TCPClientManager.shared.destroyClient(clientId = clientId)
}

/**
 * 通过客户端id发送消息
 * @param clientid 客户端id
 * @param message 消息内容
 */
export const sendMessage : SendMessageType = (clientId : string, message : string) : void => {
	TCPClientManager.shared.sendMessage(clientId = clientId, message = message)
}

/**
 * 注册连接成功回调
 * @param clientid 客户端id
 * @param callback 连接成功回调函数
 */
@UTSJS.keepAlive
export function onConnected(clientId : string, callback : ConnectedCallbackType) : void {
	TCPClientManager.shared.onConnected(clientId = clientId, callback = callback)
}

/**
 * 注册断开连接回调
 * @param clientid 客户端id
 * @param callback 断开连接回调函数
 */
@UTSJS.keepAlive
export function onDisconnected(clientId : string, callback : DisconnectedCallbackType) : void {
	TCPClientManager.shared.onDisconnected(clientId = clientId, callback = callback)
}

/**
 * 注册消息接收回调
 * @param clientid 客户端id
 * @param callback 消息接收回调函数
 */
@UTSJS.keepAlive
export function onMessage(clientId : string, callback : MessageCallbackType) : void {
	TCPClientManager.shared.onMessage(clientId = clientId, callback = callback)
}

/**
 * 注册错误回调
 * @param clientid 客户端id
 * @param callback 错误回调函数
 */
@UTSJS.keepAlive
export function onError(clientId : string, callback : ErrorCallbackType) : void {
	TCPClientManager.shared.onError(clientId = clientId, callback = callback)
}

/**
 * 获取所有活跃的客户端实例
 */
export const getActiveClients : GetActiveClientsType = () : string[] => {
	// 将Array<string>转换为UTSArray<string>
	const clientList = TCPClientManager.shared.getActiveClients()
	const clientArray : string[] = []
	for (let i = 0; i < clientList.length; i++) {
		clientArray.push(clientList[i])
	}
	return clientArray
}

/**
 * 获取客户端连接状态
 * @param clientId 客户端ID
 */
export const getClientState : GetClientStateType = (clientId : string) : string => {
	return TCPClientManager.shared.getClientState(clientId = clientId)
}

/**
 * 检查客户端是否存在
 * @param clientId 客户端ID
 */
export const clientExists : ClientExistsType = (clientId : string) : boolean => {
	return TCPClientManager.shared.clientExists(clientId = clientId)
}

/**
 * 启用心跳
 * @param clientId 客户端ID
 * @param interval 心跳间隔，单位毫秒
 * @param message 心跳消息内容
 */
export const enableHeartbeat : EnableHeartbeatType = (clientId : string, interval ?: number, message ?: string) : void => {
	const heartbeatInterval : number = interval ?? 30000
	const heartbeatMessage = message ?? "HEARTBEAT"
	TCPClientManager.shared.enableHeartbeat(clientId = clientId, interval = heartbeatInterval.toInt(), message = heartbeatMessage)
}

/**
 * 禁用心跳
 * @param clientId 客户端ID
 */
export const disableHeartbeat : DisableHeartbeatType = (clientId : string) : void => {
	TCPClientManager.shared.disableHeartbeat(clientId = clientId)
}

// ==============================
// 下面全部是 追加 的服务端接口
// ==============================
import TCPServerManager from "uts.sdk.modules.redTcp.TCPServerManager"

export const startServer: StartServerType = (port: number): void => {
	TCPServerManager.shared.startServer(port: port.toInt())
}

export const stopServer: StopServerType = (): void => {
	TCPServerManager.shared.stopServer()
}

export const sendToClient: SendToClientType = (clientId: string, msg: string): void => {
	TCPServerManager.shared.sendToClient(clientId: clientId, msg: msg)
}

export const broadcast: BroadcastType = (msg: string): void => {
	TCPServerManager.shared.broadcast(msg: msg)
}

export const getClients: GetClientsType = (): string[] => {
	return Array.from(TCPServerManager.shared.getClients()) as string[]
}

@UTSJS.keepAlive
export const onServerStarted: OnServerStartedType = (callback: () => void): void => {
	TCPServerManager.shared.onStarted(callback: callback)
}

@UTSJS.keepAlive
export const onClientConnected: OnClientConnectedType = (callback: (String) => void): void => {
	TCPServerManager.shared.onClientConnected(callback: callback)
}

@UTSJS.keepAlive
export const onClientDisconnected: OnClientDisconnectedType = (callback: (String) => void): void => {
	TCPServerManager.shared.onClientDisconnected(callback: callback)
}

@UTSJS.keepAlive
export const onServerMessage: OnServerMessageType = (callback: (String, String) => void): void => {
	TCPServerManager.shared.onMessageReceived(callback: callback)
}

@UTSJS.keepAlive
export const onServerError: OnServerErrorType = (callback: (String) => void): void => {
	TCPServerManager.shared.onError(callback: callback)
}

同目录TCPClient.swift

import DCloudUTSFoundation
import Foundation
import Network

/**
 * 从interface.uts导入的类型
 */

/**
 * ios平台tcp客户端实现类
 */
class TCPClient {
    
    // 客户端ID
    private let clientId: String
    
    // 连接状态
    private var connectionState: String = "disconnected"
    
    // 网络连接相关
    private var connection: NWConnection?
    private var queue: DispatchQueue
    
    // 回调函数
    private var connectedCallback: ConnectedCallbackType?
    private var disconnectedCallback: DisconnectedCallbackType?
    private var messageCallback: MessageCallbackType?
    private var errorCallback: ErrorCallbackType?
    
    // 连接配置
    private var connectionOptions: ConnectionOptionsType?
    
    // 心跳相关
    private var heartbeatTimer: Timer?
    private var heartbeatEnabled: Bool = false
    private var heartbeatInterval: TimeInterval = 30.0
    private var heartbeatMessage: String = "HEARTBEAT"
    
    // 线程管理器引用
    private let threadManager = TCPClientManager.shared
    
    init(clientId: String) {
        self.clientId = clientId
        self.queue = DispatchQueue(label: "com.ohyes.tcp.client.\(clientId)")
    }
    
    /**
     * 连接到服务器
     */
    func connect(options: ConnectionOptionsType) {
        guard connectionState == "disconnected" else {
            notifyError(TCPResultType(UTSJSONObject([
                "code": 1,
                "error": "Client is not disconnected"
            ])))
            return
        }
        
        connectionOptions = options
        connectionState = "connecting"
        
        // 设置心跳配置
        if options.enableHeartbeat {
            heartbeatEnabled = true
            if let interval = options.heartbeatInterval {
                heartbeatInterval = TimeInterval(interval.doubleValue) / 1000.0 // 转换为秒
            }
            if let message = options.heartbeatMessage {
                heartbeatMessage = message
            }
        }
        
        guard let host = connectionOptions?.serverHost,
              let port = connectionOptions?.serverPort else {
            connectionState = "disconnected"
            notifyError(TCPResultType(UTSJSONObject([
                "code": 2,
                "error": "Invalid host or port"
            ])))
            return
        }
        
        let nwHost = NWEndpoint.Host(host)
        let nwPort = NWEndpoint.Port(rawValue: UInt16(truncating: port))!
        
        let tcpOptions = NWProtocolTCP.Options()
        tcpOptions.enableKeepalive = true
        tcpOptions.keepaliveIdle = 2
        
        connection = NWConnection(
            host: nwHost,
            port: nwPort,
            using: .tcp
        )
        
        connection?.stateUpdateHandler = { [weak self] newState in
            guard let self = self else { return }
            
            switch newState {
            case .ready:
                self.connectionState = "connected"
                
                // 启动消息接收
                self.startMessageReceiver()
                
                // 启动心跳
                self.startHeartbeat()
                
                // 通知连接成功
                self.notifyConnected(TCPResultType(UTSJSONObject([
                    "code": 0,
                    "data": "Connected successfully"
                ])))
                
            case .failed(let error):
                self.connectionState = "disconnected"
                self.notifyError(TCPResultType(UTSJSONObject([
                    "code": 3,
                    "error": error.localizedDescription
                ])))
                
            case .cancelled:
                self.connectionState = "disconnected"
                self.notifyDisconnected(TCPResultType(UTSJSONObject([
                    "code": 0,
                    "data": "Connection cancelled"
                ])))
                
            case .waiting(let error):
                self.connectionState = "disconnected"
                self.notifyError(TCPResultType(UTSJSONObject([
                    "code": 4,
                    "error": error.localizedDescription
                ])))
                
            case .setup:
                 self.connectionState = "connecting"
                
            @unknown default:
                break
            }
        }
        
        connection?.start(queue: queue)
    }
    
    /**
     * 断开连接
     */
    func disconnect() {
        guard connectionState != "disconnected" && connectionState != "disconnecting" else {
            return
        }
        
        connectionState = "disconnecting"
        
        // 停止心跳
        stopHeartbeat()
        
        // 安全地关闭连接
        if let conn = connection {
            conn.cancel()
            connection = nil
        }
        
        connectionState = "disconnected"
        notifyDisconnected(TCPResultType(UTSJSONObject([
            "code": 0,
            "data": "Disconnected successfully"
        ])))
    }
    
    /**
     * 发送消息
     */
    func sendMessage(_ message: String) {
        guard connectionState == "connected" else {
            notifyError(TCPResultType(UTSJSONObject([
                "code": 5,
                "error": "Client is not connected"
            ])))
            return
        }
        
//         guard let data = message.data(using: .utf8) else {
//             notifyError(TCPResultType(UTSJSONObject([
//                 "code": 6,
//                 "error": "Failed to encode message"
//             ])))
//             return
//         }

        let messageWithNewline = message.hasSuffix("\n") ? message : message + "\n"
                guard let data = messageWithNewline.data(using: .utf8) else {
                    notifyError(TCPResultType(UTSJSONObject([
                        "code": 6,
                        "error": "Failed to encode message"
                    ])))
                    return
                }
        
        connection?.send(
            content: data,
            completion: .contentProcessed({ [weak self] error in
                if let error = error {
                    self?.notifyError(TCPResultType(UTSJSONObject([
                        "code": 7,
                        "error": error.localizedDescription
                    ])))
                }
            })
        )
    }
    
    /**
     * 获取连接状态
     */
    func getConnectionState() -> String {
        return connectionState
    }
    
    /**
     * 销毁客户端实例
     */
    func destroy() {
        disconnect()
    }
    
    /**
     * 注册连接成功回调
     */
    func onConnected(callback: @escaping ConnectedCallbackType) {
        connectedCallback = callback
    }
    
    /**
     * 注册断开连接回调
     */
    func onDisconnected(callback: @escaping DisconnectedCallbackType) {
        disconnectedCallback = callback
    }
    
    /**
     * 注册消息接收回调
     */
    func onMessage(callback: @escaping MessageCallbackType) {
        messageCallback = callback
    }
    
    /**
     * 注册错误回调
     */
    func onError(callback: @escaping ErrorCallbackType) {
        errorCallback = callback
    }
    
    /**
     * 启用心跳
     */
    func enableHeartbeat(interval: Int = 30000, message: String = "HEARTBEAT") {
        heartbeatEnabled = true
        heartbeatInterval = TimeInterval(interval) / 1000.0
        heartbeatMessage = message
        
        // 如果已连接，立即启动心跳
        if connectionState == "connected" {
            startHeartbeat()
        }
    }
    
    /**
     * 禁用心跳
     */
    func disableHeartbeat() {
        heartbeatEnabled = false
        stopHeartbeat()
    }
    
    /**
     * 启动消息接收
     */
     private var messageBuffer: Data = Data()
    private func startMessageReceiver() {
            // 确保只在连接状态下接收消息
            guard connectionState == "connected" else { return }

            connection?.receive(minimumIncompleteLength: 1, maximumLength: 65536) { [weak self] (data, context, isComplete, error) in
                guard let self = self else { return }

                if let data = data, !data.isEmpty {
                    // 🔥 将新数据添加到缓冲区
                    self.messageBuffer.append(data)

                    // 🔥 尝试从缓冲区中提取完整的消息（以换行符分隔）
                    while let newlineRange = self.messageBuffer.range(of: Data([0x0A])) { // 0x0A 是 \n
                        let messageData = self.messageBuffer.subdata(in: self.messageBuffer.startIndex..<newlineRange.lowerBound)

                        // 移除已处理的数据（包括换行符）
                        self.messageBuffer.removeSubrange(self.messageBuffer.startIndex..<newlineRange.upperBound)

                        // 转换为字符串
                        if let message = String(data: messageData, encoding: .utf8) {
                            let trimmedMessage = message.trimmingCharacters(in: .whitespacesAndNewlines)
                            if !trimmedMessage.isEmpty {
                                self.notifyMessage(trimmedMessage)
                            }
                        }
                    }
                }

                if isComplete {
                    // 服务器关闭了连接
                    if self.connectionState == "connected" {
                        self.connectionState = "disconnected"
                        self.stopHeartbeat()
                        self.notifyDisconnected(TCPResultType(UTSJSONObject([
                            "code": 0,
                            "data": "Server closed the connection"
                        ])))
                    }
                    return
                }

                if let error = error {
                    if self.connectionState == "connected" {
                        self.connectionState = "disconnected"
                        self.stopHeartbeat()
                        self.notifyError(TCPResultType(UTSJSONObject([
                            "code": 9,
                            "error": error.localizedDescription
                        ])))
                    }
                    return
                }

                // 继续接收下一条消息，但要再次检查连接状态
                if self.connectionState == "connected" {
                    self.startMessageReceiver()
                }
            }
        }
    
    /**
     * 启动心跳
     */
    private func startHeartbeat() {
        guard heartbeatEnabled && connectionState == "connected" else {
            return
        }
        
        // 停止之前的心跳
        stopHeartbeat()
        
        // 在主线程创建定时器
        DispatchQueue.main.async { [weak self] in
            guard let self = self else { return }
            
            self.heartbeatTimer = Timer.scheduledTimer(withTimeInterval: self.heartbeatInterval, repeats: true) { [weak self] _ in
                guard let self = self else { return }
                
                // 检查心跳是否仍然启用且连接正常
                if self.heartbeatEnabled && self.connectionState == "connected" {
                    self.sendHeartbeat()
                } else {
                    self.stopHeartbeat()
                }
            }
        }
    }
    
    /**
     * 发送心跳消息
     */
    private func sendHeartbeat() {
        guard heartbeatEnabled && connectionState == "connected" else { return }
        
        guard let data = (heartbeatMessage + "\n").data(using: .utf8) else { return }  // 添加换行符确保消息完整
        
        connection?.send(
            content: data,
            completion: .contentProcessed({ error in
                // 心跳发送失败不需要特殊处理，让正常的错误处理机制处理
            })
        )
    }
    
    /**
     * 停止心跳
     */
    private func stopHeartbeat() {
        heartbeatTimer?.invalidate()
        heartbeatTimer = nil
    }
    

    
    /**
     * 通知连接成功
     */
    private func notifyConnected(_ result: TCPResultType) {
        threadManager.executeOnMainThread {
            self.connectedCallback?(self.clientId, result)
        }
    }
    
    /**
     * 通知断开连接
     */
    private func notifyDisconnected(_ result: TCPResultType) {
        threadManager.executeOnMainThread {
            self.disconnectedCallback?(self.clientId, result)
        }
    }
    
    /**
     * 通知接收到消息
     */
    private func notifyMessage(_ message: String) {
        threadManager.executeOnMainThread {
            self.messageCallback?(self.clientId, message)
        }
    }
    
    /**
     * 通知错误
     */
    private func notifyError(_ result: TCPResultType) {
        threadManager.executeOnMainThread {
            self.errorCallback?(self.clientId, result)
        }
    }
}

同目录TCPClientManager.swift

import Foundation

/**
 * 从interface.uts导入的类型
 */

/// TCP客户端管理器
/// 负责统一管理所有TCP客户端实例和线程资源
/// 使用单例模式
class TCPClientManager {

    // 使用单例模式
    static let shared = TCPClientManager()

    // 私有初始化方法
    private init() {}

    // 存储所有活跃的客户端实例
    private var activeClients: [String: TCPClient] = [:]

    // 线程安全锁
    private let lock = NSLock()

    // 全局队列，用于所有TCP客户端的异步操作
    private let globalQueue = DispatchQueue(
        label: "com.ohyes.tcp.global", qos: .userInitiated, attributes: .concurrent)

    // 主线程队列，用于回调
    private let mainQueue = DispatchQueue.main

    /**
     * 创建TCP客户端实例
     * @return 客户端ID
     */
    func createTCPClient() -> String {
        lock.lock()
        defer { lock.unlock() }

        let clientId = "client_\(Date().timeIntervalSince1970)_\(Int.random(in: 100000...999999))"
        let client = TCPClient(clientId: clientId)
        activeClients[clientId] = client
        return clientId
    }

    /**
     * 通过客户端ID获取TCP客户端实例
     * @param clientId 客户端ID
     * @return TCP客户端实例，如果不存在则返回nil
     */
    func getTCPClient(clientId: String) -> TCPClient? {
        lock.lock()
        defer { lock.unlock() }

        return activeClients[clientId]
    }

    /**
     * 通过客户端ID连接到服务器
     * @param clientId 客户端ID
     * @param options 连接选项
     */
    func connectClient(clientId: String, options: ConnectionOptionsType) {
        lock.lock()
        defer { lock.unlock() }

        if let client = activeClients[clientId] {
            client.connect(options: options)
        }
    }

    /**
     * 通过客户端ID断开连接
     * @param clientId 客户端ID
     */
    func disconnectClient(clientId: String) {
        lock.lock()
        defer { lock.unlock() }

        let client = activeClients[clientId]
        client?.disconnect()
    }

    /**
     * 通过客户端ID销毁客户端
     * @param clientId 客户端ID
     */
    func destroyClient(clientId: String) {
        lock.lock()
        defer { lock.unlock() }

        if let client = activeClients[clientId] {
            client.destroy()
            activeClients.removeValue(forKey: clientId)
        }
    }

    /**
     * 通过客户端ID发送消息
     * @param clientId 客户端ID
     * @param message 消息内容
     */
    func sendMessage(clientId: String, message: String) {
        lock.lock()
        defer { lock.unlock() }

        if let client = activeClients[clientId], !message.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
            client.sendMessage(message)
        }
    }

    /**
     * 通过客户端ID注册连接成功回调
     * @param clientId 客户端ID
     * @param callback 连接成功回调函数
     */
    func onConnected(clientId: String, callback: @escaping ConnectedCallbackType) {
        lock.lock()
        defer { lock.unlock() }

        let client = activeClients[clientId]
        client?.onConnected(callback: callback)
    }

    /**
     * 通过客户端ID注册断开连接回调
     * @param clientId 客户端ID
     * @param callback 断开连接回调函数
     */
    func onDisconnected(clientId: String, callback: @escaping DisconnectedCallbackType) {
        lock.lock()
        defer { lock.unlock() }

        let client = activeClients[clientId]
        client?.onDisconnected(callback: callback)
    }

    /**
     * 通过客户端ID注册消息接收回调
     * @param clientId 客户端ID
     * @param callback 消息接收回调函数
     */
    func onMessage(clientId: String, callback: @escaping MessageCallbackType) {
        lock.lock()
        defer { lock.unlock() }

        let client = activeClients[clientId]
        client?.onMessage(callback: callback)
    }

    /**
     * 通过客户端ID注册错误回调
     * @param clientId 客户端ID
     * @param callback 错误回调函数
     */
    func onError(clientId: String, callback: @escaping ErrorCallbackType) {
        lock.lock()
        defer { lock.unlock() }

        let client = activeClients[clientId]
        client?.onError(callback: callback)
    }

    /**
     * 获取所有活跃的客户端ID
     * @return 客户端ID列表
     */
    func getActiveClients() -> [String] {
        lock.lock()
        defer { lock.unlock() }

        return Array(activeClients.keys)
    }
    
    /**
     * 获取客户端连接状态
     * @param clientId 客户端ID
     * @return 连接状态，如果客户端不存在返回"not_found"
     */
    func getClientState(clientId: String) -> String {
        lock.lock()
        defer { lock.unlock() }
        
        if let client = activeClients[clientId] {
            return client.getConnectionState()
        }
        return "not_found"
    }
    
    /**
     * 检查客户端是否存在
     * @param clientId 客户端ID
     * @return 是否存在
     */
    func clientExists(clientId: String) -> Bool {
        lock.lock()
        defer { lock.unlock() }
        
        return activeClients[clientId] != nil
    }
    
    /**
     * 启用客户端心跳
     * @param clientId 客户端ID
     * @param interval 心跳间隔，单位毫秒
     * @param message 心跳消息内容
     */
    func enableHeartbeat(clientId: String, interval: Int = 30000, message: String = "HEARTBEAT") {
        lock.lock()
        defer { lock.unlock() }
        
        if let client = activeClients[clientId] {
            client.enableHeartbeat(interval: interval, message: message)
        }
    }
    
    /**
     * 禁用客户端心跳
     * @param clientId 客户端ID
     */
    func disableHeartbeat(clientId: String) {
        lock.lock()
        defer { lock.unlock() }
        
        if let client = activeClients[clientId] {
            client.disableHeartbeat()
        }
    }

    /**
     * 销毁所有客户端实例
     */
    func destroyAllClients() {
        lock.lock()
        defer { lock.unlock() }

        for (_, client) in activeClients {
            client.destroy()
        }
        activeClients.removeAll()
    }

    /**
     * 在全局队列中执行任务
     * @param task 要执行的任务
     */
    func executeOnGlobalQueue(_ task: @escaping () -> Void) {
        globalQueue.async(execute: task)
    }

    /**
     * 在全局队列中执行延迟任务
     * @param task 要执行的任务
     * @param delay 延迟时间（秒）
     */
    func executeOnGlobalQueueAfterDelay(_ task: @escaping () -> Void, delay: TimeInterval) {
        globalQueue.asyncAfter(deadline: .now() + delay, execute: task)
    }

    /**
     * 在主线程中执行任务
     * @param task 要执行的任务
     */
    func executeOnMainThread(_ task: @escaping () -> Void) {
        mainQueue.async(execute: task)
    }

    /**
     * 销毁管理器，释放所有资源
     */
    func destroy() {
        lock.lock()
        defer { lock.unlock() }

        for (_, client) in activeClients {
            client.destroy()
        }
        activeClients.removeAll()
    }
}

同目录TCPServer.swift

import Foundation
import Network

class TCPServer {

    // 回调函数
    var onStarted: (() -> Void)?
    var onClientConnected: ((String) -> Void)?
    var onClientDisconnected: ((String) -> Void)?
    var onMessageReceived: ((String, String) -> Void)?
    var onError: ((String) -> Void)?

    // 服务相关
    private var listener: NWListener?
    private var isRunning: Bool = false
    private var clients: [String: TCPClientHandler] = [:]
    private let queue = DispatchQueue(label: "com.ohyes.tcp.server")

    // 启动服务
    func start(port: Int) {
        guard !isRunning else { return }

        do {
            let nwPort = NWEndpoint.Port(rawValue: UInt16(port))!
            let parameters = NWParameters.tcp
            listener = try NWListener(using: parameters, on: nwPort)

            listener?.stateUpdateHandler = { [weak self] state in
                switch state {
                case .ready:
                    self?.isRunning = true
                    DispatchQueue.main.async {
                        self?.onStarted?()
                    }

                case .failed(let error):
                    self?.isRunning = false
                    DispatchQueue.main.async {
                        self?.onError?("Listener failed: \(error.localizedDescription)")
                    }

                case .cancelled:
                    self?.isRunning = false

                default:
                    break
                }
            }

            listener?.newConnectionHandler = { [weak self] connection in
                self?.handleNewConnection(connection)
            }

            listener?.start(queue: queue)

        } catch {
            isRunning = false
            DispatchQueue.main.async {
                self.onError?("Failed to start server: \(error.localizedDescription)")
            }
        }
    }

    // 停止服务
    func stop() {
        isRunning = false
        listener?.cancel()
        listener = nil

        // 关闭所有客户端连接
        clients.values.forEach { $0.close() }
        clients.removeAll()
    }

    // 发送消息给指定客户端
    func sendToClient(clientId: String, msg: String) {
        clients[clientId]?.send(message: msg)
    }

    // 广播消息
    func broadcast(msg: String) {
        clients.values.forEach { $0.send(message: msg) }
    }

    // 获取客户端列表
    func getClientList() -> [String] {
        return Array(clients.keys)
    }

    // 处理新连接
    private func handleNewConnection(_ connection: NWConnection) {
            // 🔥 改进：更友好的 Client ID 格式
            let host = connection.endpoint.host.debugDescription.replacingOccurrences(of: "\"", with: "")
            let port = connection.endpoint.port?.rawValue ?? 0
            let clientId = "\(host):\(port)"

            let handler = TCPClientHandler(connection: connection, clientId: clientId, server: self)

            clients[clientId] = handler

            // 🔥 重要：必须先启动连接，再开始接收消息
            connection.start(queue: queue)
            handler.start()

            DispatchQueue.main.async {
                self.onClientConnected?(clientId)
            }
        }

    // 客户端断开处理
    func clientDisconnected(clientId: String) {
        clients.removeValue(forKey: clientId)
        DispatchQueue.main.async {
            self.onClientDisconnected?(clientId)
        }
    }

    // 收到消息处理
    func messageReceived(clientId: String, message: String) {
        DispatchQueue.main.async {
            self.onMessageReceived?(clientId, message)
        }
    }
}

// 客户端处理器
class TCPClientHandler {
    private let connection: NWConnection
    private let clientId: String
    private weak var server: TCPServer?
    private var messageBuffer: Data = Data()

    init(connection: NWConnection, clientId: String, server: TCPServer) {
        self.connection = connection
        self.clientId = clientId
        self.server = server
    }

    func start() {
        receiveMessage()
    }

    func close() {
        connection.cancel()
    }

    func send(message: String) {
        let messageWithNewline = message.hasSuffix("\n") ? message : message + "\n"
        guard let data = messageWithNewline.data(using: .utf8) else { return }

        connection.send(content: data, completion: .contentProcessed { error in
            if let error = error {
                print("Send error: \(error.localizedDescription)")
            }
        })
    }

    private func receiveMessage() {
        connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { [weak self] data, context, isComplete, error in
            guard let self = self else { return }

            if let data = data, !data.isEmpty {
                self.messageBuffer.append(data)

                // 按换行符分割消息
                while let newlineRange = self.messageBuffer.range(of: Data([0x0A])) {
                    let messageData = self.messageBuffer.subdata(in: self.messageBuffer.startIndex..<newlineRange.lowerBound)
                    self.messageBuffer.removeSubrange(self.messageBuffer.startIndex..<newlineRange.upperBound)

                    if let message = String(data: messageData, encoding: .utf8) {
                        let trimmedMessage = message.trimmingCharacters(in: .whitespacesAndNewlines)
                        if !trimmedMessage.isEmpty {
                            self.server?.messageReceived(clientId: self.clientId, message: trimmedMessage)
                        }
                    }
                }
            }

            if isComplete {
                self.server?.clientDisconnected(clientId: self.clientId)
                return
            }

            if let error = error {
                print("Receive error: \(error.localizedDescription)")
                self.server?.clientDisconnected(clientId: self.clientId)
                return
            }

            // 继续接收
            self.receiveMessage()
        }
    }
}

同目录TCPServerManager.swift

import Foundation

class TCPServerManager {

    static let shared = TCPServerManager()

    private var server: TCPServer?

    // 保存回调引用
    private var savedOnStarted: (() -> Void)?
    private var savedOnClientConnected: ((String) -> Void)?
    private var savedOnClientDisconnected: ((String) -> Void)?
    private var savedOnMessageReceived: ((String, String) -> Void)?
    private var savedOnError: ((String) -> Void)?

    private init() {}

    func startServer(port: Int) {
        // 如果已存在，先停止
        if server != nil {
            server?.stop()
        }

        // 创建新实例
        server = TCPServer()

        // 重新绑定回调
        server?.onStarted = savedOnStarted
        server?.onClientConnected = savedOnClientConnected
        server?.onClientDisconnected = savedOnClientDisconnected
        server?.onMessageReceived = savedOnMessageReceived
        server?.onError = savedOnError

        server?.start(port: port)
    }

    func stopServer() {
        server?.stop()
        server = nil
    }

    func sendToClient(clientId: String, msg: String) {
        server?.sendToClient(clientId: clientId, msg: msg)
    }

    func broadcast(msg: String) {
        server?.broadcast(msg: msg)
    }

    func getClients() -> [String] {
        return server?.getClientList() ?? []
    }

    func onStarted(callback: @escaping () -> Void) {
        savedOnStarted = callback
        server?.onStarted = callback
    }

    func onClientConnected(callback: @escaping (String) -> Void) {
        savedOnClientConnected = callback
        server?.onClientConnected = callback
    }

    func onClientDisconnected(callback: @escaping (String) -> Void) {
        savedOnClientDisconnected = callback
        server?.onClientDisconnected = callback
    }

    func onMessageReceived(callback: @escaping (String, String) -> Void) {
        savedOnMessageReceived = callback
        server?.onMessageReceived = callback
    }

    func onError(callback: @escaping (String) -> Void) {
        savedOnError = callback
        server?.onError = callback
    }
}

---

鸿蒙

app-harmony目录下index.uts

import {
	CreateTCPClientType,
	ConnectClientType,
	DisconnectClientType,
	DistoryClientType,
	SendMessageType,
	OnConnectedType,
	OnDisconnectedType,
	OnMessageType,
	OnErrorType,
	GetActiveClientsType,
	GetClientStateType,
	ClientExistsType,
	EnableHeartbeatType,
	DisableHeartbeatType,
	ConnectionOptionsType,
	ConnectedCallbackType,
	DisconnectedCallbackType,
	MessageCallbackType,
	ErrorCallbackType,
	TCPResultType,
} from '../interface.uts'

// 鸿蒙唯一正确引入方式（相对路径）
import TCPClientManager from "./TCPClientManager.ets"

// ====================== 以下代码 100% 不用动 ======================
export const createTCPClient : CreateTCPClientType = () : string => {
	return TCPClientManager.createTCPClient()
}

export const connectClient : ConnectClientType = (clientId : string, options : ConnectionOptionsType) : void => {
	TCPClientManager.connectClient(clientId, options)
}

export const disconnectClient : DisconnectClientType = (clientId : string) : void => {
	TCPClientManager.disconnectClient(clientId)
}

export const distoryClient : DistoryClientType = (clientId : string) : void => {
	TCPClientManager.destroyClient(clientId)
}

export const sendMessage : SendMessageType = (clientId : string, message : string) : void => {
	TCPClientManager.sendMessage(clientId, message)
}

@UTSJS.keepAlive
export function onConnected(clientId : string, callback : ConnectedCallbackType) : void {
	TCPClientManager.onConnected(clientId, callback)
}

@UTSJS.keepAlive
export function onDisconnected(clientId : string, callback : DisconnectedCallbackType) : void {
	TCPClientManager.onDisconnected(clientId, callback)
}

@UTSJS.keepAlive
export function onMessage(clientId : string, callback : MessageCallbackType) : void {
	TCPClientManager.onMessage(clientId, callback)
}

@UTSJS.keepAlive
export function onError(clientId : string, callback : ErrorCallbackType) : void {
	TCPClientManager.onError(clientId, callback)
}

export const getActiveClients : GetActiveClientsType = () : string[] => {
	return TCPClientManager.getActiveClients()
}

export const getClientState : GetClientStateType = (clientId : string) : string => {
	return TCPClientManager.getClientState(clientId)
}

export const clientExists : ClientExistsType = (clientId : string) : boolean => {
	return TCPClientManager.clientExists(clientId)
}

export const enableHeartbeat : EnableHeartbeatType = (clientId : string, interval ?: number, message ?: string) : void => {
	const heartbeatInterval = interval ?? 30000
	const heartbeatMessage = message ?? "HEARTBEAT"
	TCPClientManager.enableHeartbeat(clientId, heartbeatInterval, heartbeatMessage)
}

export const disableHeartbeat : DisableHeartbeatType = (clientId : string) : void => {
	TCPClientManager.disableHeartbeat(clientId)
}

// ==============================
// 下面全部是 追加 的服务端接口
// ==============================
import {TCPServer} from "./TCPServer.ets"

// 服务端单例
let tcpServer: TCPServer | null = null;

// 保存回调引用
let savedOnStarted: (() => void) | null = null;
let savedOnClientConnected: ((clientId: string) => void) | null = null;
let savedOnClientDisconnected: ((clientId: string) => void) | null = null;
let savedOnMessageReceived: ((clientId: string, msg: string) => void) | null = null;
let savedOnError: ((msg: string) => void) | null = null;

export const startServer: StartServerType = (port: number): void => {
    // 如果已存在，先停止
    if (tcpServer != null) {
        tcpServer.stop();
    }

    // 创建新实例
    tcpServer = new TCPServer();

    // 重新绑定回调
    tcpServer.onStarted = savedOnStarted;
    tcpServer.onClientConnected = savedOnClientConnected;
    tcpServer.onClientDisconnected = savedOnClientDisconnected;
    tcpServer.onMessageReceived = savedOnMessageReceived;
    tcpServer.onError = savedOnError;

    tcpServer.start(port);
}

export const stopServer: StopServerType = (): void => {
    if (tcpServer) {
        tcpServer.stop();
        tcpServer = null;
    }
}

export const sendToClient: SendToClientType = (clientId: string, msg: string): void => {
    if (tcpServer) {
        tcpServer.sendToClient(clientId, msg);
    }
}

export const broadcast: BroadcastType = (msg: string): void => {
    if (tcpServer) {
        tcpServer.broadcast(msg);
    }
}

export const getClients: GetClientsType = (): string[] => {
    if (tcpServer) {
        return tcpServer.getClientList();
    }
    return [];
}

@UTSJS.keepAlive
export const onServerStarted: OnServerStartedType = (callback: () => void): void => {
    savedOnStarted = callback;
    if (tcpServer) {
        tcpServer.onStarted = callback;
    }
}

@UTSJS.keepAlive
export const onClientConnected: OnClientConnectedType = (callback: (String) => void): void => {
    savedOnClientConnected = callback;
    if (tcpServer) {
        tcpServer.onClientConnected = callback;
    }
}

@UTSJS.keepAlive
export const onClientDisconnected: OnClientDisconnectedType = (callback: (String) => void): void => {
    savedOnClientDisconnected = callback;
    if (tcpServer) {
        tcpServer.onClientDisconnected = callback;
    }
}

@UTSJS.keepAlive
export const onServerMessage: OnServerMessageType = (callback: (String, String) => void): void => {
    savedOnMessageReceived = callback;
    if (tcpServer) {
        tcpServer.onMessageReceived = callback;
    }
}

@UTSJS.keepAlive
export const onServerError: OnServerErrorType = (callback: (String) => void): void => {
    savedOnError = callback;
    if (tcpServer) {
        tcpServer.onError = callback;
    }
}

####同目录TCPClient.ets

package uts.sdk.modules.redTcp

import tcp from '@ohos.net.tcp';
import util from '@ohos.util';

// 回调类型定义
type ConnectedCallbackType = (clientId: string, result: TCPResultType) => void;
type DisconnectedCallbackType = (clientId: string, result: TCPResultType) => void;
type MessageCallbackType = (clientId: string, message: string) => void;
type ErrorCallbackType = (clientId: string, result: TCPResultType) => void;

// TCP 结果
export class TCPResultType {
    code: number = 0;
    data?: string;
    error?: string;

    constructor(obj?: Partial<TCPResultType>) {
        if (obj) {
            this.code = obj.code ?? 0;
            this.data = obj.data;
            this.error = obj.error;
        }
    }
}

// 连接配置
export interface ConnectionOptionsType {
    serverHost: string;
    serverPort: number;
    timeout?: number;
    enableHeartbeat?: boolean;
    heartbeatInterval?: number;
    heartbeatMessage?: string;
}

export class TCPClient {
    private clientId: string;
    private connectionState: string = "disconnected";

    // Socket
    private socket: tcp.TCPSocket | null = null;
    private options: ConnectionOptionsType | null = null;

    // 回调
    private connectedCallback: ConnectedCallbackType | null = null;
    private disconnectedCallback: DisconnectedCallbackType | null = null;
    private messageCallback: MessageCallbackType | null = null;
    private errorCallback: ErrorCallbackType | null = null;

    // 心跳
    private heartbeatEnabled: boolean = false;
    private heartbeatInterval: number = 30000;
    private heartbeatMessage: string = "HEARTBEAT";
    private heartbeatTimer: number | null = null;

    constructor(clientId: string) {
        this.clientId = clientId;
    }

    // 连接服务器
    connect(options: ConnectionOptionsType): void {
        if (this.connectionState !== "disconnected") {
            this.notifyError(new TCPResultType({ code: 1, error: "Client is not disconnected" }));
            return;
        }

        this.options = options;
        this.connectionState = "connecting";

        if (options.enableHeartbeat) {
            this.heartbeatEnabled = true;
            this.heartbeatInterval = options.heartbeatInterval ?? 30000;
            this.heartbeatMessage = options.heartbeatMessage ?? "HEARTBEAT";
        }

        this.socket = tcp.createTCPSocket();

        // 连接成功
        this.socket.on("connect", () => {
            this.connectionState = "connected";
            this.startMessageReceiver();
            this.startHeartbeat();
            this.notifyConnected(new TCPResultType({ code: 0, data: "Connected successfully" }));
        });

        // 连接关闭
        this.socket.on("close", () => {
            if (this.connectionState === "connected") {
                this.connectionState = "disconnected";
                this.stopHeartbeat();
                this.notifyDisconnected(new TCPResultType({ code: 0, data: "Server closed the connection" }));
            }
        });

        // 错误
        this.socket.on("error", (err) => {
            this.connectionState = "disconnected";
            this.notifyError(new TCPResultType({ code: 3, error: err.message || "Connection error" }));
        });

        // 执行连接
        this.socket.connect({
            address: options.serverHost,
            port: options.serverPort,
            timeout: options.timeout ?? 5000
        });
    }

    // 断开连接
    disconnect(): void {
        if (this.connectionState === "disconnected" || this.connectionState === "disconnecting") return;

        this.connectionState = "disconnecting";
        this.stopHeartbeat();

        try {
            if (this.socket) {
                this.socket.off("connect");
                this.socket.off("close");
                this.socket.off("error");
                this.socket.off("message");
                this.socket.close();
            }
        } catch (e) {}

        this.socket = null;
        this.connectionState = "disconnected";
        this.notifyDisconnected(new TCPResultType({ code: 0, data: "Disconnected successfully" }));
    }

    // 发送消息
    sendMessage(message: string): void {
        if (this.connectionState !== "connected" || !this.socket) {
            this.notifyError(new TCPResultType({ code: 5, error: "Client not connected" }));
            return;
        }

        try {
            const data = util.encodeUtf8(message + "\n");
            this.socket.send(data.buffer);
        } catch (e) {
            this.notifyError(new TCPResultType({ code: 6, error: "Send failed" }));
        }
    }

    // 接收消息
    private startMessageReceiver(): void {
        if (!this.socket) return;

        this.socket.on("message", (data) => {
            try {
                const msg = util.decodeUtf8(new Uint8Array(data));
                if (msg.trim().length > 0) {
                    this.notifyMessage(msg);
                }
            } catch (e) {}
        });
    }

    // 心跳
    private startHeartbeat(): void {
        if (!this.heartbeatEnabled || this.connectionState !== "connected") return;
        this.stopHeartbeat();

        this.heartbeatTimer = setInterval(() => {
            if (this.connectionState === "connected") {
                this.sendMessage(this.heartbeatMessage);
            }
        }, this.heartbeatInterval);
    }

    private stopHeartbeat(): void {
        if (this.heartbeatTimer) {
            clearInterval(this.heartbeatTimer);
            this.heartbeatTimer = null;
        }
    }

    enableHeartbeat(interval: number = 30000, message: string = "HEARTBEAT"): void {
        this.heartbeatEnabled = true;
        this.heartbeatInterval = interval;
        this.heartbeatMessage = message;
        if (this.connectionState === "connected") this.startHeartbeat();
    }

    disableHeartbeat(): void {
        this.heartbeatEnabled = false;
        this.stopHeartbeat();
    }

    // 回调注册
    onConnected(callback: ConnectedCallbackType): void { this.connectedCallback = callback; }
    onDisconnected(callback: DisconnectedCallbackType): void { this.disconnectedCallback = callback; }
    onMessage(callback: MessageCallbackType): void { this.messageCallback = callback; }
    onError(callback: ErrorCallbackType): void { this.errorCallback = callback; }

    // 通知
    private notifyConnected(result: TCPResultType): void { this.connectedCallback?.(this.clientId, result); }
    private notifyDisconnected(result: TCPResultType): void { this.disconnectedCallback?.(this.clientId, result); }
    private notifyMessage(message: string): void { this.messageCallback?.(this.clientId, message); }
    private notifyError(result: TCPResultType): void { this.errorCallback?.(this.clientId, result); }

    getConnectionState(): string { return this.connectionState; }
    destroy(): void {
        this.disconnect();
        this.connectedCallback = null;
        this.disconnectedCallback = null;
        this.messageCallback = null;
        this.errorCallback = null;
    }
}

同目录TCPClientManager.ets

import { TCPClient, TCPResultType, ConnectionOptionsType } from './TCPClient';

// 回调类型定义
type ConnectedCallbackType = (clientId: string, result: TCPResultType) => void;
type DisconnectedCallbackType = (clientId: string, result: TCPResultType) => void;
type MessageCallbackType = (clientId: string, message: string) => void;
type ErrorCallbackType = (clientId: string, result: TCPResultType) => void;

// 全局单例管理
export class TCPClientManager {
    private static instance: TCPClientManager;
    private activeClients: Map<string, TCPClient> = new Map();

    // 🔥 保存回调引用
    private connectedCallbacks: Map<string, ConnectedCallbackType> = new Map();
    private disconnectedCallbacks: Map<string, DisconnectedCallbackType> = new Map();
    private messageCallbacks: Map<string, MessageCallbackType> = new Map();
    private errorCallbacks: Map<string, ErrorCallbackType> = new Map();

    private constructor() {}

    // 单例
    public static getInstance(): TCPClientManager {
        if (!this.instance) {
            this.instance = new TCPClientManager();
        }
        return this.instance;
    }

    // 🔥 创建客户端
    createTCPClient(): string {
        const clientId = `client_${Date.now()}_${Math.floor(Math.random() * 900000) + 100000}`;
        const client = new TCPClient(clientId);
        this.activeClients.set(clientId, client);
        return clientId;
    }

    // 获取或创建客户端
    getOrCreateClient(clientId: string): TCPClient {
        let client = this.activeClients.get(clientId);
        if (!client) {
            client = new TCPClient(clientId);
            this.activeClients.set(clientId, client);
        }
        return client;
    }

    // 🔥 连接客户端
    connectClient(clientId: string, options: ConnectionOptionsType): void {
        const client = this.activeClients.get(clientId);
        if (client) {
            // 先注册回调
            if (this.connectedCallbacks.has(clientId)) {
                client.onConnected(this.connectedCallbacks.get(clientId)!);
            }
            if (this.disconnectedCallbacks.has(clientId)) {
                client.onDisconnected(this.disconnectedCallbacks.get(clientId)!);
            }
            if (this.messageCallbacks.has(clientId)) {
                client.onMessage(this.messageCallbacks.get(clientId)!);
            }
            if (this.errorCallbacks.has(clientId)) {
                client.onError(this.errorCallbacks.get(clientId)!);
            }

            client.connect(options);
        }
    }

    // 🔥 断开连接
    disconnectClient(clientId: string): void {
        const client = this.activeClients.get(clientId);
        if (client) {
            client.disconnect();
        }
    }

    // 🔥 发送消息
    sendMessage(clientId: string, message: string): void {
        const client = this.activeClients.get(clientId);
        if (client) {
            client.sendMessage(message);
        }
    }

    // 🔥 注册回调
    onConnected(clientId: string, callback: ConnectedCallbackType): void {
        this.connectedCallbacks.set(clientId, callback);
        const client = this.activeClients.get(clientId);
        if (client) {
            client.onConnected(callback);
        }
    }

    onDisconnected(clientId: string, callback: DisconnectedCallbackType): void {
        this.disconnectedCallbacks.set(clientId, callback);
        const client = this.activeClients.get(clientId);
        if (client) {
            client.onDisconnected(callback);
        }
    }

    onMessage(clientId: string, callback: MessageCallbackType): void {
        this.messageCallbacks.set(clientId, callback);
        const client = this.activeClients.get(clientId);
        if (client) {
            client.onMessage(callback);
        }
    }

    onError(clientId: string, callback: ErrorCallbackType): void {
        this.errorCallbacks.set(clientId, callback);
        const client = this.activeClients.get(clientId);
        if (client) {
            client.onError(callback);
        }
    }

    // 🔥 获取活跃客户端列表
    getActiveClients(): string[] {
        return Array.from(this.activeClients.keys());
    }

    // 🔥 检查客户端是否存在
    clientExists(clientId: string): boolean {
        return this.activeClients.has(clientId);
    }

    // 🔥 启用心跳
    enableHeartbeat(clientId: string, interval: number = 30000, message: string = "HEARTBEAT"): void {
        const client = this.activeClients.get(clientId);
        if (client) {
            client.enableHeartbeat(interval, message);
        }
    }

    // 🔥 禁用心跳
    disableHeartbeat(clientId: string): void {
        const client = this.activeClients.get(clientId);
        if (client) {
            client.disableHeartbeat();
        }
    }

    // 获取状态
    getClientState(clientId: string): string {
        return this.activeClients.get(clientId)?.getConnectionState() ?? "disconnected";
    }

    // 销毁指定客户端
    destroyClient(clientId: string): void {
        const client = this.activeClients.get(clientId);
        if (client) {
            client.destroy();
            this.activeClients.delete(clientId);
            // 清理回调
            this.connectedCallbacks.delete(clientId);
            this.disconnectedCallbacks.delete(clientId);
            this.messageCallbacks.delete(clientId);
            this.errorCallbacks.delete(clientId);
        }
    }

    // 销毁所有
    destroyAllClients(): void {
        this.activeClients.forEach(client => client.destroy());
        this.activeClients.clear();
        this.connectedCallbacks.clear();
        this.disconnectedCallbacks.clear();
        this.messageCallbacks.clear();
        this.errorCallbacks.clear();
    }
}

// 导出给外部使用
const redTcpManager = TCPClientManager.getInstance();
export default redTcpManager;

同目录TCPServer.ets

package uts.sdk.modules.redTcp

import socket from '@ohos.net.socket';
import util from '@ohos.util';

// 回调类型定义
type ServerStartedCallback = () => void;
type ClientConnectedCallback = (clientId: string) => void;
type ClientDisconnectedCallback = (clientId: string) => void;
type ServerMessageCallback = (clientId: string, message: string) => void;
type ServerErrorCallback = (message: string) => void;

export class TCPServer {
    // 回调函数
    public onStarted: ServerStartedCallback | null = null;
    public onClientConnected: ClientConnectedCallback | null = null;
    public onClientDisconnected: ClientDisconnectedCallback | null = null;
    public onMessageReceived: ServerMessageCallback | null = null;
    public onError: ServerErrorCallback | null = null;

    // 🔥 服务相关 - 使用正确的 API
    private serverSocket: socket.TCPSocketServer | null = null;
    private isRunning: boolean = false;
    private clients: Map<string, socket.TCPSocketConnection> = new Map();

    // 启动服务
    start(port: number): void {
        if (this.isRunning) return;

        try {
            // 🔥 创建 TCP 服务器实例
            this.serverSocket = socket.constructTCPSocketServerInstance();
            this.isRunning = true;

            // 🔥 监听连接事件
            this.serverSocket.on('connect', (client: socket.TCPSocketConnection) => {
                const remoteInfo = client.remoteInfo;
                const clientId = `${remoteInfo.address}:${remoteInfo.port}`;

                this.clients.set(clientId, client);

                // 🔥 为每个客户端设置消息监听
                client.on('message', (value: socket.SocketMessageInfo) => {
                    try {
                        const msg = util.decodeUtf8(new Uint8Array(value.message));

                        // 按换行符分割消息
                        let buffer = msg;
                        let newlineIndex: number;
                        while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
                            const line = buffer.substring(0, newlineIndex);
                            buffer = buffer.substring(newlineIndex + 1);

                            const trimmedMsg = line.trim();
                            if (trimmedMsg.length > 0) {
                                this.messageReceived(clientId, trimmedMsg);
                            }
                        }
                    } catch (e) {
                        console.error(`Message decode error: ${e}`);
                    }
                });

                // 🔥 监听客户端关闭
                client.on('close', () => {
                    this.clientDisconnected(clientId);
                });

                // 🔥 监听客户端错误
                client.on('error', (err: Error) => {
                    console.error(`Client ${clientId} error: ${err.message}`);
                    this.clientDisconnected(clientId);
                });

                // 通知新客户端连接
                if (this.onClientConnected) {
                    this.onClientConnected(clientId);
                }
            });

            // 🔥 监听服务器错误
            this.serverSocket.on('error', (err: Error) => {
                this.isRunning = false;
                if (this.onError) {
                    this.onError(`Server error: ${err.message}`);
                }
            });

            // 🔥 绑定并监听端口
            const listenAddr: socket.NetAddress = {
                address: '0.0.0.0',
                port: port,
                family: 1  // IPv4
            };

            this.serverSocket.listen(listenAddr, (err: Error) => {
                if (err) {
                    this.isRunning = false;
                    if (this.onError) {
                        this.onError(`Failed to listen: ${err.message}`);
                    }
                } else {
                    // 🔥 监听成功，触发回调
                    if (this.onStarted) {
                        this.onStarted();
                    }
                }
            });

        } catch (e: any) {
            this.isRunning = false;
            if (this.onError) {
                this.onError(`Failed to start server: ${e.message}`);
            }
        }
    }

    // 停止服务
    stop(): void {
        this.isRunning = false;

        // 关闭所有客户端
        this.clients.forEach((client, clientId) => {
            try {
                client.off('message');
                client.off('close');
                client.off('error');
                client.close();
            } catch (e) {}
        });
        this.clients.clear();

        // 关闭服务器
        try {
            if (this.serverSocket) {
                this.serverSocket.off('connect');
                this.serverSocket.off('error');
                this.serverSocket.close();
                this.serverSocket = null;
            }
        } catch (e) {}
    }

    // 发送消息给指定客户端
    sendToClient(clientId: string, msg: string): void {
        const client = this.clients.get(clientId);
        if (client) {
            try {
                const messageWithNewline = msg.endsWith('\n') ? msg : msg + '\n';
                const data = util.encodeUtf8(messageWithNewline);
                client.send({ data: data.buffer });
            } catch (e) {
                console.error(`Send to ${clientId} failed: ${e}`);
            }
        }
    }

    // 广播消息
    broadcast(msg: string): void {
        this.clients.forEach((client, clientId) => {
            try {
                const messageWithNewline = msg.endsWith('\n') ? msg : msg + '\n';
                const data = util.encodeUtf8(messageWithNewline);
                client.send({ data: data.buffer });
            } catch (e) {
                console.error(`Broadcast to ${clientId} failed: ${e}`);
            }
        });
    }

    // 获取客户端列表
    getClientList(): string[] {
        return Array.from(this.clients.keys());
    }

    // 客户端断开处理
    clientDisconnected(clientId: string): void {
        const client = this.clients.get(clientId);
        if (client) {
            try {
                client.off('message');
                client.off('close');
                client.off('error');
                client.close();
            } catch (e) {}
        }

        this.clients.delete(clientId);

        if (this.onClientDisconnected) {
            this.onClientDisconnected(clientId);
        }
    }

    // 收到消息处理
    messageReceived(clientId: string, message: string): void {
        if (this.onMessageReceived) {
            this.onMessageReceived(clientId, message);
        }
    }
}

---

结束语

1. 传统 Native 插件（老方案，仍支持）
   叫什么：App 原生语言插件（Java/Android、Objective-C/iOS）
   支持状态：完全支持、不废弃，老项目、旧插件都能用
   开发方式：
   Android：Android Studio 写 Kotlin/Java
   iOS：Xcode 写 Objective-C/Swift
   封装成 .aar / .framework，放到 nativePlugins
   前端用 uni.requireNativePlugin() 调用
2. UTS 插件（新官方主推）
   全称：Uni TypeScript
   定位：替代传统 Native 的跨平台原生方案
   原理：
   一套 .uts 代码
   编译时转：
   Android → Kotlin
   iOS → Swift
   鸿蒙 → ArkTS
   H5 / 小程序 → JS
   真正原生执行，无 JS Bridge、无 WebView、无虚拟机
   支持版本：HBuilderX 3.6+ 全面支持

uni-app 现在依然支持传统 Native（Java/ObjC）原生插件，但官方已经全面主推 UTS，
所以建议后续都用 UTS 来写插件。