Java-Implementierung

Zur Implementierung des Android-TCP-Severs wird eine Klasse SimpleTcpClient als Wrapper für die Klasse Callable angelegt. In der Methode transmit wird die Ansteuerung dieser Klasse gekapselt.

/** 
 * SimpleTcpClient
 * Implementiert einen einfachen TCP-Client. 
 * 
 * @author Ullis Roboter Seite 
 * @version 1.0 
 * @since 2014-08-29 
 */  
public class SimpleTcpClient {  
    /** 
     * Sendet eine Nachricht und liefert die Antwort zurück. 
     * 
     * Nachrichten werden intern mit Cr/Lf terminiert. 
     * 
     * Die IP-Adresse kann mit Hilfe von WiFiUtil.checkIp überprüft werden. 
     *  
     * @param HostName 
     *            IP-Adresse des Servers. 
     * @param Port 
     *            Port für den zugehörigen TCP-Service. 
     * @param Message 
     *            Die zu übertragende Nachricht. 
     * @return Die Antwort des Servers. 
     */  
    public String transmit(String HostName, int Port, String Message) {  
        //...  
    }  
}

Der Aufruf des asynchronen Threads und das Abholen des Funktionsergebnisses erfolgt im Zusammenspiel eines Objekt der ExecutorService-Klasse und der Future-Klasse. Ich hab's irgendwo heraus kopiert.

public String transmit(String HostName, int Port, String Message) {  
    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
    Future<String> future = singleThreadExecutor.submit(new ClientCallable(HostName, Port, Message));  
    try {  
        return future.get(); // get blockiert, bis das Ergebnis zur Verfügung steht!  
    } catch (Exception e) {  
        return e.toString();  
    }  
}

Der eigentliche Datentransfer ist dann wieder recht einfach: Socket zur Übertragung einrichten, Verbindung herstellen, Nachricht senden, Antwort abwarten und zum Schluss die Verbindung wieder schließen

/** 
 * Führt den Datentransfer asynchron aus 
 */  
@Override  
public String call() {  
    Socket client;  
  
    try {  
        client = new Socket();  
        client.connect(new InetSocketAddress(hostName, port), 2000);  
  
        BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));  
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));  
  
        // Antwort aufbereiten  
        String outgoingMsg = message + System.getProperty("line.separator");  
  
        // Antwort senden  
        writer.write(outgoingMsg);  
        writer.flush();  
  
        // auf eine Nachricht des Clients warten  
        String incomingMsg = reader.readLine();  
  
        // Verbindung trennen  
        client.close();  
  
        return incomingMsg;  
    } catch (Exception e) {  
        return "keine Verbindung möglich";  
  
    } // try  
}

Visual Basic Implementierung

.Net erlaubt es, Netzwerkfunktionen im Hauptthread aufzurufen. Ist der Verbindungsaufbau nicht sofort möglich, friert die Applikation für eine kurze Zeit ein. Diese Zeit war aber gefühlt sehr kurz, so dass es nicht lohnenswert ist, hier großen Zusatzaufwand zu betreiben. Die Client-Funktion wird deshalb einfach durch einer statischen Methode zur Verfügung gestellt.

''' <summary>  
 ''' Überträgt eine Nachricht an einen TCP-Server und wartet auf dessen Antwort.  
 ''' </summary>  
 ''' <param name="IpAddress">IP-Adresse des Servers.</param>  
 ''' <param name="Port">Port für den zugehörigen TCP-Service.</param>  
 ''' <param name="Message">Die zu übertragende Nachricht.</param>  
 ''' <returns>Die Antwort des Servers.</returns>  
 ''' <remarks>Nachrichten werden intern mit Cr/Lf terminiert.  
 ''' <para/>Die IP-Adresse kann mit Hilfe von <see cref="WiFiUtil.checkIp">WiFiUtil.checkIp</see> überprüft werden.  
 ''' </remarks>  
  Public Shared Function Transmit(IpAddress As IPAddress, Port As Integer, Message As String) As String  
    ' Verbindung aufbauen  
    Dim tcpClient As New System.Net.Sockets.TcpClient()  
    Try  
       tcpClient.Connect(IpAddress, Port)  
    Catch e As SocketException  
       Return "Verbindung zu " & IpAddress.ToString & ":" & Port & " kann nicht hergestellt werden."  
    End Try  
    Dim RemoteServer As NetworkStream = tcpClient.GetStream()  
    Dim reader As StreamReader = New StreamReader(tcpClient.GetStream())  
    Dim writer As StreamWriter = New StreamWriter(tcpClient.GetStream())  
  
    ' Nachricht übermitteln  
    writer.WriteLine(Message)  
    writer.Flush()  
  
    ' Anwort abwarten  
    Dim answer As String = reader.ReadLine  
  
    ' Verbindung trennen  
    tcpClient.Close()  
  
    Return answer  
 End Function