TCP Java Android Server / C＃Windows客户端通信不起作用

Question

我目前正在尝试为Android设备设置应用程序，该应用程序可以通过TCP连接与同一网络中的设备通信。所说的设备在Windows上运行，因此我创建了一个简单的C＃TCP客户端程序来连接到TCP服务器。当服务器应用程序已经运行并且客户端尝试连接到它时，该连接将建立。双方（服务器/客户端）确认建立了连接。当我通过DataOutputStream将数据发送回客户端时，客户确认他收到了消息。但是，当我尝试从客户端发送数据并尝试通过InputStreamReader在服务器上读取它时，服务器永远不会对传入消息做出反应。

下面是Java Android服务器代码：

public class TCPServer {

    public enum ServerCommands { TURN_OFF }

    private static ServerSocket serverSocket;
    private static final Handler HANDLER = new Handler(Looper.getMainLooper());
    private static final int SERVERPORT = 5040;
    private static final HashMap<InetAddress, ServerClientCommunicationThread> connectedClientThreads = new HashMap<>();

    private interface OnUpdateUIListener {
        void onShowStatus(String status);
    }

    private static OnUpdateUIListener listener;

    public static void InitServer(Consumer<String> showStatus) {

         listener = new OnUpdateUIListener() {
            @Override
            public void onShowStatus(String status) {
                // Use the handler so we're not trying to update the UI from the bg thread
                HANDLER.post(new Runnable(){
                    @Override
                    public void run(){
                        showStatus.accept(status);
                    }
                });
            }
        };

        Thread serverThread = new Thread(new ServerThread());
        serverThread.start();
    }

    public static void OnStop(){
        try {
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void SendMessageToClient(InetAddress clientIP, ServerCommands action){
        ServerClientCommunicationThread clientThread = connectedClientThreads.get(clientIP);
        listener.onShowStatus("Trying to send Data to client!");
        if (clientThread != null)
            clientThread.getHandler().sendEmptyMessage(action.ordinal());
    }

    private static class ServerThread implements Runnable {

        public void run() {
            Socket socket = null;
            try {
                serverSocket = new ServerSocket(SERVERPORT);
            } catch (IOException e) {
                e.printStackTrace();
            }
            boolean error = false;
            while (!Thread.currentThread().isInterrupted() && !error) {
                try {
                    listener.onShowStatus("Start listening for clients!");
                    socket = serverSocket.accept();
                    listener.onShowStatus("Found client: " + socket.getInetAddress());

                    ClientServerCommunicationThread clientCommThread = new ClientServerCommunicationThread(socket);
                    new Thread(clientCommThread).start();

                    ServerClientCommunicationThread serverCommThread = new ServerClientCommunicationThread("CommThread", socket);
                    new Thread(serverCommThread).start();

                    connectedClientThreads.put(serverCommThread.clientSocket.getInetAddress(), serverCommThread);
                } catch (Exception e) {
                    listener.onShowStatus("Could not establish client connection: " + e);
                    error = true;
                }
            }
        }
    }


    private static class ServerClientCommunicationThread extends HandlerThread {

        private DataOutputStream outputStream;
        private Socket clientSocket;
        private Handler commHandler;

        public ServerClientCommunicationThread(String name, Socket clientSocket) {
            super(name);
            try {
                this.clientSocket = clientSocket;
                this.outputStream = new DataOutputStream(clientSocket.getOutputStream());

            } catch (IOException e) {
                e.printStackTrace();
                listener.onShowStatus("ERROR: could not open ReaderStream: " + e);
            }
        }

        @SuppressLint("HandlerLeak")
        @Override
        protected void onLooperPrepared(){
            commHandler = new Handler(){
                @Override
                public void handleMessage(Message msg){
                    try {
                        outputStream.write(msg.what);
                        listener.onShowStatus("Sent action: " + msg.what);
                        outputStream.flush();
                    }
                    catch(Exception e){
                        listener.onShowStatus("Could not send data to client: " + clientSocket.getInetAddress() + " " + e);
                    }
                }
            };
            listener.onShowStatus("Start Server Communication Thread");
        }

        public Handler getHandler(){
            return commHandler;
        }
    }


    private static class ClientServerCommunicationThread extends Thread {

        private BufferedReader input;
        private final Socket clientSocket;

        public ClientServerCommunicationThread(Socket clientSocket){
            super();
            this.clientSocket = clientSocket;
            try{
                this.input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            } catch (IOException e) {
                e.printStackTrace();
                listener.onShowStatus("ERROR: could not open ReaderStream: " + e);
            }
        }

        @Override
        public void run(){
            listener.onShowStatus("Start Client Communication Thread");
            boolean connectionStable = true;
            while (!Thread.currentThread().isInterrupted() && connectionStable) {
                try {
                    String read = input.readLine();
                    //It never reaches this debug message!
                    listener.onShowStatus("Received message: " + read);

                } catch (IOException e) {
                    e.printStackTrace();
                    listener.onShowStatus("ERROR: could not read message: " + e);
                    connectionStable = false;
                }
            }

            try {
                input.close();
                clientSocket.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

下面是我的C＃客户端代码。 我正在为我的C＃代码使用SuperSimpletCP库。

namespace SimpleTCPProgram
{
    internal class TCPClient
    {
        private static SimpleTcpClient tcpClient;
        private static int udpPort = 5041;
        private static int tcpPort = 5040;

        private static string macAddr;

        enum ServerCommands { TURN_OFF = 0 }


        // Main Method
        static public void Main(String[] args)
        {
            InitTCPClient("192.168.1.4");
            Console.ReadKey();
            tcpClient.Send("Hello there");

            Console.WriteLine("Sent data: " + tcpClient.Statistics.SentBytes.ToString());

            Console.ReadKey();
        }

        private static void InitTCPClient(string serverIP)
        {
            try
            {
                tcpClient = new SimpleTcpClient(serverIP + ":" + tcpPort);
                tcpClient.Events.Connected += Events_Connected;
                tcpClient.Events.Disconnected += Events_Disconnected;
                tcpClient.Events.DataReceived += Events_DataReceived;

                tcpClient.Connect();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }

        private static void Events_Connected(object sender, ConnectionEventArgs e)
        {
            Console.WriteLine("Connected to Server: " + e.IpPort);
        }

        private static void Events_Disconnected(object sender, ConnectionEventArgs e)
        {

        }

        private static void Events_DataReceived(object sender, SuperSimpleTcp.DataReceivedEventArgs e)
        {
            string dataString = Encoding.UTF8.GetString(e.Data);
            Console.WriteLine("Received Data: " + dataString);
            
            ServerCommands serverCommand = (ServerCommands)int.Parse(dataString);
            switch (serverCommand)
            {
                case ServerCommands.TURN_OFF:
                    var psi = new ProcessStartInfo("shutdown", "/s /t 0");
                    psi.CreateNoWindow = true;
                    psi.UseShellExecute = false;
                    Process.Start(psi);
                    break;
                default:
                    break;
            }
        }
    }
}

Wireshark似乎确认该消息已发送到服务器。 它甚至抓住了服务器发送给客户端的一条消息。 我正在在没有Internet访问且没有防火墙活动的测试过程中对此进行测试。 我的服务器应用程序具有以下权限：

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" tools:ignore="ManifestOrder"/>
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
    <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE"/>
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

TLDR：我的Android Java服务器没有通过TCP连接发送任何C＃客户端消息。