envoy/src/main/java/envoy/client/Client.java

package envoy.client;

import java.io.Closeable;
import java.io.IOException;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;

import javax.naming.TimeLimitExceededException;

import envoy.client.util.EnvoyLog;
import envoy.data.*;
import envoy.event.IdGeneratorRequest;
import envoy.util.SerializationUtils;

/**
 * Project: <strong>envoy-client</strong><br>
 * File: <strong>Client.java</strong><br>
 * Created: <strong>28 Sep 2019</strong><br>
 *
 * @author Kai S. K. Engelbart
 * @author Maximilian K&auml;fer
 * @author Leon Hofmeister
 * @since Envoy v0.1-alpha
 */
public class Client implements Closeable {

	private Socket		socket;
	private Receiver	receiver;
	private boolean		online;

	private volatile User	sender;
	private User			recipient;

	private volatile Contacts contacts;

	private Config config = Config.getInstance();

	private static final Logger logger = EnvoyLog.getLogger(Client.class.getSimpleName());

	/**
	 * Enters the online mode by acquiring a user ID from the server. As a
	 * connection has to be established and a handshake has to be made, this method
	 * will block for up to 5 seconds. If the handshake does exceed this time limit,
	 * an exception is thrown.
	 *
	 * @param credentials the login credentials of the user
	 * @param localDB     the local database used to persist the current
	 *                    {@link IdGenerator}
	 * @throws Exception if the online mode could not be entered or the request
	 *                   failed for some other reason
	 * @since Envoy v0.2-alpha
	 */
	public void onlineInit(LoginCredentials credentials, LocalDB localDB) throws Exception {
		// Establish TCP connection
		logger.info(String.format("Attempting connection to server %s:%d...", config.getServer(), config.getPort()));
		socket = new Socket(config.getServer(), config.getPort());
		logger.info("Successfully connected to server.");

		// Create message receiver
		receiver = new Receiver(socket.getInputStream());

		// Register user creation processor
		receiver.registerProcessor(User.class, sender -> { logger.info("Acquired user object " + sender); this.sender = sender; });
		receiver.registerProcessor(Contacts.class, contacts -> { logger.info("Acquired contacts object " + contacts); this.contacts = contacts; });

		// Start receiver
		new Thread(receiver).start();

		// Write login credentials
		logger.finest("Sending login credentials...");
		SerializationUtils.writeBytesWithLength(credentials, socket.getOutputStream());

		// Wait for a maximum of five seconds to acquire the sender object
		long start = System.currentTimeMillis();
		while (sender == null || contacts == null) {
			if (System.currentTimeMillis() - start > 5000) throw new TimeLimitExceededException("Did not log in after 5 seconds");
			Thread.sleep(500);
		}

		logger.info("Handshake completed.");
		online = true;

		// Remove user creation processor
		receiver.removeAllProcessors();

		// Register processors for message and status handling
		receiver.registerProcessor(Message.class, new ReceivedMessageProcessor());
		// TODO: Status handling

		// Process message ID generation
		receiver.registerProcessor(IdGenerator.class, localDB::setIdGenerator);

		// Request a generator if none is present
		if (!localDB.hasIdGenerator() || !localDB.getIdGenerator().hasNext()) requestIdGenerator();
	}

	/**
	 * Sends a message to the server.
	 *
	 * @param message the message to send
	 * @throws IOException if the message does not reach the server
	 * @since Envoy v0.3-alpha
	 */
	public void sendMessage(Message message) throws IOException {
		writeObject(message);
		message.nextStatus();
	}

	/**
	 * Requests a new {@link IdGenerator} from the server.
	 *
	 * @throws IOException if the request does not reach the server
	 * @since Envoy v0.3-alpha
	 */
	public void requestIdGenerator() throws IOException {
		logger.info("Requesting new id generator...");
		writeObject(new IdGeneratorRequest());
	}

	/**
	 * @return a {@code Map<String, User>} of all users on the server with their
	 *         user names as keys
	 * @since Envoy v0.2-alpha
	 */
	public Map<String, User> getUsers() {
		checkOnline();
		Map<String, User> users = new HashMap<>();
		contacts.getContacts().forEach(u -> users.put(u.getName(), u));
		return users;
	}

	@Override
	public void close() throws IOException { if (online) socket.close(); }

	private void writeObject(Object obj) throws IOException {
		checkOnline();
		SerializationUtils.writeBytesWithLength(obj, socket.getOutputStream());
	}

	private void checkOnline() { if (!online) throw new IllegalStateException("Client is not online"); }

	/**
	 * @return the sender object that represents this client.
	 * @since Envoy v0.1-alpha
	 */
	public User getSender() { return sender; }

	/**
	 * Sets the client user which is used to send messages.
	 *
	 * @param sender the client user to set
	 * @since Envoy v0.2-alpha
	 */
	public void setSender(User sender) { this.sender = sender; }

	/**
	 * @return the current recipient of the current chat.
	 * @since Envoy v0.1-alpha
	 */
	public User getRecipient() { return recipient; }

	/**
	 * Sets the recipient.
	 *
	 * @param recipient the recipient to set
	 * @since Envoy v0.1-alpha
	 */
	public void setRecipient(User recipient) { this.recipient = recipient; }

	/**
	 * @return true, if a recipient is selected
	 * @since Envoy v0.1-alpha
	 */
	public boolean hasRecipient() { return recipient != null; }

	/**
	 * @return the {@link Receiver} used by this {@link Client}
	 */
	public Receiver getReceiver() { return receiver; }

	/**
	 * @return {@code true} if a connection to the server could be established
	 * @since Envoy v0.2-alpha
	 */
	public boolean isOnline() { return online; }
}