Early version of the reconnect feature.

This will probably be not be the final version, but should be is functional as of now.

TS3Config.setLoginCredentials had to be removed. Use TS3(Async)Api.login instead. I might add it in again at a later time to restore backwards-compatibility.

There has also been quite a bit of internal refactoring. If you've directly been accessing the IO part of the API, your code will break. If you absolutely need to have access to these parts of the API, let me know. Else the IO part will stay hidden from the user.

Author: rogermb

src/main/java/com/github/theholywaffle/teamspeak3/KeepAliveThread.java

@@ -26,41 +26,37 @@
  * #L%
  */
 
-import com.github.theholywaffle.teamspeak3.commands.CWhoAmI;
+import java.util.logging.Level;
 
 public class KeepAliveThread extends Thread {
 
 	private static final int SLEEP = 60_000;
 
-	private final TS3Query ts3;
 	private final SocketWriter writer;
+	private final TS3ApiAsync asyncApi;
 
-	public KeepAliveThread(TS3Query ts3, SocketWriter socketWriter) {
+	public KeepAliveThread(SocketWriter writer, TS3ApiAsync asyncApi) {
 		super("[TeamSpeak-3-Java-API] Keep alive");
-		this.ts3 = ts3;
-		this.writer = socketWriter;
+		this.writer = writer;
+		this.asyncApi = asyncApi;
 	}
 
 	@Override
 	public void run() {
-		while (ts3.getSocket() != null && ts3.getSocket().isConnected()
-				&& ts3.getOut() != null && !isInterrupted()) {
-			final long idleTime = writer.getIdleTime();
-			if (idleTime >= SLEEP) {
-				ts3.doCommand(new CWhoAmI());
-				continue;
+		try {
+			while (!isInterrupted()) {
+				final long idleTime = writer.getIdleTime();
+				if (idleTime >= SLEEP) {
+					// Using the asynchronous API so we get InterruptedExceptions
+					asyncApi.whoAmI().get();
+				} else {
+					Thread.sleep(SLEEP - idleTime);
+				}
 			}
-			try {
-				Thread.sleep(SLEEP - idleTime);
-			} catch (final InterruptedException e) {
-				interrupt();
-				break;
-			}
-		}
-
-		if (!isInterrupted()) {
-			TS3Query.log.warning("KeepAlive thread has stopped!");
+		} catch (final InterruptedException e) {
+			// Thread stopped properly, ignore
+		} catch (final Exception e) {
+			TS3Query.log.log(Level.WARNING, "KeepAlive thread has stopped!", e);
 		}
 	}
-
 }

src/main/java/com/github/theholywaffle/teamspeak3/QueryIO.java

@@ -0,0 +1,132 @@
+package com.github.theholywaffle.teamspeak3;
+
+/*
+ * #%L
+ * TeamSpeak 3 Java API
+ * %%
+ * Copyright (C) 2015 Bert De Geyter
+ * %%
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ * #L%
+ */
+
+import com.github.theholywaffle.teamspeak3.api.Callback;
+import com.github.theholywaffle.teamspeak3.api.exception.TS3ConnectionFailedException;
+import com.github.theholywaffle.teamspeak3.commands.Command;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class QueryIO {
+
+	private final Socket socket;
+	private final SocketReader socketReader;
+	private final SocketWriter socketWriter;
+	private final KeepAliveThread keepAlive;
+
+	private final Queue<Command> commandQueue;
+	private final Map<Command, Callback> callbackMap;
+
+	QueryIO(TS3Query query, TS3Config config) {
+		commandQueue = new ConcurrentLinkedQueue<>();
+		callbackMap = Collections.synchronizedMap(new LinkedHashMap<Command, Callback>(16));
+
+		Socket tmpSocket = null;
+		try {
+			tmpSocket = new Socket(config.getHost(), config.getQueryPort());
+			socket = tmpSocket;
+			socketReader = new SocketReader(query, this);
+			socketWriter = new SocketWriter(this, config.getFloodRate().getMs());
+			keepAlive = new KeepAliveThread(socketWriter, query.getAsyncApi());
+		} catch (IOException e) {
+			// Clean up resources and fail
+			if (tmpSocket != null) {
+				try {
+					tmpSocket.close();
+				} catch (IOException ignored) {
+				}
+			}
+
+			throw new TS3ConnectionFailedException(e);
+		}
+
+		// From here on: all resources have been initialized and are non-null
+		socketReader.start();
+		socketWriter.start();
+		keepAlive.start();
+	}
+
+	public void continueFrom(QueryIO io) {
+		if (io == null || io.commandQueue.isEmpty()) return;
+
+		callbackMap.putAll(io.callbackMap);
+		Command lastSent = io.commandQueue.poll();
+		commandQueue.add(lastSent.reset());
+		commandQueue.addAll(io.commandQueue);
+
+		io.commandQueue.clear();
+		io.callbackMap.clear();
+	}
+
+	public void disconnect() {
+		keepAlive.interrupt();
+		socketWriter.interrupt();
+		socketReader.interrupt();
+
+		try {
+			keepAlive.join();
+			socketWriter.join();
+			socketReader.join();
+		} catch (final InterruptedException e) {
+			// Restore the interrupt for the caller
+			Thread.currentThread().interrupt();
+		}
+
+		try {
+			socket.close();
+		} catch (IOException ignored) {
+		}
+	}
+
+	public void queueCommand(Command command, Callback callback) {
+		if (command == null) throw new NullPointerException("Command cannot be null!");
+
+		if (callback != null) {
+			callbackMap.put(command, callback);
+		}
+		commandQueue.add(command);
+	}
+
+	public Socket getSocket() {
+		return socket;
+	}
+
+	public Map<Command, Callback> getCallbackMap() {
+		return callbackMap;
+	}
+
+	public Queue<Command> getCommandQueue() {
+		return commandQueue;
+	}
+}

src/main/java/com/github/theholywaffle/teamspeak3/SocketReader.java

@@ -29,35 +29,33 @@
 import com.github.theholywaffle.teamspeak3.api.Callback;
 import com.github.theholywaffle.teamspeak3.commands.Command;
 
+import java.io.BufferedReader;
 import java.io.IOException;
-import java.util.Collections;
+import java.io.InputStreamReader;
 import java.util.Iterator;
-import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.logging.Level;
 
 public class SocketReader extends Thread {
 
 	private final TS3Query ts3;
-	private final ExecutorService userThreadPool;
-	private final Map<Command, Callback> callbackMap;
+	private final QueryIO io;
+	private final BufferedReader in;
 
-	private String lastEvent;
+	private String lastEvent = "";
 
-	public SocketReader(TS3Query ts3) {
+	public SocketReader(TS3Query ts3Query, QueryIO io) throws IOException {
 		super("[TeamSpeak-3-Java-API] SocketReader");
-		this.ts3 = ts3;
-		this.userThreadPool = Executors.newCachedThreadPool();
-		this.callbackMap = Collections.synchronizedMap(new LinkedHashMap<Command, Callback>());
-		this.lastEvent = "";
+		this.io = io;
+		this.ts3 = ts3Query;
 
+		// Connect
+		this.in = new BufferedReader(new InputStreamReader(io.getSocket().getInputStream(), "UTF-8"));
 		try {
 			int i = 0;
-			while (i < 4 || ts3.getIn().ready()) {
-				TS3Query.log.info("< " + ts3.getIn().readLine());
+			while (i < 4 || in.ready()) {
+				TS3Query.log.info("< " + in.readLine());
 				i++;
 			}
 		} catch (final IOException e) {
@@ -67,13 +65,12 @@ public SocketReader(TS3Query ts3) {
 
 	@Override
 	public void run() {
-		while (ts3.getSocket() != null && ts3.getSocket().isConnected()
-				&& ts3.getIn() != null && !isInterrupted()) {
+		while (!isInterrupted()) {
 			final String line;
 
 			try {
 				// Will block until a full line of text could be read.
-				line = ts3.getIn().readLine();
+				line = in.readLine();
 			} catch (IOException io) {
 				if (!isInterrupted()) {
 					io.printStackTrace();
@@ -87,15 +84,15 @@ public void run() {
 				continue; // The server is sending garbage
 			}
 
-			final Command c = ts3.getCommandList().peek();
+			final Command c = io.getCommandQueue().peek();
 
 			if (line.startsWith("notify")) {
 				TS3Query.log.info("< [event] " + line);
 
 				// Filter out duplicate events for join, quit and channel move events
 				if (isDuplicate(line)) continue;
 
-				userThreadPool.execute(new Runnable() {
+				ts3.submitUserTask(new Runnable() {
 					@Override
 					public void run() {
 						final String arr[] = line.split(" ", 2);
@@ -110,7 +107,7 @@ public void run() {
 						TS3Query.log.severe("TS3 command error: " + c.getError());
 					}
 					c.setAnswered();
-					ts3.getCommandList().remove(c);
+					io.getCommandQueue().remove(c);
 					answerCallback(c);
 				} else {
 					c.feed(line);
@@ -120,13 +117,20 @@ public void run() {
 			}
 		}
 
-		userThreadPool.shutdown();
+		try {
+			in.close();
+		} catch (IOException ignored) {
+			// Ignore
+		}
+
 		if (!isInterrupted()) {
 			TS3Query.log.warning("SocketReader has stopped!");
+			ts3.fireDisconnect();
 		}
 	}
 
 	private void answerCallback(Command c) {
+		final Map<Command, Callback> callbackMap = io.getCallbackMap();
 		final Callback callback = callbackMap.get(c);
 
 		// Command had no callback registered
@@ -143,7 +147,7 @@ private void answerCallback(Command c) {
 			}
 		}
 
-		userThreadPool.execute(new Runnable() {
+		ts3.submitUserTask(new Runnable() {
 			@Override
 			public void run() {
 				try {
@@ -155,10 +159,6 @@ public void run() {
 		});
 	}
 
-	void registerCallback(Command command, Callback callback) {
-		callbackMap.put(command, callback);
-	}
-
 	private boolean isDuplicate(String eventMessage) {
 		if (!(eventMessage.startsWith("notifyclientmoved")
 				|| eventMessage.startsWith("notifycliententerview")

src/main/java/com/github/theholywaffle/teamspeak3/SocketWriter.java

@@ -28,33 +28,38 @@
 
 import com.github.theholywaffle.teamspeak3.commands.Command;
 
+import java.io.IOException;
+import java.io.PrintStream;
+
 public class SocketWriter extends Thread {
 
-	private final TS3Query ts3;
+	private final QueryIO io;
 	private final int floodRate;
+	private final PrintStream out;
 	private volatile long lastCommand = System.currentTimeMillis();
 
-	public SocketWriter(TS3Query ts3, int floodRate) {
+	public SocketWriter(QueryIO io, int floodRate) throws IOException {
 		super("[TeamSpeak-3-Java-API] SocketWriter");
-		this.ts3 = ts3;
+		this.io = io;
 		if (floodRate > 50) {
 			this.floodRate = floodRate;
 		} else {
 			this.floodRate = 50;
 		}
+
+		out = new PrintStream(io.getSocket().getOutputStream(), true, "UTF-8");
 	}
 
 	@Override
 	public void run() {
-		while (ts3.getSocket() != null && ts3.getSocket().isConnected()
-				&& ts3.getOut() != null && !isInterrupted()) {
-			final Command c = ts3.getCommandList().peek();
+		while (!isInterrupted()) {
+			final Command c = io.getCommandQueue().peek();
 			if (c != null && !c.isSent()) {
 				final String msg = c.toString();
 				TS3Query.log.info("> " + msg);
 
 				c.setSent();
-				ts3.getOut().println(msg);
+				out.println(msg);
 				lastCommand = System.currentTimeMillis();
 			}
 			try {
@@ -65,6 +70,8 @@ public void run() {
 			}
 		}
 
+		out.close();
+
 		if (!isInterrupted()) {
 			TS3Query.log.warning("SocketWriter has stopped!");
 		}
@@ -73,5 +80,4 @@ public void run() {
 	public long getIdleTime() {
 		return System.currentTimeMillis() - lastCommand;
 	}
-
 }

src/main/java/com/github/theholywaffle/teamspeak3/TS3Api.java

@@ -2543,7 +2543,6 @@ private boolean kickClients(ReasonIdentifier reason, String message, int... clie
 	 * @return whether the command succeeded or not
 	 *
 	 * @querycommands 1
-	 * @see TS3Config#setLoginCredentials(String, String)
 	 * @see #logout()
 	 */
 	public boolean login(String username, String password) {