Kotlin：如何在kotlin 中实现异步socket 连接的异步读取方法和读取结束回调方法？

如何解决Kotlin：如何在kotlin 中实现异步socket 连接的异步读取方法和读取结束回调方法？

目前我的 android 应用程序通过 tcp 套接字与服务器通信，使用同步读写方法

    private val addressstring : String = "192.168.1.200"
    private val port : Int = 33322
    private var socketAddress: InetSocketAddress = InetSocketAddress(addressstring,port)
    private var socket: Socket? = null
    
    fun connect(){
        socket = Socket()
        socketAddress = InetSocketAddress(addressstring,port)
        try{
                socket!!.connect(socketAddress)
        }catch(e : Exception){
              socket!!.close()
        }
    }
    
    fun disconnect(){
         try {
            socket?.shutdownOutput()
        } catch (e: Exception) {}
        try {
            socket?.shutdowninput()
        } catch (e: Exception) {}
        try {
            socket?.close()
        } catch (e: Exception) {}
        socket = null
    }
    
     fun send(data: ByteArray): Int {
        var sentByteCount: Int = -1
        try {
            socket!!.getoutputStream().write(data)
            sentByteCount = data.size
        } catch (e: Exception) {
            throw e
        }
        return sentByteCount
    }
    
    data class Wrapper<T>(
    var value:T
)
    
      fun receive(buffer: Wrapper<ByteArray>): Int {
        val size = buffer.value.size
        var receivedByteCount: Int = -1
        try {
            receivedByteCount = socket!!.getInputStream().read(buffer.value)
        } catch (e: Exception) {
            throw e
        }
        return receivedByteCount
    }

然而，用 C# 编写的服务器总是通过套接字与另一个设备通信，但使用异步读取方法

 public const int BUFFER_SIZE = 4096;

            private string addressstring = "192.168.1.200"
            private int port = 33322
            private int timeout = 5000
            private byte[] _buffer = new byte[BUFFER_SIZE];
            private TcpClient _client;
            private SocketError _socketError;
            private AsyncCallback _callback = new AsyncCallback(ReceiveCallback);
            
            public void connect()
            {
              _client = TCpClient()
              _client.ConnectAsync(addressstring,port).Wait(timeout)
            }
            
            public void receive()
            {
                _client.BeginReceive(_buffer,_buffer.Length,SocketFlags.None,_socketError,_callback,null)
            }
            
            private void receiveCallback(IAsyncResult ar)
            {
                //callback method when it has finished reading asynchronously
            }
            
            public void send()
            {
                 _client.GetStream().Write(_buffer,_buffer.Length);
            }
            
            public void disconnect()
            {
                if (_client.Connected)
                 _client.Close();
            }
            

我需要的是在我的应用程序和设备之间进行通信，因为服务器已经在做。

我试图找出即使在 kotlin 中是否有可能创建一个异步连接，这将使我能够像在 C# 中那样进行异步读取，然后我找到了 AsynchronousSocketChannel。 但是，从文档中可以推断出使用此套接字的可能性与服务器是 AsynchronousServerSocketChannel 套接字这一事实有关，在我的情况下，无法使用它，因为我只能创建客户端。 是否还有其他可能性可以在 Kotlin 中重新创建类似于上面显示的 C# 代码的内容？