TCP-Verbindung zwischen Java und Autoit

package com.example.tcpclienttest;


import android.util.Log;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;




public class TCPClient {


    private String serverMessage;
    public static final String SERVERIP = "192.168.0.102"; //your computer IP address
    public static final int SERVERPORT = 4444;
    private OnMessageReceived mMessageListener = null;
    private boolean mRun = false;


    PrintWriter out;
    BufferedReader in;


    /**
     *  Constructor of the class. OnMessagedReceived listens for the messages received from server
     */
    public TCPClient(OnMessageReceived listener) {
        mMessageListener = listener;
    }


    /**
     * Sends the message entered by client to the server
     * @param message text entered by client
     */
    public void sendMessage(String message){
        if (out != null && !out.checkError()) {
            out.println(message);
            out.flush();
        }
    }


    public void stopClient(){
        mRun = false;
    }


    public void run() {


        mRun = true;


        try {
            //here you must put your computer's IP address.
            InetAddress serverAddr = InetAddress.getByName(SERVERIP);


            Log.e("TCP Client", "C: Connecting...");


            //create a socket to make the connection with the server
            Socket socket = new Socket(serverAddr, SERVERPORT);


            Log.e("TCP Client", "C: Socket");

            try {


                //send the message to the server
                out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);


                Log.e("TCP Client", "C: Sent.");


                Log.e("TCP Client", "C: Done.");


                //receive the message which the server sends back
                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));


                //in this while the client listens for the messages sent by the server
                while (mRun) {
                    serverMessage = in.readLine();


                    if (serverMessage != null && mMessageListener != null) {
                        //call the method messageReceived from MyActivity class
                        mMessageListener.messageReceived(serverMessage);
                    }
                    serverMessage = null;


                }




                Log.e("RESPONSE FROM SERVER", "S: Received Message: '" + serverMessage + "'");




            } catch (Exception e) {


                Log.e("TCP", "S: Error", e);


            } finally {
                //the socket must be closed. It is not possible to reconnect to this socket
                // after it is closed, which means a new socket instance has to be created.
                socket.close();
            }


        } catch (Exception e) {


            Log.e("TCP", "C: Error", e);


        }


    }


    //Declare the interface. The method messageReceived(String message) will must be implemented in the MyActivity
    //class at on asynckTask doInBackground
    public interface OnMessageReceived {
        public void messageReceived(String message);
    }

import javax.swing.*;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;


/**
 * The class extends the Thread class so we can receive and send messages at the same time
 */
public class TCPServer extends Thread {


    public static final int SERVERPORT = 4444;
    private boolean running = false;
    private PrintWriter mOut;
    private OnMessageReceived messageListener;


    public static void main(String[] args) {


        //opens the window where the messages will be received and sent
        ServerBoard frame = new ServerBoard();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setVisible(true);


    }


    /**
     * Constructor of the class
     * @param messageListener listens for the messages
     */
    public TCPServer(OnMessageReceived messageListener) {
        this.messageListener = messageListener;
    }




    /**
     * Method to send the messages from server to client
     * @param message the message sent by the server
     */
    public void sendMessage(String message){
        if (mOut != null && !mOut.checkError()) {
            mOut.println(message);
            mOut.flush();
        }
    }


    @Override
    public void run() {
        super.run();


        running = true;


        try {
            System.out.println("S: Connecting...");


            //create a server socket. A server socket waits for requests to come in over the network.
            ServerSocket serverSocket = new ServerSocket(SERVERPORT);


            //create client socket... the method accept() listens for a connection to be made to this socket and accepts it.
            Socket client = serverSocket.accept();
            System.out.println("S: Receiving...");


            try {


                //sends the message to the client
                mOut = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())), true);


                //read the message received from client
                BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));


                //in this while we wait to receive messages from client (it's an infinite loop)
                //this while it's like a listener for messages
                while (running) {
                    String message = in.readLine();


                    if (message != null && messageListener != null) {
                        //call the method messageReceived from ServerBoard class
                        messageListener.messageReceived(message);
                    }
                }


            } catch (Exception e) {
                System.out.println("S: Error");
                e.printStackTrace();
            } finally {
                client.close();
                System.out.println("S: Done.");
            }


        } catch (Exception e) {
            System.out.println("S: Error");
            e.printStackTrace();
        }


    }




    //Declare the interface. The method messageReceived(String message) will must be implemented in the ServerBoard
    //class at on startServer button click
    public interface OnMessageReceived {
        public void messageReceived(String message);
    }


}